@soleri/forge 5.14.10 → 7.0.0

package/src/templates/test-facades.ts

@@ -9,20 +9,29 @@ export function generateFacadesTest(config: AgentConfig): string {
     .map((d) => generateDomainDescribe(config.id, d))
     .join('\n\n');
 
+  const hasDomainPacks = config.domainPacks && config.domainPacks.length > 0;
+  const domainPackDescribes = hasDomainPacks
+    ? config.domainPacks!.map((ref) => generateDomainPackDescribe(config.id, ref)).join('\n\n')
+    : '';
+
   return `import { describe, it, expect, beforeEach, afterEach } from 'vitest';
 import {
   createAgentRuntime,
   createSemanticFacades,
   createDomainFacade,
+  createDomainFacades,${hasDomainPacks ? `\n  loadDomainPacksFromConfig,` : ''}
 } from '@soleri/core';
 import type { AgentRuntime, IntelligenceEntry, OpDefinition, FacadeConfig } from '@soleri/core';
 import { z } from 'zod';
 import { mkdirSync, readFileSync, rmSync, writeFileSync, existsSync } from 'node:fs';
-import { join } from 'node:path';
+import { dirname, join } from 'node:path';
+import { fileURLToPath } from 'node:url';
 import { tmpdir } from 'node:os';
 import { PERSONA } from '../identity/persona.js';
 import { activateAgent, deactivateAgent } from '../activation/activate.js';
-import { injectClaudeMd, injectClaudeMdGlobal, hasAgentMarker } from '../activation/inject-claude-md.js';
+import { injectClaudeMd, injectClaudeMdGlobal, hasAgentMarker, injectAgentsMd, injectAgentsMdGlobal, hasAgentMarkerInAgentsMd } from '../activation/inject-claude-md.js';
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
 
 function makeEntry(overrides: Partial<IntelligenceEntry> = {}): IntelligenceEntry {
   return {
@@ -56,7 +65,7 @@ describe('Facades', () => {
   });
 
 ${domainDescribes}
-
+${domainPackDescribes ? `\n${domainPackDescribes}\n` : ''}
   // ─── Semantic Facades ────────────────────────────────────────
   describe('semantic facades', () => {
     function buildSemanticFacades(): FacadeConfig[] {
@@ -103,6 +112,12 @@ ${domainDescribes}
       expect(opNames).toContain('vault_import');
       expect(opNames).toContain('capture_knowledge');
       expect(opNames).toContain('intake_ingest_book');
+      // Zettelkasten linking ops
+      expect(opNames).toContain('link_entries');
+      expect(opNames).toContain('get_links');
+      expect(opNames).toContain('traverse');
+      expect(opNames).toContain('suggest_links');
+      expect(opNames).toContain('get_orphans');
     });
 
     it('search should query across all domains', async () => {
@@ -300,7 +315,7 @@ ${domainDescribes}
           }),
           handler: async (params) => {
             if (params.deactivate) return deactivateAgent();
-            return activateAgent(runtime.vault, (params.projectPath as string) ?? '.', runtime.planner);
+            return activateAgent(runtime, (params.projectPath as string) ?? '.');
           },
         },
         {
@@ -316,6 +331,19 @@ ${domainDescribes}
             return injectClaudeMd((params.projectPath as string) ?? '.');
           },
         },
+        {
+          name: 'inject_agents_md',
+          description: 'Inject AGENTS.md',
+          auth: 'write',
+          schema: z.object({
+            projectPath: z.string().optional().default('.'),
+            global: z.boolean().optional(),
+          }),
+          handler: async (params) => {
+            if (params.global) return injectAgentsMdGlobal();
+            return injectAgentsMd((params.projectPath as string) ?? '.');
+          },
+        },
         {
           name: 'setup',
           description: 'Setup status',
@@ -389,6 +417,7 @@ ${domainDescribes}
       expect(allOps).not.toContain('identity');
       expect(allOps).not.toContain('activate');
       expect(allOps).not.toContain('inject_claude_md');
+      expect(allOps).not.toContain('inject_agents_md');
       expect(allOps).not.toContain('setup');
     });
 
@@ -412,10 +441,10 @@ ${domainDescribes}
       const activateOp = facade.ops.find((o) => o.name === 'activate')!;
       const result = (await activateOp.handler({ projectPath: '/tmp/nonexistent-test' })) as {
         activated: boolean;
-        persona: { name: string; role: string };
+        origin: { name: string; role: string };
       };
       expect(result.activated).toBe(true);
-      expect(result.persona.name).toBe('${escapeQuotes(config.name)}');
+      expect(result.origin.name).toBe('${escapeQuotes(config.name)}');
     });
 
     it('activate with deactivate flag should return deactivation', async () => {
@@ -447,6 +476,27 @@ ${domainDescribes}
       }
     });
 
+    it('inject_agents_md should create AGENTS.md in temp dir', async () => {
+      const tempDir = join(tmpdir(), 'forge-inject-agents-test-' + Date.now());
+      mkdirSync(tempDir, { recursive: true });
+      try {
+        const facade = buildAgentFacade();
+        const injectOp = facade.ops.find((o) => o.name === 'inject_agents_md')!;
+        const result = (await injectOp.handler({ projectPath: tempDir })) as {
+          injected: boolean;
+          path: string;
+          action: string;
+        };
+        expect(result.injected).toBe(true);
+        expect(result.action).toBe('created');
+        expect(existsSync(result.path)).toBe(true);
+        const content = readFileSync(result.path, 'utf-8');
+        expect(content).toContain('${config.id}:mode');
+      } finally {
+        rmSync(tempDir, { recursive: true, force: true });
+      }
+    });
+
     it('setup should return project and global CLAUDE.md status', async () => {
       const facade = buildAgentFacade();
       const setupOp = facade.ops.find((o) => o.name === 'setup')!;
@@ -462,6 +512,73 @@ ${domainDescribes}
       expect(result.recommendations.length).toBeGreaterThan(0);
     });
   });
+
+  // ─── Capability Registry ───────────────────────────────────
+  describe('Capability Registry', () => {
+    it('should register and resolve capabilities', () => {
+      const { CapabilityRegistry } = require('@soleri/core');
+      const registry = new CapabilityRegistry();
+
+      // Register a test capability
+      const handlers = new Map();
+      handlers.set('test.hello', async () => ({ success: true, data: {}, produced: ['greeting'] }));
+      registry.registerPack(
+        'test-pack',
+        [{ id: 'test.hello', description: 'Test', provides: ['greeting'], requires: [] }],
+        handlers,
+      );
+
+      expect(registry.has('test.hello')).toBe(true);
+      expect(registry.has('test.missing')).toBe(false);
+
+      const resolved = registry.resolve('test.hello');
+      expect(resolved.available).toBe(true);
+    });
+
+    it('should track multiple capabilities from one pack', () => {
+      const { CapabilityRegistry } = require('@soleri/core');
+      const registry = new CapabilityRegistry();
+
+      const handlers = new Map();
+      handlers.set('test.alpha', async () => ({ success: true, data: {}, produced: ['a'] }));
+      handlers.set('test.beta', async () => ({ success: true, data: {}, produced: ['b'] }));
+      registry.registerPack(
+        'multi-pack',
+        [
+          { id: 'test.alpha', description: 'Alpha', provides: ['a'], requires: [] },
+          { id: 'test.beta', description: 'Beta', provides: ['b'], requires: [] },
+        ],
+        handlers,
+      );
+
+      expect(registry.size).toBe(2);
+      expect(registry.has('test.alpha')).toBe(true);
+      expect(registry.has('test.beta')).toBe(true);
+    });
+
+    it('should report missing capabilities in flow validation', () => {
+      const { CapabilityRegistry } = require('@soleri/core');
+      const registry = new CapabilityRegistry();
+
+      const handlers = new Map();
+      handlers.set('vault.search', async () => ({ success: true, data: {}, produced: ['results'] }));
+      registry.registerPack(
+        'core',
+        [{ id: 'vault.search', description: 'Search vault', provides: ['results'], requires: [] }],
+        handlers,
+      );
+
+      const flow = {
+        steps: [
+          { needs: ['vault.search', 'color.validate'] },
+        ],
+      };
+      const validation = registry.validateFlow(flow);
+      expect(validation.valid).toBe(false);
+      expect(validation.available).toContain('vault.search');
+      expect(validation.missing).toContain('color.validate');
+    });
+  });
 });
 `;
 }
