@soleri/core 2.1.0 → 2.5.0

package/src/__tests__/project-ops.test.ts

@@ -0,0 +1,381 @@
+import { describe, it, expect, afterEach } from 'vitest';
+import { createAgentRuntime } from '../runtime/runtime.js';
+import { createProjectOps } from '../runtime/project-ops.js';
+import type { AgentRuntime } from '../runtime/types.js';
+import type { OpDefinition } from '../facades/types.js';
+
+describe('createProjectOps', () => {
+  let runtime: AgentRuntime;
+  let ops: OpDefinition[];
+
+  function findOp(name: string): OpDefinition {
+    const op = ops.find((o) => o.name === name);
+    if (!op) throw new Error(`Op "${name}" not found`);
+    return op;
+  }
+
+  afterEach(() => {
+    runtime?.close();
+  });
+
+  function setup() {
+    runtime = createAgentRuntime({
+      agentId: 'test-project',
+      vaultPath: ':memory:',
+    });
+    ops = createProjectOps(runtime);
+  }
+
+  it('should return 12 ops', () => {
+    setup();
+    expect(ops).toHaveLength(12);
+    const names = ops.map((o) => o.name);
+    expect(names).toEqual([
+      'project_get',
+      'project_list',
+      'project_unregister',
+      'project_get_rules',
+      'project_list_rules',
+      'project_add_rule',
+      'project_remove_rule',
+      'project_link',
+      'project_unlink',
+      'project_get_links',
+      'project_linked_projects',
+      'project_touch',
+    ]);
+  });
+
+  // ─── Register + Get round-trip ─────────────────────────────────
+
+  describe('register + project_get round-trip', () => {
+    it('should register a project and retrieve it by ID', async () => {
+      setup();
+      const registered = runtime.projectRegistry.register('/tmp/my-project', 'My Project');
+      const result = (await findOp('project_get').handler({
+        projectId: registered.id,
+      })) as { found: boolean; project: { id: string; path: string; name: string } };
+
+      expect(result.found).toBe(true);
+      expect(result.project.path).toBe('/tmp/my-project');
+      expect(result.project.name).toBe('My Project');
+    });
+
+    it('should return found=false for unknown ID', async () => {
+      setup();
+      const result = (await findOp('project_get').handler({
+        projectId: 'nonexistent',
+      })) as { found: boolean; project: null };
+
+      expect(result.found).toBe(false);
+      expect(result.project).toBeNull();
+    });
+  });
+
+  // ─── project_list ──────────────────────────────────────────────
+
+  describe('project_list', () => {
+    it('should list all registered projects', async () => {
+      setup();
+      runtime.projectRegistry.register('/tmp/alpha', 'Alpha');
+      runtime.projectRegistry.register('/tmp/beta', 'Beta');
+
+      const result = (await findOp('project_list').handler({})) as {
+        count: number;
+        projects: Array<{ path: string; name: string }>;
+      };
+
+      expect(result.count).toBe(2);
+      const paths = result.projects.map((p) => p.path);
+      expect(paths).toContain('/tmp/alpha');
+      expect(paths).toContain('/tmp/beta');
+    });
+
+    it('should return empty list when no projects registered', async () => {
+      setup();
+      const result = (await findOp('project_list').handler({})) as {
+        count: number;
+        projects: unknown[];
+      };
+      expect(result.count).toBe(0);
+      expect(result.projects).toEqual([]);
+    });
+  });
+
+  // ─── project_unregister ────────────────────────────────────────
+
+  describe('project_unregister', () => {
+    it('should unregister a project', async () => {
+      setup();
+      const registered = runtime.projectRegistry.register('/tmp/to-remove');
+
+      const result = (await findOp('project_unregister').handler({
+        projectId: registered.id,
+      })) as { removed: boolean };
+
+      expect(result.removed).toBe(true);
+
+      // Verify it is gone
+      const getResult = (await findOp('project_get').handler({
+        projectId: registered.id,
+      })) as { found: boolean };
+      expect(getResult.found).toBe(false);
+    });
+
+    it('should return removed=false for unknown project', async () => {
+      setup();
+      const result = (await findOp('project_unregister').handler({
+        projectId: 'nonexistent',
+      })) as { removed: boolean };
+      expect(result.removed).toBe(false);
+    });
+  });
+
+  // ─── Rules CRUD ────────────────────────────────────────────────
+
+  describe('project_add_rule + project_get_rules', () => {
+    it('should add and retrieve rules for a project', async () => {
+      setup();
+      const project = runtime.projectRegistry.register('/tmp/rules-project');
+
+      const addResult = (await findOp('project_add_rule').handler({
+        projectId: project.id,
+        category: 'behavior',
+        text: 'Always use semantic tokens',
+        priority: 10,
+      })) as {
+        added: boolean;
+        rule: { id: string; category: string; text: string; priority: number };
+      };
+
+      expect(addResult.added).toBe(true);
+      expect(addResult.rule.category).toBe('behavior');
+      expect(addResult.rule.text).toBe('Always use semantic tokens');
+      expect(addResult.rule.priority).toBe(10);
+
+      const rulesResult = (await findOp('project_get_rules').handler({
+        projectId: project.id,
+      })) as { count: number; rules: Array<{ text: string }> };
+
+      expect(rulesResult.count).toBe(1);
+      expect(rulesResult.rules[0].text).toBe('Always use semantic tokens');
+    });
+  });
+
+  describe('project_remove_rule', () => {
+    it('should remove a rule', async () => {
+      setup();
+      const project = runtime.projectRegistry.register('/tmp/rm-rule');
+      const rule = runtime.projectRegistry.addRule(project.id, {
+        category: 'restriction',
+        text: 'No inline styles',
+        priority: 5,
+      });
+
+      const result = (await findOp('project_remove_rule').handler({
+        ruleId: rule.id,
+      })) as { removed: boolean };
+
+      expect(result.removed).toBe(true);
+
+      // Verify rule is gone
+      const rulesResult = (await findOp('project_get_rules').handler({
+        projectId: project.id,
+      })) as { count: number };
+      expect(rulesResult.count).toBe(0);
+    });
+
+    it('should return removed=false for unknown rule', async () => {
+      setup();
+      const result = (await findOp('project_remove_rule').handler({
+        ruleId: 'nonexistent-rule',
+      })) as { removed: boolean };
+      expect(result.removed).toBe(false);
+    });
+  });
+
+  describe('project_list_rules', () => {
+    it('should list all projects with their rules', async () => {
+      setup();
+      const p1 = runtime.projectRegistry.register('/tmp/p1', 'P1');
+      const p2 = runtime.projectRegistry.register('/tmp/p2', 'P2');
+      runtime.projectRegistry.addRule(p1.id, { category: 'behavior', text: 'Rule A', priority: 0 });
+      runtime.projectRegistry.addRule(p1.id, {
+        category: 'convention',
+        text: 'Rule B',
+        priority: 1,
+      });
+      runtime.projectRegistry.addRule(p2.id, {
+        category: 'preference',
+        text: 'Rule C',
+        priority: 0,
+      });
+
+      const result = (await findOp('project_list_rules').handler({})) as {
+        count: number;
+        projects: Array<{ project: { id: string }; ruleCount: number; rules: unknown[] }>;
+      };
+
+      expect(result.count).toBe(2);
+      const p1Entry = result.projects.find((p) => p.project.id === p1.id);
+      expect(p1Entry?.ruleCount).toBe(2);
+      const p2Entry = result.projects.find((p) => p.project.id === p2.id);
+      expect(p2Entry?.ruleCount).toBe(1);
+    });
+  });
+
+  // ─── Links ─────────────────────────────────────────────────────
+
+  describe('project_link + project_unlink', () => {
+    it('should link and unlink two projects', async () => {
+      setup();
+      const p1 = runtime.projectRegistry.register('/tmp/link-a', 'Link A');
+      const p2 = runtime.projectRegistry.register('/tmp/link-b', 'Link B');
+
+      const linkResult = (await findOp('project_link').handler({
+        sourceId: p1.id,
+        targetId: p2.id,
+        linkType: 'related',
+      })) as {
+        linked: boolean;
+        link: { sourceProjectId: string; targetProjectId: string; linkType: string };
+      };
+
+      expect(linkResult.linked).toBe(true);
+      expect(linkResult.link.sourceProjectId).toBe(p1.id);
+      expect(linkResult.link.targetProjectId).toBe(p2.id);
+      expect(linkResult.link.linkType).toBe('related');
+
+      const unlinkResult = (await findOp('project_unlink').handler({
+        sourceId: p1.id,
+        targetId: p2.id,
+        linkType: 'related',
+      })) as { removed: number };
+
+      expect(unlinkResult.removed).toBe(1);
+    });
+
+    it('should unlink all types when linkType is omitted', async () => {
+      setup();
+      const p1 = runtime.projectRegistry.register('/tmp/unlink-a');
+      const p2 = runtime.projectRegistry.register('/tmp/unlink-b');
+
+      runtime.projectRegistry.link(p1.id, p2.id, 'related');
+      runtime.projectRegistry.link(p1.id, p2.id, 'parent');
+
+      const result = (await findOp('project_unlink').handler({
+        sourceId: p1.id,
+        targetId: p2.id,
+      })) as { removed: number };
+
+      expect(result.removed).toBe(2);
+    });
+  });
+
+  describe('project_get_links', () => {
+    it('should get all links for a project', async () => {
+      setup();
+      const p1 = runtime.projectRegistry.register('/tmp/gl-a');
+      const p2 = runtime.projectRegistry.register('/tmp/gl-b');
+      const p3 = runtime.projectRegistry.register('/tmp/gl-c');
+
+      runtime.projectRegistry.link(p1.id, p2.id, 'related');
+      runtime.projectRegistry.link(p3.id, p1.id, 'parent');
+
+      const result = (await findOp('project_get_links').handler({
+        projectId: p1.id,
+      })) as { count: number; links: Array<{ sourceProjectId: string; targetProjectId: string }> };
+
+      expect(result.count).toBe(2);
+    });
+  });
+
+  describe('project_linked_projects', () => {
+    it('should return linked projects with direction info', async () => {
+      setup();
+      const p1 = runtime.projectRegistry.register('/tmp/lp-a', 'LP-A');
+      const p2 = runtime.projectRegistry.register('/tmp/lp-b', 'LP-B');
+      const p3 = runtime.projectRegistry.register('/tmp/lp-c', 'LP-C');
+
+      runtime.projectRegistry.link(p1.id, p2.id, 'related');
+      runtime.projectRegistry.link(p3.id, p1.id, 'fork');
+
+      const result = (await findOp('project_linked_projects').handler({
+        projectId: p1.id,
+      })) as {
+        count: number;
+        linked: Array<{
+          project: { id: string; name: string };
+          linkType: string;
+          direction: 'outgoing' | 'incoming';
+        }>;
+      };
+
+      expect(result.count).toBe(2);
+
+      const outgoing = result.linked.find((l) => l.direction === 'outgoing');
+      expect(outgoing?.project.name).toBe('LP-B');
+      expect(outgoing?.linkType).toBe('related');
+
+      const incoming = result.linked.find((l) => l.direction === 'incoming');
+      expect(incoming?.project.name).toBe('LP-C');
+      expect(incoming?.linkType).toBe('fork');
+    });
+  });
+
+  // ─── project_touch ─────────────────────────────────────────────
+
+  describe('project_touch', () => {
+    it('should update last accessed timestamp', async () => {
+      setup();
+      const project = runtime.projectRegistry.register('/tmp/touch-project');
+      const originalTs = project.lastAccessedAt;
+
+      // Small delay to ensure timestamp changes
+      await new Promise((r) => setTimeout(r, 10));
+
+      const result = (await findOp('project_touch').handler({
+        projectId: project.id,
+      })) as { touched: boolean };
+
+      expect(result.touched).toBe(true);
+
+      const updated = runtime.projectRegistry.get(project.id);
+      expect(updated!.lastAccessedAt).toBeGreaterThan(originalTs);
+    });
+  });
+
+  // ─── Auth levels ───────────────────────────────────────────────
+
+  describe('auth levels', () => {
+    it('should use read auth for read ops', () => {
+      setup();
+      const readOps = [
+        'project_get',
+        'project_list',
+        'project_get_rules',
+        'project_list_rules',
+        'project_get_links',
+        'project_linked_projects',
+      ];
+      for (const name of readOps) {
+        expect(findOp(name).auth).toBe('read');
+      }
+    });
+
+    it('should use write auth for mutation ops', () => {
+      setup();
+      const writeOps = [
+        'project_unregister',
+        'project_add_rule',
+        'project_remove_rule',
+        'project_link',
+        'project_unlink',
+        'project_touch',
+      ];
+      for (const name of writeOps) {
+        expect(findOp(name).auth).toBe('write');
+      }
+    });
+  });
+});

