@soleri/forge 4.0.0 → 4.2.0

package/src/patching.ts

@@ -0,0 +1,123 @@
+/**
+ * Source file patching utilities — shared between knowledge-installer and domain-manager.
+ *
+ * These functions modify an agent's src/index.ts and src/activation/claude-md-content.ts
+ * to register new domain facades and their CLAUDE.md table rows.
+ */
+import { pascalCase } from './templates/domain-facade.js';
+
+/**
+ * Patch the agent's src/index.ts to add imports and facade registrations
+ * for new domains.
+ *
+ * Anchor patterns:
+ * - Import: insert before `import { createCoreFacade }`
+ * - Facade array: insert before `createCoreFacade(`
+ */
+export function patchIndexTs(
+  source: string,
+  newDomains: string[],
+  hasBrain: boolean,
+): string | null {
+  // Filter out domains whose imports already exist (idempotent)
+  const domainsToImport = newDomains.filter((d) => {
+    const fn = `create${pascalCase(d)}Facade`;
+    return !source.includes(`import { ${fn} }`);
+  });
+
+  // Filter out domains whose facade calls already exist
+  const domainsToRegister = newDomains.filter((d) => {
+    const fn = `create${pascalCase(d)}Facade(`;
+    return !source.includes(fn);
+  });
+
+  // Nothing to patch
+  if (domainsToImport.length === 0 && domainsToRegister.length === 0) {
+    return source;
+  }
+
+  let patched = source;
+
+  // ── Insert imports ──
+  if (domainsToImport.length > 0) {
+    const importAnchor = /^(import \{ createCoreFacade \}.*$)/m;
+    if (!importAnchor.test(patched)) return null;
+
+    const newImports = domainsToImport
+      .map((d) => {
+        const fn = `create${pascalCase(d)}Facade`;
+        return `import { ${fn} } from './facades/${d}.facade.js';`;
+      })
+      .join('\n');
+
+    patched = patched.replace(importAnchor, `${newImports}\n$1`);
+  }
+
+  // ── Insert facade creations ──
+  if (domainsToRegister.length > 0) {
+    const facadeAnchor = /^(\s+createCoreFacade\()/m;
+    if (!facadeAnchor.test(patched)) return null;
+
+    const newCreations = domainsToRegister
+      .map((d) => {
+        const fn = `create${pascalCase(d)}Facade`;
+        const args = hasBrain ? 'vault, brain' : 'vault';
+        return `    ${fn}(${args}),`;
+      })
+      .join('\n');
+
+    patched = patched.replace(facadeAnchor, `${newCreations}\n$1`);
+  }
+
+  return patched;
+}
+
+/**
+ * Patch the agent's src/activation/claude-md-content.ts to add
+ * facade table rows for new domains.
+ *
+ * Primary anchor: line containing `| Memory search |` (newer agents)
+ * Fallback anchor: line containing `## Intent Detection` (older agents without memory/brain rows)
+ */
+export function patchClaudeMdContent(
+  source: string,
+  agentId: string,
+  newDomains: string[],
+): string | null {
+  const facadeId = agentId.replace(/-/g, '_');
+  const bt = '`';
+
+  // Filter out domains whose rows already exist (idempotent)
+  const domainsToAdd = newDomains.filter((d) => {
+    const toolName = `${facadeId}_${d.replace(/-/g, '_')}`;
+    return !source.includes(`${toolName}`);
+  });
+
+  if (domainsToAdd.length === 0) return source;
+
+  // Try primary anchor first, then fallback for older agents
+  let anchorIdx = source.indexOf("'| Memory search |");
+  if (anchorIdx === -1) {
+    // Older agents: insert before the empty line preceding ## Intent Detection
+    anchorIdx = source.indexOf("'## Intent Detection'");
+    if (anchorIdx === -1) return null;
+    // Back up to include the preceding empty string line ('',)
+    const emptyLineIdx = source.lastIndexOf("'',", anchorIdx);
+    if (emptyLineIdx !== -1 && anchorIdx - emptyLineIdx < 20) {
+      // Find the start of that line (the indentation)
+      const lineStart = source.lastIndexOf('\n', emptyLineIdx);
+      anchorIdx = lineStart === -1 ? emptyLineIdx : lineStart + 1;
+    }
+  }
+
+  const newRows = domainsToAdd.flatMap((d) => {
+    const toolName = `${facadeId}_${d.replace(/-/g, '_')}`;
+    return [
+      `    '| ${d} patterns | ${bt}${toolName}${bt} | ${bt}get_patterns${bt} |',`,
+      `    '| Search ${d} | ${bt}${toolName}${bt} | ${bt}search${bt} |',`,
+      `    '| Capture ${d} | ${bt}${toolName}${bt} | ${bt}capture${bt} |',`,
+    ];
+  });
+
+  return source.slice(0, anchorIdx) + newRows.join('\n') + '\n' + source.slice(anchorIdx);
+}

package/src/templates/core-facade.ts

@@ -6,20 +6,20 @@ import type { AgentConfig } from '../types.js';
  */
 export function generateCoreFacade(config: AgentConfig): string {
   return `import { z } from 'zod';
-import type { FacadeConfig, Vault, IntelligenceEntry, Planner, Brain, KeyPool } from '@soleri/core';
+import type { FacadeConfig, Vault, IntelligenceEntry, Planner, Brain, KeyPool, CogneeClient } from '@soleri/core';
 import { PERSONA } from '../identity/persona.js';
 import { activateAgent, deactivateAgent } from '../activation/activate.js';
 import { injectClaudeMd, injectClaudeMdGlobal, hasAgentMarker } from '../activation/inject-claude-md.js';
 import type { LLMClient } from '../llm/llm-client.js';
 
-export function createCoreFacade(vault: Vault, planner: Planner, brain: Brain, llmClient?: LLMClient, openaiKeyPool?: KeyPool, anthropicKeyPool?: KeyPool): FacadeConfig {
+export function createCoreFacade(vault: Vault, planner: Planner, brain: Brain, cognee?: CogneeClient, llmClient?: LLMClient, openaiKeyPool?: KeyPool, anthropicKeyPool?: KeyPool): FacadeConfig {
   return {
     name: '${config.id}_core',
     description: 'Core operations — vault stats, cross-domain search, health check, identity, and activation system.',
     ops: [
       {
         name: 'search',
-        description: 'Search across all knowledge domains. Results ranked by TF-IDF + severity + recency + tag overlap + domain match.',
+        description: 'Search across all knowledge domains. Results ranked by TF-IDF + severity + recency + tag overlap + domain match. When Cognee is available, adds vector similarity for hybrid ranking.',
         auth: 'read',
         schema: z.object({
           query: z.string(),
@@ -30,7 +30,7 @@ export function createCoreFacade(vault: Vault, planner: Planner, brain: Brain, l
           limit: z.number().optional(),
         }),
         handler: async (params) => {
-          return brain.intelligentSearch(params.query as string, {
+          return await brain.intelligentSearch(params.query as string, {
             domain: params.domain as string | undefined,
             type: params.type as string | undefined,
             severity: params.severity as string | undefined,
@@ -450,6 +450,66 @@ export function createCoreFacade(vault: Vault, planner: Planner, brain: Brain, l
           };
         },
       },
+      {
+        name: 'cognee_status',
+        description: 'Check Cognee vector search availability and connection status.',
+        auth: 'read',
+        handler: async () => {
+          if (!cognee) return { available: false, message: 'Cognee not configured' };
+          const status = cognee.getStatus();
+          const cfg = cognee.getConfig();
+          return {
+            available: cognee.isAvailable,
+            config: {
+              baseUrl: cfg.baseUrl,
+              dataset: cfg.dataset,
+              timeoutMs: cfg.timeoutMs,
+              searchTimeoutMs: cfg.searchTimeoutMs,
+              healthTimeoutMs: cfg.healthTimeoutMs,
+              healthCacheTtlMs: cfg.healthCacheTtlMs,
+              cognifyDebounceMs: cfg.cognifyDebounceMs,
+              hasApiToken: Boolean(cfg.apiToken),
+              hasServiceCredentials: Boolean(cfg.serviceEmail && cfg.servicePassword),
+            },
+            lastHealth: status,
+          };
+        },
+      },
+      {
+        name: 'cognee_sync',
+        description: 'Force sync all vault entries to Cognee and trigger knowledge graph build. Requires Cognee to be running.',
+        auth: 'write',
+        handler: async () => {
+          if (!cognee?.isAvailable) {
+            return { synced: false, message: 'Cognee not available. Start with: docker compose -f docker/docker-compose.cognee.yml up -d' };
+          }
+          const result = await brain.syncToCognee();
+          return { ok: true, entriesSynced: result.synced, cognified: result.cognified };
+        },
+      },
+      {
+        name: 'graph_search',
+        description: 'Search using Cognee knowledge graph completion. Returns semantically related entries that keyword search might miss.',
+        auth: 'read',
+        schema: z.object({
+          query: z.string(),
+          searchType: z.enum(['SUMMARIES', 'CHUNKS', 'RAG_COMPLETION', 'GRAPH_COMPLETION', 'GRAPH_SUMMARY_COMPLETION', 'NATURAL_LANGUAGE', 'FEELING_LUCKY', 'CHUNKS_LEXICAL']).optional().default('CHUNKS'),
+          limit: z.number().optional().default(10),
+        }),
+        handler: async (params) => {
+          if (!cognee?.isAvailable) {
+            return { results: [], message: 'Cognee not available — use search op for FTS5 results' };
+          }
+          const results = await cognee.search(
+            params.query as string,
+            {
+              searchType: params.searchType as 'SUMMARIES' | 'CHUNKS' | 'GRAPH_COMPLETION',
+              limit: params.limit as number,
+            },
+          );
+          return { results, count: results.length };
+        },
+      },
     ],
   };
 }

package/src/templates/entry-point.ts

@@ -24,7 +24,7 @@ import { dirname, join } from 'node:path';
 import { fileURLToPath } from 'node:url';
 import { homedir } from 'node:os';
 
-import { Vault, Brain, Planner, KeyPool, loadKeyPoolConfig, loadIntelligenceData, registerAllFacades } from '@soleri/core';
+import { Vault, Brain, Planner, KeyPool, CogneeClient, loadKeyPoolConfig, loadIntelligenceData, registerAllFacades } from '@soleri/core';
 ${facadeImports}
 import { createCoreFacade } from './facades/core.facade.js';
 import { LLMClient } from './llm/llm-client.js';
@@ -53,10 +53,29 @@ async function main(): Promise<void> {
   const planner = new Planner(plansPath);
   console.error(\`[\${PERSONA.name.toLowerCase()}] Planner: \${plansPath}\`);
 
+  // Initialize Cognee client (optional — vector search + knowledge graph)
+  // Auto-registers a service account on first use. Override with env vars.
+  const cognee = new CogneeClient({
+    baseUrl: process.env.COGNEE_URL ?? 'http://localhost:8000',
+    dataset: '${config.id}-vault',
+    ...(process.env.COGNEE_API_TOKEN ? { apiToken: process.env.COGNEE_API_TOKEN } : {}),
+    ...(process.env.COGNEE_EMAIL ? { serviceEmail: process.env.COGNEE_EMAIL } : {}),
+    ...(process.env.COGNEE_PASSWORD ? { servicePassword: process.env.COGNEE_PASSWORD } : {}),
+  });
+  await cognee.healthCheck();
+  console.error(\`[\${PERSONA.name.toLowerCase()}] Cognee: \${cognee.isAvailable ? 'available' : 'not running (FTS5 fallback)'}\`);
+
   // Initialize brain — intelligence layer for ranked search, auto-tagging, dedup
-  const brain = new Brain(vault);
+  const brain = new Brain(vault, cognee.isAvailable ? cognee : undefined);
   console.error(\`[\${PERSONA.name.toLowerCase()}] Brain: vocabulary \${brain.getVocabularySize()} terms\`);
 
+  // Background sync vault to Cognee if available
+  if (cognee.isAvailable) {
+    brain.syncToCognee().catch((err) => {
+      console.error(\`[\${PERSONA.name.toLowerCase()}] Cognee sync failed:\`, err);
+    });
+  }
+
   // Initialize LLM client (optional — works without API keys)
   const keyPoolFiles = loadKeyPoolConfig('${config.id}');
   const openaiKeyPool = new KeyPool(keyPoolFiles.openai);
@@ -79,7 +98,7 @@ async function main(): Promise<void> {
   // Create and register facades
   const facades = [
 ${facadeCreations}
-    createCoreFacade(vault, planner, brain, llmClient, openaiKeyPool, anthropicKeyPool),
+    createCoreFacade(vault, planner, brain, cognee.isAvailable ? cognee : undefined, llmClient, openaiKeyPool, anthropicKeyPool),
   ];
 
   registerAllFacades(server, facades);

package/src/templates/package-json.ts

@@ -23,7 +23,7 @@ export function generatePackageJson(config: AgentConfig): string {
     dependencies: {
       '@anthropic-ai/sdk': '^0.39.0',
       '@modelcontextprotocol/sdk': '^1.12.1',
-      '@soleri/core': '^1.0.0',
+      '@soleri/core': '^2.0.0',
       zod: '^3.24.2',
     },
     devDependencies: {

package/src/types.ts

@@ -51,6 +51,18 @@ export interface ScaffoldPreview {
   persona: { name: string; role: string };
 }
 
+/** Result of adding a domain to an existing agent */
+export interface AddDomainResult {
+  success: boolean;
+  agentPath: string;
+  domain: string;
+  agentId: string;
+  facadeGenerated: boolean;
+  buildOutput: string;
+  warnings: string[];
+  summary: string;
+}
+
 /** Result of installing knowledge packs into an existing agent */
 export interface InstallKnowledgeResult {
   success: boolean;

package/dist/templates/brain.d.ts

@@ -1,6 +0,0 @@
-/**
- * Generates the brain.ts source file for a new agent.
- * The Brain provides a local, zero-dependency intelligence layer:
- * TF-IDF scoring, auto-tagging, duplicate detection, and search feedback.
- */
-export declare function generateBrain(): string;