@soleri/forge 0.0.1 → 4.0.0

package/dist/templates/entry-point.js

@@ -0,0 +1,116 @@
+/**
+ * Generate the main index.ts entry point for the agent.
+ */
+export function generateEntryPoint(config) {
+    const facadeImports = config.domains
+        .map((d) => {
+        const fn = `create${pascalCase(d)}Facade`;
+        const file = `${d}.facade.js`;
+        return `import { ${fn} } from './facades/${file}';`;
+    })
+        .join('\n');
+    const facadeCreations = config.domains
+        .map((d) => `    create${pascalCase(d)}Facade(vault, brain),`)
+        .join('\n');
+    return `#!/usr/bin/env node
+
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
+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';
+${facadeImports}
+import { createCoreFacade } from './facades/core.facade.js';
+import { LLMClient } from './llm/llm-client.js';
+import { PERSONA, getPersonaPrompt } from './identity/persona.js';
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+
+async function main(): Promise<void> {
+  // Initialize persistent vault at ~/.${config.id}/vault.db
+  const vaultPath = join(homedir(), '.${config.id}', 'vault.db');
+  const vault = new Vault(vaultPath);
+  console.error(\`[\${PERSONA.name.toLowerCase()}] Vault: \${vaultPath}\`);
+
+  // Load and seed intelligence data
+  const dataDir = join(__dirname, 'intelligence', 'data');
+  const entries = loadIntelligenceData(dataDir);
+  if (entries.length > 0) {
+    const seeded = vault.seed(entries);
+    console.error(\`[\${PERSONA.name.toLowerCase()}] Seeded vault with \${seeded} intelligence entries\`);
+  } else {
+    console.error(\`[\${PERSONA.name.toLowerCase()}] Vault is empty — ready for knowledge capture\`);
+  }
+
+  // Initialize planner at ~/.${config.id}/plans.json
+  const plansPath = join(homedir(), '.${config.id}', 'plans.json');
+  const planner = new Planner(plansPath);
+  console.error(\`[\${PERSONA.name.toLowerCase()}] Planner: \${plansPath}\`);
+
+  // Initialize brain — intelligence layer for ranked search, auto-tagging, dedup
+  const brain = new Brain(vault);
+  console.error(\`[\${PERSONA.name.toLowerCase()}] Brain: vocabulary \${brain.getVocabularySize()} terms\`);
+
+  // Initialize LLM client (optional — works without API keys)
+  const keyPoolFiles = loadKeyPoolConfig('${config.id}');
+  const openaiKeyPool = new KeyPool(keyPoolFiles.openai);
+  const anthropicKeyPool = new KeyPool(keyPoolFiles.anthropic);
+  const llmClient = new LLMClient(openaiKeyPool, anthropicKeyPool);
+  const llmAvail = llmClient.isAvailable();
+  console.error(\`[\${PERSONA.name.toLowerCase()}] LLM: OpenAI \${llmAvail.openai ? 'available' : 'not configured'}, Anthropic \${llmAvail.anthropic ? 'available' : 'not configured'}\`);
+
+  // Create MCP server
+  const server = new McpServer({
+    name: '${config.id}-mcp',
+    version: '1.0.0',
+  });
+
+  // Register persona prompt
+  server.prompt('persona', 'Get agent persona and principles', async () => ({
+    messages: [{ role: 'assistant' as const, content: { type: 'text' as const, text: getPersonaPrompt() } }],
+  }));
+
+  // Create and register facades
+  const facades = [
+${facadeCreations}
+    createCoreFacade(vault, planner, brain, llmClient, openaiKeyPool, anthropicKeyPool),
+  ];
+
+  registerAllFacades(server, facades);
+
+  const stats = vault.stats();
+  console.error(\`[\${PERSONA.name.toLowerCase()}] \${PERSONA.name} — \${PERSONA.role}\`);
+  console.error(\`[\${PERSONA.name.toLowerCase()}] Vault: \${stats.totalEntries} entries across \${Object.keys(stats.byDomain).length} domains\`);
+  console.error(\`[\${PERSONA.name.toLowerCase()}] Registered \${facades.length} facades with \${facades.reduce((sum, f) => sum + f.ops.length, 0)} operations\`);
+
+  // Stdio transport
+  const transport = new StdioServerTransport();
+  await server.connect(transport);
+  console.error(\`[\${PERSONA.name.toLowerCase()}] Connected via stdio transport\`);
+  console.error(\`[\${PERSONA.name.toLowerCase()}] Say "Hello, \${PERSONA.name}!" to activate\`);
+
+  // Graceful shutdown
+  const shutdown = async (): Promise<void> => {
+    console.error(\`[\${PERSONA.name.toLowerCase()}] Shutting down...\`);
+    vault.close();
+    process.exit(0);
+  };
+  process.on('SIGTERM', shutdown);
+  process.on('SIGINT', shutdown);
+}
+
+main().catch((err) => {
+  console.error('[${config.id}] Fatal error:', err);
+  process.exit(1);
+});
+`;
+}
+function pascalCase(s) {
+    return s
+        .split(/[-_\s]+/)
+        .map((w) => w.charAt(0).toUpperCase() + w.slice(1))
+        .join('');
+}
+//# sourceMappingURL=entry-point.js.map

