@soleri/core 2.12.0 → 8.0.0

package/src/engine/__tests__/register-engine.test.ts

@@ -0,0 +1,104 @@
+/**
+ * Tests for the direct engine registration (replaces facade factory).
+ *
+ * Validates that registerEngine() produces the same tools and behavior
+ * as the old createSemanticFacades() + registerAllFacades() pattern.
+ */
+
+import { describe, it, expect, beforeAll, afterAll } from 'vitest';
+import { createAgentRuntime } from '../../runtime/runtime.js';
+import { captureOps, executeOp } from '../test-helpers.js';
+import { createVaultFacadeOps } from '../../runtime/facades/vault-facade.js';
+import { createBrainFacadeOps } from '../../runtime/facades/brain-facade.js';
+import { createPlanFacadeOps } from '../../runtime/facades/plan-facade.js';
+import { createCuratorFacadeOps } from '../../runtime/facades/curator-facade.js';
+import { createLoopFacadeOps } from '../../runtime/facades/loop-facade.js';
+import type { AgentRuntime } from '../../runtime/types.js';
+
+let runtime: AgentRuntime;
+
+beforeAll(() => {
+  runtime = createAgentRuntime({
+    agentId: 'test-engine',
+    vaultPath: ':memory:',
+  });
+});
+
+afterAll(() => {
+  runtime.close();
+});
+
+describe('Direct op execution (no facade factory)', () => {
+  it('vault ops work without facade dispatch', async () => {
+    const ops = captureOps(createVaultFacadeOps(runtime));
+
+    // Capture a pattern
+    const captureResult = await executeOp(ops, 'capture_enriched', {
+      projectPath: '.',
+      title: 'Test Pattern',
+      description: 'A test pattern for engine registration',
+      type: 'pattern',
+      category: 'testing',
+      severity: 'suggestion',
+      tags: ['test'],
+    });
+    expect(captureResult.success).toBe(true);
+
+    // Search for it
+    const searchResult = await executeOp(ops, 'search', {
+      query: 'test pattern engine',
+    });
+    expect(searchResult.success).toBe(true);
+    expect(searchResult.data).toBeDefined();
+  });
+
+  it('brain ops work without facade dispatch', async () => {
+    const ops = captureOps(createBrainFacadeOps(runtime));
+
+    const statsResult = await executeOp(ops, 'brain_stats', {});
+    expect(statsResult.success).toBe(true);
+    expect(statsResult.data).toBeDefined();
+  });
+
+  it('plan ops work without facade dispatch', async () => {
+    const ops = captureOps(createPlanFacadeOps(runtime));
+
+    const createResult = await executeOp(ops, 'create_plan', {
+      objective: 'Test objective',
+      scope: 'Test scope',
+    });
+    expect(createResult.success).toBe(true);
+    expect(createResult.data).toBeDefined();
+  });
+
+  it('curator ops work without facade dispatch', async () => {
+    const ops = captureOps(createCuratorFacadeOps(runtime));
+
+    const statusResult = await executeOp(ops, 'curator_status', {});
+    expect(statusResult.success).toBe(true);
+  });
+
+  it('loop ops work without facade dispatch', async () => {
+    const ops = captureOps(createLoopFacadeOps(runtime));
+
+    const statusResult = await executeOp(ops, 'loop_status', {});
+    expect(statusResult.success).toBe(true);
+  });
+
+  it('returns error for unknown ops', async () => {
+    const ops = captureOps(createVaultFacadeOps(runtime));
+
+    const result = await executeOp(ops, 'nonexistent_op', {});
+    expect(result.success).toBe(false);
+    expect(result.error).toContain('Unknown operation');
+  });
+
+  it('response envelope matches old format', async () => {
+    const ops = captureOps(createVaultFacadeOps(runtime));
+
+    const result = await executeOp(ops, 'vault_stats', {}, 'test_vault');
+    expect(result).toHaveProperty('success');
+    expect(result).toHaveProperty('op', 'vault_stats');
+    expect(result).toHaveProperty('facade', 'test_vault');
+  });
+});

package/src/engine/bin/soleri-engine.ts

