@soleri/forge 4.0.0 → 4.1.0

package/dist/types.d.ts

@@ -72,6 +72,17 @@ export interface ScaffoldPreview {
         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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@soleri/forge",
-  "version": "4.0.0",
+  "version": "4.1.0",
   "description": "Scaffold AI agents that learn, remember, and grow with you.",
   "keywords": [
     "agent",
@@ -26,6 +26,13 @@
   },
   "type": "module",
   "main": "dist/index.js",
+  "exports": {
+    ".": "./dist/index.js",
+    "./lib": {
+      "types": "./dist/lib.d.ts",
+      "import": "./dist/lib.js"
+    }
+  },
   "publishConfig": {
     "access": "public"
   },

package/src/__tests__/knowledge-installer.test.ts

@@ -1,13 +1,9 @@
 import { describe, it, expect, beforeEach, afterEach } from 'vitest';
-import { mkdirSync, rmSync, writeFileSync, readFileSync, existsSync, readdirSync } from 'node:fs';
+import { mkdirSync, rmSync, writeFileSync, readFileSync, existsSync } from 'node:fs';
 import { join } from 'node:path';
 import { tmpdir } from 'node:os';
-import {
-  installKnowledge,
-  patchIndexTs,
-  patchClaudeMdContent,
-  generateVaultOnlyDomainFacade,
-} from '../knowledge-installer.js';
+import { installKnowledge, generateVaultOnlyDomainFacade } from '../knowledge-installer.js';
+import { patchIndexTs, patchClaudeMdContent } from '../patching.js';
 
 describe('Knowledge Installer', () => {
   let tempDir: string;

package/src/domain-manager.ts

@@ -0,0 +1,168 @@
+/**
+ * Domain manager — add new knowledge domains to existing agents.
+ */
+import { existsSync, readFileSync, writeFileSync, mkdirSync } from 'node:fs';
+import { join } from 'node:path';
+import { execFileSync } from 'node:child_process';
+import { generateDomainFacade } from './templates/domain-facade.js';
+import { generateVaultOnlyDomainFacade } from './knowledge-installer.js';
+import { patchIndexTs, patchClaudeMdContent } from './patching.js';
+import type { AddDomainResult } from './types.js';
+
+interface AddDomainParams {
+  agentPath: string;
+  domain: string;
+  noBuild?: boolean;
+}
+
+/**
+ * Add a new knowledge domain to an existing agent.
+ *
+ * Steps:
+ * 1. Validate agent path and domain name
+ * 2. Create empty intelligence bundle
+ * 3. Generate domain facade
+ * 4. Patch src/index.ts with import + registration
+ * 5. Patch src/activation/claude-md-content.ts with facade table rows
+ * 6. Rebuild (unless noBuild)
+ */
+export async function addDomain(params: AddDomainParams): Promise<AddDomainResult> {
+  const { agentPath, domain, noBuild = false } = params;
+  const warnings: string[] = [];
+
+  // ── Validate agent ──
+
+  const pkgPath = join(agentPath, 'package.json');
+  if (!existsSync(pkgPath)) {
+    return fail(agentPath, domain, 'No package.json found — is this an agent project?');
+  }
+
+  let pkg: Record<string, unknown>;
+  try {
+    pkg = JSON.parse(readFileSync(pkgPath, 'utf-8'));
+  } catch {
+    return fail(agentPath, domain, 'Failed to parse package.json — is it valid JSON?');
+  }
+  const pkgName: string = (pkg.name as string) ?? '';
+  if (!pkgName.endsWith('-mcp')) {
+    return fail(agentPath, domain, `package.json name "${pkgName}" does not end with -mcp`);
+  }
+
+  const agentId = pkgName.replace(/-mcp$/, '');
+
+  // ── Validate domain name ──
+
+  if (!/^[a-z][a-z0-9-]*$/.test(domain)) {
+    return fail(agentPath, domain, `Invalid domain name "${domain}" — must be kebab-case`);
+  }
+
+  // ── Check if domain already exists ──
+
+  const dataDir = join(agentPath, 'src', 'intelligence', 'data');
+  if (!existsSync(dataDir)) {
+    return fail(agentPath, domain, 'src/intelligence/data/ directory not found');
+  }
+
+  const bundlePath = join(dataDir, `${domain}.json`);
+  if (existsSync(bundlePath)) {
+    return fail(agentPath, domain, `Domain "${domain}" already exists`);
+  }
+
+  const hasBrain = existsSync(join(agentPath, 'src', 'brain'));
+
+  // ── Step 1: Create empty bundle ──
+
+  const emptyBundle = JSON.stringify({ domain, version: '1.0.0', entries: [] }, null, 2);
+  writeFileSync(bundlePath, emptyBundle, 'utf-8');
+
+  // Also write to dist if it exists
+  const distDataDir = join(agentPath, 'dist', 'intelligence', 'data');
+  if (existsSync(join(agentPath, 'dist'))) {
+    mkdirSync(distDataDir, { recursive: true });
+    writeFileSync(join(distDataDir, `${domain}.json`), emptyBundle, 'utf-8');
+  }
+
+  // ── Step 2: Generate facade ──
+
+  const facadesDir = join(agentPath, 'src', 'facades');
+  const facadePath = join(facadesDir, `${domain}.facade.ts`);
+
+  if (existsSync(facadePath)) {
+    warnings.push(`Facade ${domain}.facade.ts already exists — skipped`);
+  } else {
+    const facadeCode = hasBrain
+      ? generateDomainFacade(agentId, domain)
+      : generateVaultOnlyDomainFacade(agentId, domain);
+    writeFileSync(facadePath, facadeCode, 'utf-8');
+  }
+
+  // ── Step 3: Patch src/index.ts ──
+
+  const indexPath = join(agentPath, 'src', 'index.ts');
+  if (existsSync(indexPath)) {
+    const patched = patchIndexTs(readFileSync(indexPath, 'utf-8'), [domain], hasBrain);
+    if (patched !== null) {
+      writeFileSync(indexPath, patched, 'utf-8');
+    } else {
+      warnings.push('Could not patch src/index.ts — anchor patterns not found');
+    }
+  }
+
+  // ── Step 4: Patch claude-md-content.ts ──
+
+  const claudeMdPath = join(agentPath, 'src', 'activation', 'claude-md-content.ts');
+  if (existsSync(claudeMdPath)) {
+    const patched = patchClaudeMdContent(readFileSync(claudeMdPath, 'utf-8'), agentId, [domain]);
+    if (patched !== null) {
+      writeFileSync(claudeMdPath, patched, 'utf-8');
+    } else {
+      warnings.push('Could not patch claude-md-content.ts — anchor not found');
+    }
+  }
+
+  // ── Step 5: Build ──
+
+  let buildOutput = '';
+  if (!noBuild) {
+    try {
+      buildOutput = execFileSync('npm', ['run', 'build'], {
+        cwd: agentPath,
+        encoding: 'utf-8',
+        timeout: 60_000,
+        stdio: ['pipe', 'pipe', 'pipe'],
+      });
+    } catch (err) {
+      const stderr = (err as { stderr?: string }).stderr ?? '';
+      buildOutput = `Build failed: ${stderr}`;
+      warnings.push('Build failed — check buildOutput for details');
+    }
+  }
+
+  const hasPatchFailure = warnings.some(
+    (w) => w.includes('Could not patch') || w.includes('Build failed'),
+  );
+
+  return {
+    success: !hasPatchFailure,
+    agentPath,
+    domain,
+    agentId,
+    facadeGenerated: !existsSync(facadePath) || !warnings.some((w) => w.includes('already exists')),
+    buildOutput,
+    warnings,
+    summary: `Added domain "${domain}" to ${agentId}${warnings.length > 0 ? ` (${warnings.length} warning(s))` : ''}`,
+  };
+}
+
+function fail(agentPath: string, domain: string, message: string): AddDomainResult {
+  return {
+    success: false,
+    agentPath,
+    domain,
+    agentId: '',
+    facadeGenerated: false,
+    buildOutput: '',
+    warnings: [message],
+    summary: message,
+  };
+}

package/src/facades/forge.facade.ts

@@ -2,6 +2,7 @@ import { z } from 'zod';
 import { scaffold, previewScaffold, listAgents } from '../scaffolder.js';
 import { AgentConfigSchema } from '../types.js';
 import { installKnowledge } from '../knowledge-installer.js';
+import { addDomain } from '../domain-manager.js';
 
 interface OpDef {
   name: string;
@@ -147,4 +148,21 @@ export const forgeOps: OpDef[] = [
         params as { agentPath: string; bundlePath: string; generateFacades?: boolean },
       ),
   },
+  {
+    name: 'add_domain',
+    description:
+      'Add a new knowledge domain to an existing MCP agent. ' +
+      'Creates an empty bundle, generates a domain facade, patches index.ts and claude-md-content.ts, then rebuilds.',
+    schema: z.object({
+      agentPath: z.string().describe('Absolute path to the target agent project'),
+      domain: z.string().describe('Domain name in kebab-case (e.g., "security", "api-design")'),
+      noBuild: z
+        .boolean()
+        .optional()
+        .default(false)
+        .describe('Skip the build step after adding the domain'),
+    }),
+    handler: async (params) =>
+      addDomain(params as { agentPath: string; domain: string; noBuild?: boolean }),
+  },
 ];

package/src/knowledge-installer.ts

@@ -9,6 +9,7 @@ import {
 import { join, basename } from 'node:path';
 import { execFileSync } from 'node:child_process';
 import { generateDomainFacade, pascalCase, capitalize } from './templates/domain-facade.js';
+import { patchIndexTs, patchClaudeMdContent } from './patching.js';
 import type { InstallKnowledgeResult } from './types.js';
 
 // ---------- Bundle validation types ----------
@@ -413,120 +414,4 @@ function validateBundle(bundle: Bundle, file: string): string[] {
   return issues;
 }
 
-// ---------- Source file patching ----------
-
-/**
- * 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);
-}
+// patching functions (patchIndexTs, patchClaudeMdContent) are in patching.ts

package/src/lib.ts

@@ -0,0 +1,19 @@
+/**
+ * @soleri/forge — Public API
+ *
+ * Import this for programmatic access to forge functions.
+ * The main index.ts starts the MCP server — use this for library usage.
+ */
+export { scaffold, previewScaffold, listAgents } from './scaffolder.js';
+export { installKnowledge, generateVaultOnlyDomainFacade } from './knowledge-installer.js';
+export { addDomain } from './domain-manager.js';
+export { patchIndexTs, patchClaudeMdContent } from './patching.js';
+export type {
+  AgentConfig,
+  ScaffoldResult,
+  ScaffoldPreview,
+  AgentInfo,
+  InstallKnowledgeResult,
+  AddDomainResult,
+} from './types.js';
+export { AgentConfigSchema } from './types.js';

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/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;