package/dist/templates/entry-point.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"entry-point.js","sourceRoot":"","sources":["../../src/templates/entry-point.ts"],"names":[],"mappings":"AAEA;;GAEG;AACH,MAAM,UAAU,kBAAkB,CAAC,MAAmB;IACpD,MAAM,aAAa,GAAG,MAAM,CAAC,OAAO;SACjC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE;QACT,MAAM,EAAE,GAAG,SAAS,UAAU,CAAC,CAAC,CAAC,QAAQ,CAAC;QAC1C,MAAM,IAAI,GAAG,GAAG,CAAC,YAAY,CAAC;QAC9B,OAAO,YAAY,EAAE,sBAAsB,IAAI,IAAI,CAAC;IACtD,CAAC,CAAC;SACD,IAAI,CAAC,IAAI,CAAC,CAAC;IAEd,MAAM,eAAe,GAAG,MAAM,CAAC,OAAO;SACnC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,aAAa,UAAU,CAAC,CAAC,CAAC,uBAAuB,CAAC;SAC7D,IAAI,CAAC,IAAI,CAAC,CAAC;IAEd,OAAO;;;;;;;;;EASP,aAAa;;;;;;;;yCAQ0B,MAAM,CAAC,EAAE;wCACV,MAAM,CAAC,EAAE;;;;;;;;;;;;;;gCAcjB,MAAM,CAAC,EAAE;wCACD,MAAM,CAAC,EAAE;;;;;;;;;4CASL,MAAM,CAAC,EAAE;;;;;;;;;aASxC,MAAM,CAAC,EAAE;;;;;;;;;;;EAWpB,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;oBA4BG,MAAM,CAAC,EAAE;;;CAG5B,CAAC;AACF,CAAC;AAED,SAAS,UAAU,CAAC,CAAS;IAC3B,OAAO,CAAC;SACL,KAAK,CAAC,SAAS,CAAC;SAChB,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,WAAW,EAAE,GAAG,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC;SAClD,IAAI,CAAC,EAAE,CAAC,CAAC;AACd,CAAC"}

package/dist/templates/facade-factory.d.ts

@@ -0,0 +1 @@
+export declare function generateFacadeFactory(): string;

package/dist/templates/facade-factory.js