package/src/__tests__/template-manager.test.ts

@@ -0,0 +1,222 @@
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import { mkdirSync, writeFileSync, rmSync } from 'node:fs';
+import { join } from 'node:path';
+import { tmpdir } from 'node:os';
+import { parseVariables, resolveIncludes } from '../prompts/parser.js';
+import { TemplateManager } from '../prompts/template-manager.js';
+
+// ─── parseVariables ───────────────────────────────────────────────────
+
+describe('parseVariables', () => {
+  it('extracts required variable', () => {
+    const vars = parseVariables('Hello {{name}}');
+    expect(vars).toHaveLength(1);
+    expect(vars[0]).toEqual({ name: 'name', required: true, defaultValue: undefined });
+  });
+
+  it('extracts variable with default', () => {
+    const vars = parseVariables('Hello {{name:World}}');
+    expect(vars).toHaveLength(1);
+    expect(vars[0]).toEqual({ name: 'name', required: false, defaultValue: 'World' });
+  });
+
+  it('extracts multiple unique variables', () => {
+    const vars = parseVariables('{{greeting}} {{name}}, welcome to {{place}}');
+    expect(vars).toHaveLength(3);
+    expect(vars.map((v) => v.name)).toEqual(['greeting', 'name', 'place']);
+  });
+
+  it('deduplicates same variable', () => {
+    const vars = parseVariables('{{name}} and {{name}} again');
+    expect(vars).toHaveLength(1);
+  });
+
+  it('handles empty default', () => {
+    const vars = parseVariables('{{opt:}}');
+    expect(vars[0]).toEqual({ name: 'opt', required: false, defaultValue: '' });
+  });
+
+  it('returns empty for no variables', () => {
+    expect(parseVariables('plain text')).toEqual([]);
+  });
+
+  it('handles mixed required and optional', () => {
+    const vars = parseVariables('{{required}} and {{optional:fallback}}');
+    expect(vars).toHaveLength(2);
+    expect(vars[0].required).toBe(true);
+    expect(vars[1].required).toBe(false);
+    expect(vars[1].defaultValue).toBe('fallback');
+  });
+});
+
+// ─── resolveIncludes ──────────────────────────────────────────────────
+
+describe('resolveIncludes', () => {
+  it('resolves single include', () => {
+    const result = resolveIncludes('before @include(header) after', (name) => {
+      if (name === 'header') return 'HEADER';
+      return '';
+    });
+    expect(result).toBe('before HEADER after');
+  });
+
+  it('resolves nested includes', () => {
+    const result = resolveIncludes('start @include(a)', (name) => {
+      if (name === 'a') return 'A @include(b)';
+      if (name === 'b') return 'B';
+      return '';
+    });
+    expect(result).toBe('start A B');
+  });
+
+  it('detects circular includes', () => {
+    expect(() =>
+      resolveIncludes('@include(a)', (name) => {
+        if (name === 'a') return '@include(b)';
+        if (name === 'b') return '@include(a)';
+        return '';
+      }),
+    ).toThrow(/Circular include detected/);
+  });
+
+  it('throws on depth exceeding 10', () => {
+    // Each level includes a unique name so cycle detection doesn't fire
+    let counter = 0;
+    expect(() =>
+      resolveIncludes('@include(level0)', (name) => {
+        counter++;
+        return `@include(level${counter})`;
+      }),
+    ).toThrow(/Include depth exceeded/);
+  });
+
+  it('handles no includes', () => {
+    const result = resolveIncludes('no includes here', () => '');
+    expect(result).toBe('no includes here');
+  });
+
+  it('handles multiple includes', () => {
+    const result = resolveIncludes('@include(a) + @include(b)', (name) => name.toUpperCase());
+    expect(result).toBe('A + B');
+  });
+});
+
+// ─── TemplateManager ──────────────────────────────────────────────────
+
+describe('TemplateManager', () => {
+  let tempDir: string;
+
+  beforeEach(() => {
+    tempDir = join(tmpdir(), `templates-test-${Date.now()}`);
+    mkdirSync(tempDir, { recursive: true });
+  });
+
+  afterEach(() => {
+    rmSync(tempDir, { recursive: true, force: true });
+  });
+
+  it('loads .prompt files from directory', () => {
+    writeFileSync(join(tempDir, 'greeting.prompt'), 'Hello {{name}}!');
+    writeFileSync(join(tempDir, 'farewell.prompt'), 'Goodbye {{name}}.');
+    writeFileSync(join(tempDir, 'not-a-template.txt'), 'ignored');
+
+    const mgr = new TemplateManager(tempDir);
+    mgr.load();
+
+    expect(mgr.listTemplates().sort()).toEqual(['farewell', 'greeting']);
+  });
+
+  it('handles nonexistent directory gracefully', () => {
+    const mgr = new TemplateManager('/nonexistent/path');
+    mgr.load(); // should not throw
+    expect(mgr.listTemplates()).toEqual([]);
+  });
+
+  it('renders template with variables', () => {
+    writeFileSync(join(tempDir, 'hello.prompt'), 'Hello {{name}}, you are {{role}}!');
+    const mgr = new TemplateManager(tempDir);
+    mgr.load();
+
+    const result = mgr.render('hello', { name: 'Atlas', role: 'advisor' });
+    expect(result).toBe('Hello Atlas, you are advisor!');
+  });
+
+  it('uses default values', () => {
+    writeFileSync(join(tempDir, 'hello.prompt'), 'Hello {{name:World}}!');
+    const mgr = new TemplateManager(tempDir);
+    mgr.load();
+
+    expect(mgr.render('hello', {})).toBe('Hello World!');
+    expect(mgr.render('hello', { name: 'Custom' })).toBe('Hello Custom!');
+  });
+
+  it('throws on missing required variable in strict mode', () => {
+    writeFileSync(join(tempDir, 'strict.prompt'), '{{required}}');
+    const mgr = new TemplateManager(tempDir);
+    mgr.load();
+
+    expect(() => mgr.render('strict', {})).toThrow(/Missing required variable: required/);
+  });
+
+  it('leaves placeholder in non-strict mode', () => {
+    writeFileSync(join(tempDir, 'lax.prompt'), 'Hello {{name}}!');
+    const mgr = new TemplateManager(tempDir);
+    mgr.load();
+
+    const result = mgr.render('lax', {}, { strict: false });
+    expect(result).toBe('Hello {{name}}!');
+  });
+
+  it('resolves @include directives', () => {
+    writeFileSync(join(tempDir, 'header.prompt'), '--- HEADER ---');
+    writeFileSync(join(tempDir, 'page.prompt'), '@include(header)\nContent here.');
+    const mgr = new TemplateManager(tempDir);
+    mgr.load();
+
+    const result = mgr.render('page', {});
+    expect(result).toBe('--- HEADER ---\nContent here.');
+  });
+
+  it('throws on missing include', () => {
+    writeFileSync(join(tempDir, 'broken.prompt'), '@include(nonexistent)');
+    const mgr = new TemplateManager(tempDir);
+    mgr.load();
+
+    expect(() => mgr.render('broken', {})).toThrow(/Include not found: nonexistent/);
+  });
+
+  it('throws on nonexistent template name', () => {
+    const mgr = new TemplateManager(tempDir);
+    mgr.load();
+
+    expect(() => mgr.render('missing', {})).toThrow(/Template not found: missing/);
+  });
+
+  it('getTemplate returns raw template', () => {
+    writeFileSync(join(tempDir, 'raw.prompt'), 'Raw {{content}}');
+    const mgr = new TemplateManager(tempDir);
+    mgr.load();
+
+    const tmpl = mgr.getTemplate('raw');
+    expect(tmpl).not.toBeNull();
+    expect(tmpl!.name).toBe('raw');
+    expect(tmpl!.content).toBe('Raw {{content}}');
+    expect(tmpl!.variables).toHaveLength(1);
+  });
+
+  it('getTemplate returns null for nonexistent', () => {
+    const mgr = new TemplateManager(tempDir);
+    mgr.load();
+    expect(mgr.getTemplate('nope')).toBeNull();
+  });
+
+  it('variables in included templates get substituted', () => {
+    writeFileSync(join(tempDir, 'partial.prompt'), 'I am {{name}}');
+    writeFileSync(join(tempDir, 'main.prompt'), 'Hello: @include(partial)!');
+    const mgr = new TemplateManager(tempDir);
+    mgr.load();
+
+    const result = mgr.render('main', { name: 'Atlas' });
+    expect(result).toBe('Hello: I am Atlas!');
+  });
+});