@@ -0,0 +1,218 @@
+#!/usr/bin/env node
+/**
+ * Soleri Knowledge Engine — MCP Server
+ *
+ * Reads agent.yaml, boots the runtime, registers all tools, connects stdio.
+ *
+ * Usage:
+ *   npx @soleri/engine --agent ./agent.yaml
+ *   node dist/engine/bin/soleri-engine.js --agent ./agent.yaml
+ */
+
+import { readFileSync, existsSync } from 'node:fs';
+import { resolve, dirname, join } from 'node:path';
+import { homedir } from 'node:os';
+import { parse as parseYaml } from 'yaml';
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
+import { createAgentRuntime } from '../../runtime/runtime.js';
+import { registerEngine } from '../register-engine.js';
+import { createCoreOps } from '../core-ops.js';
+import { seedDefaultPlaybooks } from '../../playbooks/playbook-seeder.js';
+import type { AgentIdentityConfig } from '../core-ops.js';
+
+// ─── Parse CLI args ───────────────────────────────────────────────────
+
+function parseArgs(): { agentYamlPath: string } {
+  const args = process.argv.slice(2);
+  let agentYamlPath: string | undefined;
+
+  for (let i = 0; i < args.length; i++) {
+    if (args[i] === '--agent' && args[i + 1]) {
+      agentYamlPath = resolve(args[i + 1]);
+      break;
+    }
+  }
+
+  if (!agentYamlPath) {
+    // Default: look for agent.yaml in cwd
+    agentYamlPath = resolve('agent.yaml');
+  }
+
+  if (!existsSync(agentYamlPath)) {
+    console.error(`[soleri-engine] agent.yaml not found: ${agentYamlPath}`);
+    console.error('Usage: soleri-engine --agent ./agent.yaml');
+    process.exit(1);
+  }
+
+  return { agentYamlPath };
+}
+
+// ─── Main ─────────────────────────────────────────────────────────────
+
+async function main(): Promise<void> {
+  const { agentYamlPath } = parseArgs();
+  const agentDir = dirname(agentYamlPath);
+
+  // 1. Read agent.yaml
+  const raw = readFileSync(agentYamlPath, 'utf-8');
+  const config = parseYaml(raw) as Record<string, unknown>;
+
+  const agentId = config.id as string;
+  const tag = `[${agentId}]`;
+
+  console.error(`${tag} Starting Soleri Knowledge Engine...`);
+  console.error(`${tag} Agent: ${config.name} (${agentId})`);
+  console.error(`${tag} Format: file-tree`);
+
+  // 2. Resolve vault path
+  const engineConfig = (config.engine ?? {}) as Record<string, unknown>;
+  const vaultPath = engineConfig.vault
+    ? resolve((engineConfig.vault as string).replace(/^~/, homedir()))
+    : join(homedir(), `.${agentId}`, 'vault.db');
+
+  // 3. Create runtime
+  const runtime = createAgentRuntime({
+    agentId,
+    vaultPath,
+    agentDir,
+    cognee: (engineConfig.cognee as boolean) ?? false,
+  });
+
+  console.error(`${tag} Vault: ${vaultPath}`);
+  console.error(`${tag} Vault entries: ${runtime.vault.stats().totalEntries}`);
+
+  // 4. Connect linked vaults
+  const vaults = (config.vaults ?? []) as Array<{ name: string; path: string; priority?: number }>;
+  for (const vault of vaults) {
+    try {
+      const vaultAbsPath = resolve(vault.path.replace(/^~/, homedir()));
+      runtime.vaultManager.connect(vault.name, vaultAbsPath, vault.priority ?? 0.5);
+      console.error(`${tag} Linked vault: ${vault.name} (${vaultAbsPath})`);
+    } catch (err) {
+      console.error(
+        `${tag} Warning: failed to connect vault "${vault.name}": ${err instanceof Error ? err.message : String(err)}`,
+      );
+    }
+  }
+
+  // 5. Seed intelligence data from knowledge/ directory
+  const knowledgeDir = join(agentDir, 'knowledge');
+  if (existsSync(knowledgeDir)) {
+    const { readdirSync } = await import('node:fs');
+    const files = readdirSync(knowledgeDir).filter((f: string) => f.endsWith('.json'));
+    for (const file of files) {
+      try {
+        const bundle = JSON.parse(readFileSync(join(knowledgeDir, file), 'utf-8'));
+        if (bundle.entries && Array.isArray(bundle.entries) && bundle.entries.length > 0) {
+          const seeded = runtime.vault.seed(bundle.entries);
+          console.error(`${tag} Seeded ${seeded} entries from ${file}`);
+        }
+      } catch {
+        // Skip invalid bundles
+      }
+    }
+  }
+
+  // 6. Seed default playbooks
+  seedDefaultPlaybooks(runtime.vault);
+
+  // 7. Load domain packs
+  const packs = (config.packs ?? []) as Array<{ name: string; package: string; version?: string }>;
+  const loadedPacks: Array<{ name: string; facades?: Array<{ name: string; ops: unknown[] }> }> =
+    [];
+
+  if (packs.length > 0) {
+    try {
+      const { loadDomainPacksFromConfig } = await import('../../domain-packs/loader.js');
+      const refs = packs.map((p) => ({ name: p.name, package: p.package, version: p.version }));
+      const manifests = await loadDomainPacksFromConfig(refs);
+
+      // Packs activate sequentially — order may matter for dependencies
+      for (const manifest of manifests) {
+        if (manifest.onActivate) {
+          await manifest.onActivate(runtime); // eslint-disable-line no-await-in-loop
+        }
+        loadedPacks.push(manifest);
+        console.error(`${tag} Domain pack: ${manifest.name}`);
+      }
+    } catch (err) {
+      console.error(
+        `${tag} Warning: domain pack loading failed: ${err instanceof Error ? err.message : String(err)}`,
+      );
+    }
+  }
+
+  // 8. Build identity config from agent.yaml
+  const identity: AgentIdentityConfig = {
+    id: agentId,
+    name: config.name as string,
+    role: config.role as string,
+    description: config.description as string,
+    domains: (config.domains ?? []) as string[],
+    principles: (config.principles ?? []) as string[],
+    tone: (config.tone as string) ?? 'pragmatic',
+    greeting: config.greeting as string | undefined,
+  };
+
+  // 9. Create core ops
+  const coreOps = createCoreOps(runtime, identity);
+
+  // 10. Create MCP server
+  const server = new McpServer({
+    name: `${agentId}-engine`,
+    version: '1.0.0',
+  });
+
+  // 11. Register persona prompt
+  server.prompt('persona', 'Get agent persona and principles', () => ({
+    messages: [
+      {
+        role: 'user' as const,
+        content: {
+          type: 'text' as const,
+          text: `You are ${identity.name}. ${identity.role}.\n\nPrinciples:\n${identity.principles.map((p) => `- ${p}`).join('\n')}\n\nTone: ${identity.tone}`,
+        },
+      },
+    ],
+  }));
+
+  // 12. Register all engine tools
+  const { tools, totalOps } = registerEngine(server, runtime, {
+    agentId,
+    coreOps,
+    domains: identity.domains,
+    domainPacks: loadedPacks as Parameters<typeof registerEngine>[2]['domainPacks'],
+    hotOps: [
+      'search_intelligent',
+      'capture_knowledge',
+      'orchestrate_plan',
+      'orchestrate_execute',
+      'orchestrate_complete',
+    ],
+    authPolicy: () => runtime.authPolicy,
+  });
+
+  console.error(`${tag} Registered ${tools.length} tools (${totalOps} ops)`);
+
+  // 13. Connect stdio transport
+  const transport = new StdioServerTransport();
+  await server.connect(transport);
+
+  console.error(`${tag} Engine ready — listening on stdio`);
+
+  // 14. Graceful shutdown
+  const shutdown = () => {
+    console.error(`${tag} Shutting down...`);
+    runtime.close();
+    process.exit(0);
+  };
+
+  process.on('SIGTERM', shutdown);
+  process.on('SIGINT', shutdown);
+}
+
+main().catch((err) => {
+  console.error('[soleri-engine] Fatal:', err);
+  process.exit(1);
+});