@@ -0,0 +1,63 @@
+export function generateFacadeFactory() {
+    return `import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { z } from 'zod';
+import type { FacadeConfig, FacadeResponse } from './types.js';
+
+export function registerFacade(server: McpServer, facade: FacadeConfig): void {
+  const opNames = facade.ops.map((o) => o.name);
+
+  server.tool(
+    facade.name,
+    \`\${facade.description}\\n\\nOperations: \${opNames.join(', ')}\`,
+    {
+      op: z.string().describe(\`Operation: \${opNames.join(' | ')}\`),
+      params: z.record(z.unknown()).optional().default({}).describe('Operation parameters'),
+    },
+    async ({ op, params }): Promise<{ content: Array<{ type: 'text'; text: string }> }> => {
+      const response = await dispatchOp(facade, op, params);
+      return { content: [{ type: 'text' as const, text: JSON.stringify(response, null, 2) }] };
+    },
+  );
+}
+
+async function dispatchOp(
+  facade: FacadeConfig,
+  opName: string,
+  params: Record<string, unknown>,
+): Promise<FacadeResponse> {
+  const op = facade.ops.find((o) => o.name === opName);
+  if (!op) {
+    return {
+      success: false,
+      error: \`Unknown operation "\${opName}" on \${facade.name}. Available: \${facade.ops.map((o) => o.name).join(', ')}\`,
+      op: opName,
+      facade: facade.name,
+    };
+  }
+
+  try {
+    let validatedParams = params;
+    if (op.schema) {
+      const result = op.schema.safeParse(params);
+      if (!result.success) {
+        return { success: false, error: \`Invalid params for \${opName}: \${result.error.message}\`, op: opName, facade: facade.name };
+      }
+      validatedParams = result.data as Record<string, unknown>;
+    }
+
+    const data = await op.handler(validatedParams);
+    return { success: true, data, op: opName, facade: facade.name };
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    return { success: false, error: message, op: opName, facade: facade.name };
+  }
+}
+
+export function registerAllFacades(server: McpServer, facades: FacadeConfig[]): void {
+  for (const facade of facades) {
+    registerFacade(server, facade);
+  }
+}
+`;
+}
+//# sourceMappingURL=facade-factory.js.map

package/dist/templates/facade-factory.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"facade-factory.js","sourceRoot":"","sources":["../../src/templates/facade-factory.ts"],"names":[],"mappings":"AAAA,MAAM,UAAU,qBAAqB;IACnC,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA2DR,CAAC;AACF,CAAC"}

package/dist/templates/facade-types.d.ts

@@ -0,0 +1 @@
+export declare function generateFacadeTypes(): string;

package/dist/templates/facade-types.js

@@ -0,0 +1,46 @@
+export function generateFacadeTypes() {
+    return `import { z } from 'zod';
+
+/** Handler function for a single facade operation */
+export type OpHandler = (params: Record<string, unknown>) => Promise<unknown>;
+
+/** Auth level required for an operation */
+export type AuthLevel = 'read' | 'write' | 'admin';
+
+/** Operation definition within a facade */
+export interface OpDefinition {
+  name: string;
+  description: string;
+  auth: AuthLevel;
+  handler: OpHandler;
+  schema?: z.ZodType;
+}
+
+/** Facade configuration — one MCP tool */
+export interface FacadeConfig {
+  /** MCP tool name */
+  name: string;
+  /** Human-readable description */
+  description: string;
+  /** Domain operations */
+  ops: OpDefinition[];
+}
+
+/** Standard facade response envelope */
+export interface FacadeResponse {
+  success: boolean;
+  data?: unknown;
+  error?: string;
+  op?: string;
+  facade?: string;
+}
+
+export const facadeInputSchema = z.object({
+  op: z.string().describe('Operation name'),
+  params: z.record(z.unknown()).optional().default({}),
+});
+
+export type FacadeInput = z.infer<typeof facadeInputSchema>;
+`;
+}
+//# sourceMappingURL=facade-types.js.map

package/dist/templates/facade-types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"facade-types.js","sourceRoot":"","sources":["../../src/templates/facade-types.ts"],"names":[],"mappings":"AAAA,MAAM,UAAU,mBAAmB;IACjC,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA0CR,CAAC;AACF,CAAC"}

