fix(lint): prefer-const for organizationIdForMemory and currentToolForges

Author: jddunn

README.md

@@ -9,7 +9,7 @@
 **TypeScript runtime for autonomous AI agents — multimodal RAG, cognitive memory, streaming guardrails, voice pipeline, and emergent multi-agent orchestration.**
 
 [![npm version](https://img.shields.io/npm/v/@framers/agentos?style=flat-square&logo=npm&color=cb3837)](https://www.npmjs.com/package/@framers/agentos)
-[![CI](https://img.shields.io/github/actions/workflow/status/framersai/agentos/ci.yml?style=flat-square&logo=github&label=CI)](https://github.com/framersai/agentos/actions)
+[![CI](https://img.shields.io/github/actions/workflow/status/framersai/agentos/ci.yml?branch=master&style=flat-square&logo=github&label=CI)](https://github.com/framersai/agentos/actions/workflows/ci.yml)
 [![codecov](https://codecov.io/gh/framersai/agentos/graph/badge.svg)](https://codecov.io/gh/framersai/agentos)
 [![TypeScript](https://img.shields.io/badge/TypeScript-5.4+-3178c6?style=flat-square&logo=typescript&logoColor=white)](https://www.typescriptlang.org/)
 [![License](https://img.shields.io/badge/License-Apache_2.0-blue?style=flat-square)](https://opensource.org/licenses/Apache-2.0)

docs/memory/CLIENT_SIDE_STORAGE.md

@@ -268,12 +268,12 @@ const storage = await createAgentOSStorage({ platform: 'auto' });
 const agentos = new AgentOS();
 await agentos.initialize({
   storageAdapter: storage.getAdapter(),  // 🆕 Client-side
-  prisma: mockPrisma,  // Stub for compatibility (TODO: make optional)
+  prisma: mockPrisma,  // Compatibility stub while Prisma remains required
   // ...
 });
 ```
 
-**Note:** Currently, AgentOS still requires a Prisma instance. We're working on making it optional when `storageAdapter` is provided.
+**Note:** Client-side AgentOS initialization still expects a Prisma-compatible object even when `storageAdapter` is provided, so keep the stub in place for now.
 
 ---
 
@@ -376,4 +376,3 @@ const storage = new IndexedDbAdapter({
 ---
 
 **TL;DR:** Use `createAgentOSStorage({ platform: 'auto' })` and AgentOS works offline everywhere. IndexedDB for web, better-sqlite3 for desktop, capacitor for mobile.
-

src/api/runtime/TurnExecutionPipeline.ts

@@ -237,7 +237,7 @@ export class TurnExecutionPipeline {
     // -------------------------------------------------------------------
     // Phase 3: Stream context registration
     // -------------------------------------------------------------------
-    let organizationIdForMemory: string | undefined;
+    const organizationIdForMemory: string | undefined;
     const streamContext: PipelineStreamContext = {
       gmi,
       userId: input.userId,

src/api/types/AgentOSInput.ts

@@ -122,6 +122,7 @@ export interface ProcessingOptions {
   temperature?: number;
   topP?: number;
   maxTokens?: number;
+  responseFormat?: { type: 'text' | 'json_object' | string };
   disableAdaptation?: boolean;
   debugMode?: boolean;
   forceNewConversation?: boolean;

src/core/utils/usage/UsageLedger.ts

@@ -34,7 +34,7 @@ export type UsageSummary = UsageBucket;
 /** Persistence adapter contract enabling storage engines. */
 export interface IUsageLedgerPersistence {
   save(bucket: UsageBucket): Promise<void>;
-  loadAll(): Promise<UsageBucket[]>; // For bootstrapping (may be large; future pagination TBD)
+  loadAll(): Promise<UsageBucket[]>; // For bootstrapping only; callers should avoid using this for routine large scans.
 }
 
 /** Options for UsageLedger behavior. */

src/nlp/ai_utilities/StatisticalUtilityAI.ts

@@ -23,6 +23,20 @@ import {
 import * as natural from 'natural';
 import { GMIError, GMIErrorCode } from '@framers/agentos/core/utils/errors';
 
+const NATURAL_STEMMER_LANGUAGE_KEYS: Record<string, string> = {
+  De: 'de',
+  Es: 'es',
+  Fa: 'fa',
+  Fr: 'fr',
+  It: 'it',
+  Nl: 'nl',
+  No: 'no',
+  Pt: 'pt',
+  Ru: 'ru',
+  Sv: 'sv',
+  Uk: 'uk',
+};
+
 // Default English stop words list (can be expanded or loaded from file)
 const DEFAULT_ENGLISH_STOP_WORDS = new Set([
   'i', 'me', 'my', 'myself', 'we', 'our', 'ours', 'ourselves', 'you', 'your', 'yours', 'yourself', 'yourselves',
@@ -85,18 +99,45 @@ export class StatisticalUtilityAI implements IUtilityAI {
   // For sentiment analysis
   private sentimentAnalyzers: Map<string, natural.SentimentAnalyzer>; // language -> analyzer
 
+  private createStemmerRegistry(): Record<string, natural.Stemmer> {
+    const registry: Record<string, natural.Stemmer> = {
+      porter: natural.PorterStemmer,
+      lancaster: natural.LancasterStemmer,
+    };
+
+    const naturalWithVariants = natural as unknown as Record<string, unknown>;
+    for (const [suffix, langCode] of Object.entries(NATURAL_STEMMER_LANGUAGE_KEYS)) {
+      const porterVariant = naturalWithVariants[`PorterStemmer${suffix}`];
+      if (porterVariant && typeof (porterVariant as natural.Stemmer).stem === 'function') {
+        registry[`porter_${langCode}`] = porterVariant as natural.Stemmer;
+      }
+    }
+
+    const carryFrench = naturalWithVariants.CarryStemmerFr;
+    if (carryFrench && typeof (carryFrench as natural.Stemmer).stem === 'function') {
+      registry.carry_fr = carryFrench as natural.Stemmer;
+    }
+
+    const stemmerId = naturalWithVariants.StemmerId;
+    if (stemmerId && typeof (stemmerId as natural.Stemmer).stem === 'function') {
+      registry.default_id = stemmerId as natural.Stemmer;
+    }
+
+    const stemmerJa = naturalWithVariants.StemmerJa;
+    if (stemmerJa && typeof (stemmerJa as natural.Stemmer).stem === 'function') {
+      registry.default_ja = stemmerJa as natural.Stemmer;
+    }
+
+    return registry;
+  }
 
   constructor(utilityId?: string) {
     this.utilityId = utilityId || `stat-utility-${uuidv4()}`;
     this.tokenizers = {
       word: new natural.WordTokenizer(),
       sentence: new natural.SentenceTokenizer(),
     };
-    this.stemmers = {
-      porter: natural.PorterStemmer, // Static access to stem method
-      lancaster: natural.LancasterStemmer, // Static access
-      // PorterStemmerRu, PorterStemmerEs, etc. can be added if 'natural' supports them or via external libraries
-    };
+    this.stemmers = this.createStemmerRegistry();
     this.stopWords = new Map<string, Set<string>>([['en', DEFAULT_ENGLISH_STOP_WORDS]]);
     this.classifiers = new Map();
     this.sentimentAnalyzers = new Map();
@@ -165,11 +206,12 @@ export class StatisticalUtilityAI implements IUtilityAI {
 
   private getStemmer(algorithm?: string, language?: string): natural.Stemmer {
     const algo = (algorithm || 'porter').toLowerCase();
-    // TODO: Add language-specific stemmers from 'natural' if they exist (e.g., PorterStemmerRu)
-    // This requires checking the 'natural' library for available stemmers beyond the basic English ones.
-    // For now, defaults to English Porter if language-specific is not found.
-    if (language && language.toLowerCase() !== 'en' && this.stemmers[`${algo}_${language.toLowerCase()}`]) {
-        return this.stemmers[`${algo}_${language.toLowerCase()}`];
+    const langCode = language?.toLowerCase().split('-')[0];
+    if (langCode && langCode !== 'en' && this.stemmers[`${algo}_${langCode}`]) {
+        return this.stemmers[`${algo}_${langCode}`];
+    }
+    if (langCode && this.stemmers[`default_${langCode}`]) {
+        return this.stemmers[`default_${langCode}`];
     }
     return this.stemmers[algo] || natural.PorterStemmer; // Fallback to Porter
   }
@@ -722,4 +764,3 @@ export class StatisticalUtilityAI implements IUtilityAI {
     console.log(`StatisticalUtilityAI (ID: ${this.utilityId}) shut down.`);
   }
 }
-

src/nlp/ai_utilities/tests/StatisticalUtilityAI.test.ts

@@ -46,6 +46,20 @@ describe('StatisticalUtilityAI', () => {
     expect(summary).toBe("Sentence one. Sentence two.");
   });
 
+  it('should use language-specific stemmers when available', async () => {
+    const spanishStem = await statUtility.stemTokens(['corriendo'], {
+      algorithm: 'porter',
+      language: 'es',
+    });
+    const russianStem = await statUtility.stemTokens(['машины'], {
+      algorithm: 'porter',
+      language: 'ru',
+    });
+
+    expect(spanishStem).toEqual(['corr']);
+    expect(russianStem).toEqual(['машин']);
+  });
+
   it('checkHealth should report as healthy if initialized', async () => {
     const health = await statUtility.checkHealth();
     expect(health.isHealthy).toBe(true);
@@ -56,4 +70,4 @@ describe('StatisticalUtilityAI', () => {
     await expect(statUtility.shutdown?.()).resolves.toBeUndefined();
     // Add any assertions about state after shutdown if applicable
   });
-});
+});