package/src/engine/core-ops.ts

@@ -0,0 +1,178 @@
+/**
+ * Soleri v7 — Agent Core Ops
+ *
+ * Generates the agent-specific ops (health, identity, activate, setup)
+ * from agent.yaml config, without generated TypeScript.
+ *
+ * These ops were previously hardcoded in the Forge entry-point template.
+ * Now they're created dynamically by the engine at startup.
+ */
+
+import { z } from 'zod';
+import type { OpDefinition } from '../facades/types.js';
+import type { AgentRuntime } from '../runtime/types.js';
+
+export interface AgentIdentityConfig {
+  id: string;
+  name: string;
+  role: string;
+  description: string;
+  domains: string[];
+  principles: string[];
+  tone: string;
+  greeting?: string;
+}
+
+/**
+ * Create agent-specific core ops from identity config.
+ * These are registered under `{agentId}_core`.
+ */
+export function createCoreOps(
+  runtime: AgentRuntime,
+  identity: AgentIdentityConfig,
+): OpDefinition[] {
+  return [
+    {
+      name: 'health',
+      description: 'Health check — vault status and agent info.',
+      auth: 'read',
+      handler: async () => {
+        const s = runtime.vault.stats();
+        return {
+          status: 'ok',
+          agent: { name: identity.name, role: identity.role, format: 'filetree' },
+          vault: { entries: s.totalEntries, domains: Object.keys(s.byDomain) },
+        };
+      },
+    },
+    {
+      name: 'identity',
+      description: 'Get agent identity — name, role, principles.',
+      auth: 'read',
+      handler: async () => {
+        // Check IdentityManager first (may have evolved via updates)
+        const managed = runtime.identityManager?.getIdentity(identity.id);
+        if (managed) return managed;
+
+        return {
+          name: identity.name,
+          role: identity.role,
+          description: identity.description,
+          domains: identity.domains,
+          principles: identity.principles,
+          tone: identity.tone,
+        };
+      },
+    },
+    {
+      name: 'activate',
+      description: `Activate agent persona. Say "Hello, ${identity.name}!" to trigger.`,
+      auth: 'read',
+      schema: z.object({
+        projectPath: z.string().optional().default('.'),
+        deactivate: z.boolean().optional(),
+      }),
+      handler: async (params) => {
+        if (params.deactivate) {
+          return { deactivated: true, agent: identity.id };
+        }
+
+        // Seed identity on first activation
+        if (runtime.identityManager && !runtime.identityManager.getIdentity(identity.id)) {
+          runtime.identityManager.setIdentity(identity.id, {
+            name: identity.name,
+            role: identity.role,
+            description: identity.description,
+            personality: identity.principles,
+            changedBy: 'system',
+            changeReason: 'Initial identity seeded from agent.yaml',
+          });
+        }
+
+        // Register project if project registry available
+        const projectPath = (params.projectPath as string) ?? '.';
+        if (runtime.projectRegistry) {
+          try {
+            runtime.projectRegistry.register(projectPath);
+          } catch {
+            // Project may already be registered
+          }
+        }
+
+        // Build activation context
+        const s = runtime.vault.stats();
+        return {
+          activated: true,
+          agent: {
+            id: identity.id,
+            name: identity.name,
+            role: identity.role,
+            description: identity.description,
+            format: 'filetree',
+          },
+          persona: {
+            tone: identity.tone,
+            principles: identity.principles,
+            greeting: identity.greeting ?? `Hello! I am ${identity.name}.`,
+          },
+          vault: {
+            connected: true,
+            entries: s.totalEntries,
+            domains: Object.keys(s.byDomain),
+          },
+          domains: identity.domains,
+        };
+      },
+    },
+    {
+      name: 'register',
+      description: 'Register a project for context tracking.',
+      auth: 'write',
+      schema: z.object({
+        projectPath: z.string().default('.'),
+      }),
+      handler: async (params) => {
+        const projectPath = (params.projectPath as string) ?? '.';
+        if (runtime.projectRegistry) {
+          try {
+            const project = runtime.projectRegistry.register(projectPath);
+            return { registered: true, project };
+          } catch {
+            return { registered: false, reason: 'Already registered or error' };
+          }
+        }
+        return { registered: false, reason: 'Project registry not available' };
+      },
+    },
+    {
+      name: 'setup',
+      description: 'Check setup status — vault entries, engine health, domain packs.',
+      auth: 'read',
+      handler: async () => {
+        const s = runtime.vault.stats();
+        return {
+          agent: {
+            id: identity.id,
+            name: identity.name,
+            format: 'filetree',
+          },
+          vault: {
+            entries: s.totalEntries,
+            domains: Object.keys(s.byDomain),
+            byType: s.byType,
+          },
+          engine: {
+            cognee: runtime.cognee !== null && runtime.cognee !== undefined,
+            brain: true,
+            curator: true,
+            planner: true,
+          },
+          recommendations:
+            s.totalEntries === 0
+              ? ['Vault is empty — capture knowledge to start building intelligence']
+              : [],
+        };
+      },
+    },
+  ];
+}

package/src/engine/index.ts

@@ -0,0 +1,19 @@
+/**
+ * Soleri Knowledge Engine — MCP Server Entry Point
+ *
+ * This is the standalone knowledge engine that file-tree agents connect to.
+ * It reads agent.yaml, initializes the runtime, and registers all tools.
+ *
+ * Usage:
+ *   npx @soleri/engine --agent ./agent.yaml
+ *
+ * Or in .mcp.json:
+ *   { "command": "npx", "args": ["@soleri/engine", "--agent", "./agent.yaml"] }
+ *
+ * Binary entry point: ./bin/soleri-engine.ts
+ */
+
+export { registerEngine } from './register-engine.js';
+export type { EngineRegistrationOptions, EngineRegistrationResult } from './register-engine.js';
+export { createCoreOps } from './core-ops.js';
+export type { AgentIdentityConfig } from './core-ops.js';