package/dist/templates/inject-claude-md.d.ts

@@ -0,0 +1,11 @@
+import type { AgentConfig } from '../types.js';
+/**
+ * Generates src/activation/inject-claude-md.ts for a new agent.
+ * Provides idempotent CLAUDE.md injection — creates, appends, or updates
+ * the agent's section between HTML comment markers.
+ * Supports both project-level and global (~/.claude/CLAUDE.md) injection.
+ *
+ * Uses array-joined pattern because the generated code contains
+ * template literals (backticks) for path operations and string interpolation.
+ */
+export declare function generateInjectClaudeMd(config: AgentConfig): string;

package/dist/templates/inject-claude-md.js

@@ -0,0 +1,92 @@
+/**
+ * Generates src/activation/inject-claude-md.ts for a new agent.
+ * Provides idempotent CLAUDE.md injection — creates, appends, or updates
+ * the agent's section between HTML comment markers.
+ * Supports both project-level and global (~/.claude/CLAUDE.md) injection.
+ *
+ * Uses array-joined pattern because the generated code contains
+ * template literals (backticks) for path operations and string interpolation.
+ */
+export function generateInjectClaudeMd(config) {
+    const marker = `${config.id}:mode`;
+    return [
+        "import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs';",
+        "import { homedir } from 'node:os';",
+        "import { join } from 'node:path';",
+        "import { getClaudeMdContent, getClaudeMdMarker } from './claude-md-content.js';",
+        '',
+        'export interface InjectResult {',
+        '  injected: boolean;',
+        '  path: string;',
+        "  action: 'created' | 'updated' | 'appended';",
+        '}',
+        '',
+        '/**',
+        ' * Inject into a specific CLAUDE.md file path.',
+        ' * Shared logic for both project-level and global injection.',
+        ' */',
+        'function injectIntoFile(filePath: string): InjectResult {',
+        '  const content = getClaudeMdContent();',
+        '  const marker = getClaudeMdMarker();',
+        `  const startMarker = '<!-- ' + marker + ' -->';`,
+        `  const endMarker = '<!-- /' + marker + ' -->';`,
+        '',
+        '  if (!existsSync(filePath)) {',
+        "    writeFileSync(filePath, content + '\\n', 'utf-8');",
+        "    return { injected: true, path: filePath, action: 'created' };",
+        '  }',
+        '',
+        "  const existing = readFileSync(filePath, 'utf-8');",
+        '',
+        '  if (existing.includes(startMarker)) {',
+        '    const startIdx = existing.indexOf(startMarker);',
+        '    const endIdx = existing.indexOf(endMarker);',
+        '    if (endIdx === -1) {',
+        "      const updated = existing.slice(0, startIdx) + content + '\\n' + existing.slice(startIdx + startMarker.length);",
+        "      writeFileSync(filePath, updated, 'utf-8');",
+        "      return { injected: true, path: filePath, action: 'updated' };",
+        '    }',
+        '    const updated = existing.slice(0, startIdx) + content + existing.slice(endIdx + endMarker.length);',
+        "    writeFileSync(filePath, updated, 'utf-8');",
+        "    return { injected: true, path: filePath, action: 'updated' };",
+        '  }',
+        '',
+        "  const separator = existing.endsWith('\\n') ? '\\n' : '\\n\\n';",
+        "  writeFileSync(filePath, existing + separator + content + '\\n', 'utf-8');",
+        "  return { injected: true, path: filePath, action: 'appended' };",
+        '}',
+        '',
+        '/**',
+        ' * Inject agent CLAUDE.md section into a project.',
+        ' * - If no CLAUDE.md exists: creates one',
+        ' * - If markers found: replaces content between them (update)',
+        ' * - If no markers: appends section to end',
+        ' */',
+        'export function injectClaudeMd(projectPath: string): InjectResult {',
+        "  return injectIntoFile(join(projectPath, 'CLAUDE.md'));",
+        '}',
+        '',
+        '/**',
+        ' * Inject agent CLAUDE.md section into the global ~/.claude/CLAUDE.md.',
+        " * Creates ~/.claude/ directory if it doesn't exist.",
+        ' * This makes the activation phrase work in any project.',
+        ' */',
+        'export function injectClaudeMdGlobal(): InjectResult {',
+        "  const claudeDir = join(homedir(), '.claude');",
+        '  if (!existsSync(claudeDir)) {',
+        '    mkdirSync(claudeDir, { recursive: true });',
+        '  }',
+        "  return injectIntoFile(join(claudeDir, 'CLAUDE.md'));",
+        '}',
+        '',
+        '/**',
+        ' * Check if the agent marker exists in a CLAUDE.md file.',
+        ' */',
+        'export function hasAgentMarker(filePath: string): boolean {',
+        '  if (!existsSync(filePath)) return false;',
+        "  const content = readFileSync(filePath, 'utf-8');",
+        `  return content.includes('<!-- ${marker} -->');`,
+        '}',
+    ].join('\n');
+}
+//# sourceMappingURL=inject-claude-md.js.map