@@ -544,6 +661,39 @@ function generateDomainDescribe(agentId: string, domain: string): string {
   });`;
 }
 
+function generateDomainPackDescribe(
+  agentId: string,
+  ref: { name: string; package: string; version?: string },
+): string {
+  return `  describe('domain pack: ${ref.name}', () => {
+    it('should load and validate the domain pack', async () => {
+      const packs = await loadDomainPacksFromConfig([${JSON.stringify(ref)}]);
+      expect(packs.length).toBe(1);
+      expect(packs[0].name).toBe('${ref.name}');
+      expect(packs[0].ops.length).toBeGreaterThan(0);
+    });
+
+    it('should register pack ops in domain facades', async () => {
+      const packs = await loadDomainPacksFromConfig([${JSON.stringify(ref)}]);
+      const facades = createDomainFacades(runtime, '${agentId}', ${JSON.stringify([ref.name])}, packs);
+      expect(facades.length).toBeGreaterThanOrEqual(1);
+      // Pack ops should be present
+      const allOps = facades.flatMap(f => f.ops.map(o => o.name));
+      expect(allOps.length).toBeGreaterThan(5); // More than standard 5
+    });
+
+    it('pack custom ops should be callable', async () => {
+      const packs = await loadDomainPacksFromConfig([${JSON.stringify(ref)}]);
+      const facades = createDomainFacades(runtime, '${agentId}', ${JSON.stringify([ref.name])}, packs);
+      const facade = facades[0];
+      // Test first custom op returns without error
+      const firstOp = facade.ops[0];
+      const result = await firstOp.handler({});
+      expect(result).toBeDefined();
+    });
+  });`;
+}
+
 function escapeQuotes(s: string): string {
   return s.replace(/\\/g, '\\\\').replace(/'/g, "\\'");
 }

package/src/types.ts

@@ -4,9 +4,23 @@ import { z } from 'zod';
 const TONES = ['precise', 'mentor', 'pragmatic'] as const;
 
 /** Where to scaffold host/client integration setup. */
-export const SETUP_TARGETS = ['claude', 'codex', 'both'] as const;
+export const SETUP_TARGETS = ['claude', 'codex', 'opencode', 'both', 'all'] as const;
 export type SetupTarget = (typeof SETUP_TARGETS)[number];
 
+/** Available model presets for agent configuration */
+export const MODEL_PRESETS = [
+  'claude-code-sonnet-4',
+  'claude-code-opus-4',
+  'claude-code-3.7-sonnet',
+  'claude-code-3.5-haiku',
+  'claude-4-sonnet',
+  'claude-4-opus',
+  'gpt-4.1',
+  'gpt-4.1-mini',
+  'gemini-2.5',
+  'gemini-2.5-flash',
+] as const;
+
 /** Agent configuration — everything needed to scaffold */
 export const AgentConfigSchema = z.object({
   /** Agent identifier (kebab-case, used for directory and package name) */
@@ -31,10 +45,39 @@ export const AgentConfigSchema = z.object({
   hookPacks: z.array(z.string()).optional(),
   /** Skills to include (if omitted, all skills are included for backward compat) */
   skills: z.array(z.string()).optional(),
+  /** Primary model for the coder agent */
+  model: z.string().optional().default('claude-code-sonnet-4'),
   /** AI client setup target: Claude Code, Codex, or both */
-  setupTarget: z.enum(SETUP_TARGETS).optional().default('claude'),
+  setupTarget: z.enum(SETUP_TARGETS).optional().default('opencode'),
   /** Enable Telegram transport scaffolding. Default: false. */
   telegram: z.boolean().optional().default(false),
+  /** Enable Cognee vector search integration. Default: false. */
+  cognee: z.boolean().optional().default(false),
+  /** Domain packs — npm packages with custom ops, knowledge, rules, and skills. */
+  domainPacks: z
+    .array(
+      z.object({
+        name: z.string(),
+        package: z.string(),
+        version: z.string().optional(),
+      }),
+    )
+    .optional(),
+  /** Vault connections — link to existing vaults instead of importing knowledge. */
+  vaults: z
+    .array(
+      z.object({
+        /** Display name for this vault connection */
+        name: z.string(),
+        /** Absolute path to the vault SQLite database */
+        path: z.string(),
+        /** Search priority (0-1). Higher = results ranked higher. Default: 0.5 */
+        priority: z.number().min(0).max(1).optional().default(0.5),
+      }),
+    )
+    .optional(),
+  /** @deprecated Use vaults[] instead. Shorthand for a single shared vault at priority 0.6. */
+  sharedVaultPath: z.string().optional(),
 });
 
 export type AgentConfig = z.infer<typeof AgentConfigSchema>;

package/src/utils/detect-domain-packs.ts

@@ -0,0 +1,129 @@
+/**
+ * Auto-detect installed @soleri/domain-* packages.
+ * Scans node_modules for packages matching the pattern.
+ */
+
+import { existsSync, readdirSync, readFileSync } from 'node:fs';
+import { join } from 'node:path';
+
+export interface DetectedDomainPack {
+  /** Display name (e.g., 'design') */
+  name: string;
+  /** npm package name (e.g., '@soleri/domain-design') */
+  package: string;
+  /** Installed version from package.json */
+  version: string;
+}
+
+/**
+ * Scan node_modules/@soleri/ for domain-* packages and return refs
+ * suitable for merging into AgentConfig.domainPacks.
+ *
+ * Walks up from basePath to find the nearest node_modules with @soleri scope.
+ * For each `domain-*` directory found, reads its package.json to extract
+ * name and version, then does a lightweight structural check (the package
+ * must export a default or named 'pack' with name, version, domains, ops fields).
+ *
+ * @param basePath - Directory to start searching from (typically config.outputDir)
+ * @returns Array of detected domain pack references
+ */
+export function detectInstalledDomainPacks(basePath: string): DetectedDomainPack[] {
+  const results: DetectedDomainPack[] = [];
+  const soleriScope = findSoleriScope(basePath);
+  if (!soleriScope) return results;
+
+  let entries: string[];
+  try {
+    entries = readdirSync(soleriScope);
+  } catch {
+    return results;
+  }
+
+  for (const entry of entries) {
+    if (!entry.startsWith('domain-')) continue;
+
+    const packDir = join(soleriScope, entry);
+    const pkgJsonPath = join(packDir, 'package.json');
+
+    if (!existsSync(pkgJsonPath)) continue;
+
+    try {
+      const pkg = JSON.parse(readFileSync(pkgJsonPath, 'utf-8')) as {
+        name?: string;
+        version?: string;
+        main?: string;
+      };
+
+      if (!pkg.name || !pkg.version) continue;
+
+      // Lightweight structural check: look for an index/main file that
+      // would be importable. We don't actually import it (that would
+      // execute arbitrary code at scaffold time), but we verify the
+      // package looks like a domain pack by checking package.json keywords
+      // or the presence of expected exports.
+      if (looksLikeDomainPack(packDir, pkg)) {
+        const shortName = entry.replace(/^domain-/, '');
+        results.push({
+          name: shortName,
+          package: pkg.name,
+          version: pkg.version,
+        });
+      }
+    } catch {
+      // Skip packages with invalid package.json
+    }
+  }
+
+  return results;
+}
+
+/**
+ * Walk up from basePath to find node_modules/@soleri directory.
+ */
+function findSoleriScope(basePath: string): string | null {
+  let current = basePath;
+  const seen = new Set<string>();
+
+  while (current && !seen.has(current)) {
+    seen.add(current);
+    const candidate = join(current, 'node_modules', '@soleri');
+    if (existsSync(candidate)) {
+      return candidate;
+    }
+    const parent = join(current, '..');
+    if (parent === current) break;
+    current = parent;
+  }
+
+  return null;
+}
+
+/**
+ * Lightweight check that a package looks like a domain pack without importing it.
+ * Checks for:
+ * - A soleri-domain-pack keyword in package.json, OR
+ * - An entry point file that exists
+ */
+function looksLikeDomainPack(
+  packDir: string,
+  pkg: { main?: string; keywords?: string[]; exports?: unknown },
+): boolean {
+  // Fast path: keyword-based detection
+  if (Array.isArray(pkg.keywords) && pkg.keywords.includes('soleri-domain-pack')) {
+    return true;
+  }
+
+  // Check that the package has an entry point (main or exports)
+  if (pkg.main) {
+    return existsSync(join(packDir, pkg.main));
+  }
+
+  // Check common entry points
+  for (const candidate of ['dist/index.js', 'index.js', 'dist/index.mjs']) {
+    if (existsSync(join(packDir, candidate))) {
+      return true;
+    }
+  }
+
+  return false;
+}

package/tsconfig.json

@@ -13,7 +13,6 @@
     "sourceMap": true,
     "forceConsistentCasingInFileNames": true,
     "skipLibCheck": true,
-    "noEmitOnError": true,
     "composite": true
   },
   "include": ["src/**/*.ts"],

package/vitest.config.ts

@@ -3,8 +3,7 @@ import { defineConfig } from 'vitest/config';
 export default defineConfig({
   test: {
     environment: 'node',
-    pool: 'forks',
-    poolOptions: { forks: { singleFork: true } },
+    pool: 'threads',
     testTimeout: 30_000,
     coverage: {
       provider: 'v8',