package/dist/templates/inject-claude-md.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"inject-claude-md.js","sourceRoot":"","sources":["../../src/templates/inject-claude-md.ts"],"names":[],"mappings":"AAEA;;;;;;;;GAQG;AACH,MAAM,UAAU,sBAAsB,CAAC,MAAmB;IACxD,MAAM,MAAM,GAAG,GAAG,MAAM,CAAC,EAAE,OAAO,CAAC;IAEnC,OAAO;QACL,+EAA+E;QAC/E,oCAAoC;QACpC,mCAAmC;QACnC,iFAAiF;QACjF,EAAE;QACF,iCAAiC;QACjC,sBAAsB;QACtB,iBAAiB;QACjB,+CAA+C;QAC/C,GAAG;QACH,EAAE;QACF,KAAK;QACL,gDAAgD;QAChD,8DAA8D;QAC9D,KAAK;QACL,2DAA2D;QAC3D,yCAAyC;QACzC,uCAAuC;QACvC,kDAAkD;QAClD,iDAAiD;QACjD,EAAE;QACF,gCAAgC;QAChC,wDAAwD;QACxD,mEAAmE;QACnE,KAAK;QACL,EAAE;QACF,qDAAqD;QACrD,EAAE;QACF,yCAAyC;QACzC,qDAAqD;QACrD,iDAAiD;QACjD,0BAA0B;QAC1B,sHAAsH;QACtH,kDAAkD;QAClD,qEAAqE;QACrE,OAAO;QACP,wGAAwG;QACxG,gDAAgD;QAChD,mEAAmE;QACnE,KAAK;QACL,EAAE;QACF,kEAAkE;QAClE,6EAA6E;QAC7E,kEAAkE;QAClE,GAAG;QACH,EAAE;QACF,KAAK;QACL,mDAAmD;QACnD,0CAA0C;QAC1C,+DAA+D;QAC/D,4CAA4C;QAC5C,KAAK;QACL,qEAAqE;QACrE,0DAA0D;QAC1D,GAAG;QACH,EAAE;QACF,KAAK;QACL,wEAAwE;QACxE,sDAAsD;QACtD,0DAA0D;QAC1D,KAAK;QACL,wDAAwD;QACxD,iDAAiD;QACjD,iCAAiC;QACjC,gDAAgD;QAChD,KAAK;QACL,wDAAwD;QACxD,GAAG;QACH,EAAE;QACF,KAAK;QACL,0DAA0D;QAC1D,KAAK;QACL,6DAA6D;QAC7D,4CAA4C;QAC5C,oDAAoD;QACpD,mCAAmC,MAAM,SAAS;QAClD,GAAG;KACJ,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;AACf,CAAC"}

package/dist/templates/intelligence-loader.d.ts

@@ -0,0 +1 @@
+export declare function generateIntelligenceLoader(): string;

package/dist/templates/intelligence-loader.js

@@ -0,0 +1,43 @@
+export function generateIntelligenceLoader() {
+    return `import { readFileSync, readdirSync } from 'node:fs';
+import { join } from 'node:path';
+import type { IntelligenceBundle, IntelligenceEntry } from './types.js';
+
+export function loadIntelligenceData(dataDir: string): IntelligenceEntry[] {
+  const entries: IntelligenceEntry[] = [];
+  let files: string[];
+  try {
+    files = readdirSync(dataDir).filter((f) => f.endsWith('.json'));
+  } catch {
+    console.warn('Intelligence data directory not found: ' + dataDir);
+    return entries;
+  }
+
+  for (const file of files) {
+    try {
+      const raw = readFileSync(join(dataDir, file), 'utf-8');
+      const bundle = JSON.parse(raw) as IntelligenceBundle;
+      if (!bundle.entries || !Array.isArray(bundle.entries)) continue;
+      for (const entry of bundle.entries) {
+        if (validateEntry(entry)) entries.push(entry);
+      }
+    } catch (err) {
+      console.warn('Failed to load ' + file + ': ' + (err instanceof Error ? err.message : err));
+    }
+  }
+  return entries;
+}
+
+function validateEntry(entry: IntelligenceEntry): boolean {
+  return (
+    typeof entry.id === 'string' && entry.id.length > 0 &&
+    ['pattern', 'anti-pattern', 'rule'].includes(entry.type) &&
+    typeof entry.title === 'string' && entry.title.length > 0 &&
+    typeof entry.description === 'string' && entry.description.length > 0 &&
+    ['critical', 'warning', 'suggestion'].includes(entry.severity) &&
+    Array.isArray(entry.tags)
+  );
+}
+`;
+}
+//# sourceMappingURL=intelligence-loader.js.map

package/dist/templates/intelligence-loader.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"intelligence-loader.js","sourceRoot":"","sources":["../../src/templates/intelligence-loader.ts"],"names":[],"mappings":"AAAA,MAAM,UAAU,0BAA0B;IACxC,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAuCR,CAAC;AACF,CAAC"}

package/dist/templates/intelligence-types.d.ts

@@ -0,0 +1 @@
+export declare function generateIntelligenceTypes(): string;

package/dist/templates/intelligence-types.js

@@ -0,0 +1,24 @@
+export function generateIntelligenceTypes() {
+    return `export interface IntelligenceEntry {
+  id: string;
+  type: 'pattern' | 'anti-pattern' | 'rule';
+  domain: string;
+  title: string;
+  severity: 'critical' | 'warning' | 'suggestion';
+  description: string;
+  context?: string;
+  example?: string;
+  counterExample?: string;
+  why?: string;
+  tags: string[];
+  appliesTo?: string[];
+}
+
+export interface IntelligenceBundle {
+  domain: string;
+  version: string;
+  entries: IntelligenceEntry[];
+}
+`;
+}
+//# sourceMappingURL=intelligence-types.js.map

package/dist/templates/intelligence-types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"intelligence-types.js","sourceRoot":"","sources":["../../src/templates/intelligence-types.ts"],"names":[],"mappings":"AAAA,MAAM,UAAU,yBAAyB;IACvC,OAAO;;;;;;;;;;;;;;;;;;;;CAoBR,CAAC;AACF,CAAC"}

package/dist/templates/llm-client.d.ts

@@ -0,0 +1,7 @@
+import type { AgentConfig } from '../types.js';
+/**
+ * Generate the LLM client file for a new agent.
+ * Contains LLMClient (OpenAI fetch + Anthropic SDK) and ModelRouter (inlined).
+ * Uses config.id to resolve ~/.{agentId}/model-routing.json.
+ */
+export declare function generateLLMClient(config: AgentConfig): string;