@soleri/core 9.0.3 → 9.2.0

package/src/__tests__/obsidian-sync.test.ts

@@ -1,354 +0,0 @@
-/**
- * Obsidian Sync Tests — export/import vault entries as Obsidian markdown.
- */
-
-import { describe, test, expect, beforeEach, afterEach } from 'vitest';
-import { mkdtempSync, rmSync, readFileSync, readdirSync, mkdirSync, writeFileSync } from 'node:fs';
-import { join } from 'node:path';
-import { tmpdir } from 'node:os';
-import { Vault } from '../vault/vault.js';
-import {
-  ObsidianSync,
-  toObsidianMarkdown,
-  fromObsidianMarkdown,
-  titleToSlug,
-} from '../vault/obsidian-sync.js';
-
-function makeTempDir(): string {
-  return mkdtempSync(join(tmpdir(), 'obsidian-sync-'));
-}
-
-// ─── Format Helpers ─────────────────────────────────────────────
-
-describe('titleToSlug', () => {
-  test('converts title to kebab-case', () => {
-    expect(titleToSlug('Hello World')).toBe('hello-world');
-  });
-
-  test('removes special characters', () => {
-    expect(titleToSlug('Use @decorators for DI!')).toBe('use-decorators-for-di');
-  });
-
-  test('collapses multiple dashes', () => {
-    expect(titleToSlug('one -- two --- three')).toBe('one-two-three');
-  });
-
-  test('trims leading/trailing dashes', () => {
-    expect(titleToSlug('  --hello--  ')).toBe('hello');
-  });
-
-  test('truncates at 80 chars', () => {
-    const long = 'a '.repeat(50).trim();
-    expect(titleToSlug(long).length).toBeLessThanOrEqual(80);
-  });
-
-  test('returns empty for empty input', () => {
-    expect(titleToSlug('')).toBe('');
-  });
-});
-
-describe('toObsidianMarkdown', () => {
-  test('generates YAML frontmatter with body', () => {
-    const md = toObsidianMarkdown({
-      id: 'test-1',
-      type: 'pattern',
-      domain: 'testing',
-      title: 'Test Pattern',
-      description: 'A test pattern description.',
-      severity: 'warning',
-      tags: ['test', 'example'],
-    });
-
-    expect(md).toContain('---');
-    expect(md).toContain('id: "test-1"');
-    expect(md).toContain('type: "pattern"');
-    expect(md).toContain('domain: "testing"');
-    expect(md).toContain('severity: "warning"');
-    expect(md).toContain('tags: ["test", "example"]');
-    expect(md).toContain('# Test Pattern');
-    expect(md).toContain('A test pattern description.');
-  });
-
-  test('omits optional fields when missing', () => {
-    const md = toObsidianMarkdown({
-      id: 'test-2',
-      type: 'rule',
-      title: 'No Domain',
-      description: 'No domain or tags.',
-    });
-
-    expect(md).not.toContain('domain:');
-    expect(md).not.toContain('severity:');
-    expect(md).not.toContain('tags:');
-  });
-});
-
-describe('fromObsidianMarkdown', () => {
-  test('parses YAML frontmatter and body', () => {
-    const content = `---
-id: "abc-1"
-type: "anti-pattern"
-domain: "security"
-severity: "critical"
-tags: ["auth", "xss"]
-updated: 1234567890
----
-
-# SQL Injection Risk
-
-Always use parameterized queries.`;
-
-    const parsed = fromObsidianMarkdown(content);
-    expect(parsed.id).toBe('abc-1');
-    expect(parsed.type).toBe('anti-pattern');
-    expect(parsed.domain).toBe('security');
-    expect(parsed.severity).toBe('critical');
-    expect(parsed.tags).toEqual(['auth', 'xss']);
-    expect(parsed.updated).toBe(1234567890);
-    expect(parsed.title).toBe('SQL Injection Risk');
-    expect(parsed.description).toBe('Always use parameterized queries.');
-  });
-
-  test('infers type from content when missing', () => {
-    const antiPattern = fromObsidianMarkdown(`---
----
-
-# Bad Practice
-
-Avoid using globals in production.`);
-    expect(antiPattern.type).toBe('anti-pattern');
-
-    const pattern = fromObsidianMarkdown(`---
----
-
-# Good Practice
-
-Always prefer const over let.`);
-    expect(pattern.type).toBe('pattern');
-  });
-
-  test('handles missing frontmatter', () => {
-    const parsed = fromObsidianMarkdown('# Just a Title\n\nSome content.');
-    expect(parsed.title).toBe('Just a Title');
-    expect(parsed.description).toBe('Some content.');
-  });
-});
-
-// ─── ObsidianSync Class ─────────────────────────────────────────
-
-describe('ObsidianSync', () => {
-  let vault: Vault;
-  let obsidianDir: string;
-  let sync: ObsidianSync;
-
-  beforeEach(() => {
-    vault = new Vault(':memory:');
-    vault.seed([
-      {
-        id: 'entry-1',
-        type: 'pattern',
-        domain: 'testing',
-        title: 'Test First',
-        description: 'Write tests before code.',
-        severity: 'suggestion',
-        tags: ['tdd'],
-      },
-      {
-        id: 'entry-2',
-        type: 'anti-pattern',
-        domain: 'security',
-        title: 'Hardcoded Secrets',
-        description: 'Never hardcode API keys in source.',
-        severity: 'critical',
-        tags: ['secrets', 'auth'],
-      },
-    ]);
-    obsidianDir = makeTempDir();
-    sync = new ObsidianSync({ vault });
-  });
-
-  afterEach(() => {
-    vault.close();
-    rmSync(obsidianDir, { recursive: true, force: true });
-  });
-
-  describe('export', () => {
-    test('creates markdown files in domain subdirectories', () => {
-      const result = sync.export(obsidianDir);
-      expect(result.exported).toBe(2);
-      expect(result.files).toHaveLength(2);
-      expect(result.skipped).toBe(0);
-
-      // Check files exist
-      const testingDir = join(obsidianDir, 'testing');
-      const securityDir = join(obsidianDir, 'security');
-      expect(readdirSync(testingDir)).toContain('test-first.md');
-      expect(readdirSync(securityDir)).toContain('hardcoded-secrets.md');
-    });
-
-    test('exported files contain valid YAML frontmatter', () => {
-      sync.export(obsidianDir);
-      const content = readFileSync(join(obsidianDir, 'testing', 'test-first.md'), 'utf-8');
-      expect(content).toContain('id: "entry-1"');
-      expect(content).toContain('type: "pattern"');
-      expect(content).toContain('# Test First');
-    });
-
-    test('dry run does not create files', () => {
-      const result = sync.export(obsidianDir, { dryRun: true });
-      expect(result.exported).toBe(2);
-      expect(readdirSync(obsidianDir)).toHaveLength(0);
-    });
-
-    test('filters by domain', () => {
-      const result = sync.export(obsidianDir, { domains: ['security'] });
-      expect(result.exported).toBe(1);
-      expect(result.files[0]).toContain('security');
-    });
-
-    test('filters by type', () => {
-      const result = sync.export(obsidianDir, { types: ['pattern'] });
-      expect(result.exported).toBe(1);
-    });
-  });
-
-  describe('import', () => {
-    test('imports markdown files into vault', () => {
-      // Create some Obsidian files
-      const dir = join(obsidianDir, 'architecture');
-      mkdirSync(dir, { recursive: true });
-      writeFileSync(
-        join(dir, 'clean-code.md'),
-        `---
-type: "pattern"
-domain: "architecture"
-severity: "suggestion"
-tags: ["clean-code"]
----
-
-# Clean Code Principles
-
-Functions should do one thing and do it well.`,
-        'utf-8',
-      );
-
-      const result = sync.import(obsidianDir);
-      expect(result.imported).toBe(1);
-      expect(result.skipped).toBe(0);
-    });
-
-    test('updates existing entries by ID', () => {
-      // Export first to create files with IDs
-      sync.export(obsidianDir);
-
-      // Modify a file
-      const content = readFileSync(join(obsidianDir, 'testing', 'test-first.md'), 'utf-8');
-      const modified = content.replace(
-        'Write tests before code.',
-        'Write tests before implementation.',
-      );
-      writeFileSync(join(obsidianDir, 'testing', 'test-first.md'), modified, 'utf-8');
-
-      const result = sync.import(obsidianDir);
-      expect(result.updated).toBeGreaterThan(0);
-    });
-
-    test('uses directory name as domain fallback', () => {
-      const dir = join(obsidianDir, 'my-domain');
-      mkdirSync(dir, { recursive: true });
-      writeFileSync(
-        join(dir, 'entry.md'),
-        `---
-type: "rule"
----
-
-# Domain From Dir
-
-This entry gets its domain from the directory name.`,
-        'utf-8',
-      );
-
-      sync.import(obsidianDir);
-      const entries = vault.list({ domain: 'my-domain' });
-      expect(entries.length).toBe(1);
-    });
-
-    test('skips files without title or description', () => {
-      mkdirSync(join(obsidianDir, 'empty'), { recursive: true });
-      writeFileSync(join(obsidianDir, 'empty', 'nothing.md'), '---\n---\n', 'utf-8');
-
-      const result = sync.import(obsidianDir);
-      expect(result.skipped).toBe(1);
-    });
-
-    test('dry run does not modify vault', () => {
-      const dir = join(obsidianDir, 'test');
-      mkdirSync(dir, { recursive: true });
-      writeFileSync(
-        join(dir, 'new.md'),
-        `---
-type: "pattern"
----
-
-# New Entry
-
-Should not be imported.`,
-        'utf-8',
-      );
-
-      const before = vault.list({}).length;
-      sync.import(obsidianDir, { dryRun: true });
-      expect(vault.list({}).length).toBe(before);
-    });
-  });
-
-  describe('sync', () => {
-    test('push mode exports only', () => {
-      const result = sync.sync(obsidianDir, { mode: 'push' });
-      expect(result.pushed).toBe(2);
-      expect(result.pulled).toBe(0);
-      expect(result.mode).toBe('push');
-    });
-
-    test('pull mode imports only', () => {
-      // Create an obsidian file first
-      const dir = join(obsidianDir, 'test');
-      mkdirSync(dir, { recursive: true });
-      writeFileSync(
-        join(dir, 'pull.md'),
-        `---
-type: "pattern"
----
-
-# Pulled Entry
-
-Imported via pull.`,
-        'utf-8',
-      );
-
-      const result = sync.sync(obsidianDir, { mode: 'pull' });
-      expect(result.pushed).toBe(0);
-      expect(result.pulled).toBeGreaterThan(0);
-      expect(result.mode).toBe('pull');
-    });
-
-    test('bidirectional mode exports then imports', () => {
-      const result = sync.sync(obsidianDir, { mode: 'bidirectional' });
-      expect(result.pushed).toBe(2);
-      // pulled includes re-reading the just-exported files
-      expect(result.pulled).toBeGreaterThanOrEqual(0);
-      expect(result.mode).toBe('bidirectional');
-    });
-
-    test('defaults to bidirectional', () => {
-      const result = sync.sync(obsidianDir);
-      expect(result.mode).toBe('bidirectional');
-    });
-
-    test('dry run does not create files or modify vault', () => {
-      const result = sync.sync(obsidianDir, { dryRun: true });
-      expect(result.pushed).toBe(2);
-      expect(readdirSync(obsidianDir)).toHaveLength(0);
-    });
-  });
-});

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

@@ -1,289 +0,0 @@
-import { describe, it, expect, beforeEach, afterEach } from 'vitest';
-import { mkdirSync, rmSync } from 'node:fs';
-import { join } from 'node:path';
-import { tmpdir } from 'node:os';
-import { createAgentRuntime } from '../runtime/runtime.js';
-import { createOrchestrateOps } from '../runtime/orchestrate-ops.js';
-import type { AgentRuntime } from '../runtime/types.js';
-import type { OpDefinition } from '../facades/types.js';
-
-describe('createOrchestrateOps', () => {
-  let runtime: AgentRuntime;
-  let ops: OpDefinition[];
-  let plannerDir: string;
-
-  beforeEach(() => {
-    plannerDir = join(tmpdir(), 'orchestrate-ops-test-' + Date.now());
-    mkdirSync(plannerDir, { recursive: true });
-    runtime = createAgentRuntime({
-      agentId: 'test-orchestrate',
-      vaultPath: ':memory:',
-      plansPath: join(plannerDir, 'plans.json'),
-    });
-    ops = createOrchestrateOps(runtime);
-  });
-
-  afterEach(() => {
-    runtime.close();
-    rmSync(plannerDir, { recursive: true, force: true });
-  });
-
-  function findOp(name: string): OpDefinition {
-    const op = ops.find((o) => o.name === name);
-    if (!op) throw new Error(`Op "${name}" not found`);
-    return op;
-  }
-
-  it('should return 5 ops', () => {
-    expect(ops.length).toBe(5);
-  });
-
-  it('should have all expected op names', () => {
-    const names = ops.map((o) => o.name);
-    expect(names).toContain('orchestrate_plan');
-    expect(names).toContain('orchestrate_execute');
-    expect(names).toContain('orchestrate_complete');
-    expect(names).toContain('orchestrate_status');
-    expect(names).toContain('orchestrate_quick_capture');
-  });
-
-  it('should assign correct auth levels', () => {
-    expect(findOp('orchestrate_plan').auth).toBe('write');
-    expect(findOp('orchestrate_execute').auth).toBe('write');
-    expect(findOp('orchestrate_complete').auth).toBe('write');
-    expect(findOp('orchestrate_status').auth).toBe('read');
-    expect(findOp('orchestrate_quick_capture').auth).toBe('write');
-  });
-
-  // ─── orchestrate_plan ───────────────────────────────────────────
-
-  describe('orchestrate_plan', () => {
-    it('should create a plan with empty recommendations when brain has no data', async () => {
-      const op = findOp('orchestrate_plan');
-      const result = (await op.handler({
-        objective: 'Build a new button component',
-        scope: 'src/components/Button',
-        domain: 'component',
-      })) as {
-        plan: { id: string; objective: string; decisions: string[] };
-        recommendations: unknown[];
-      };
-
-      expect(result.plan).toBeDefined();
-      expect(result.plan.objective).toBe('Build a new button component');
-      expect(result.recommendations).toEqual([]);
-      expect(result.plan.decisions).toEqual([]);
-    });
-
-    it('should create a plan with tasks when provided', async () => {
-      const op = findOp('orchestrate_plan');
-      const result = (await op.handler({
-        objective: 'Refactor auth module',
-        scope: 'src/auth',
-        tasks: [
-          { title: 'Extract interfaces', description: 'Pull out shared types' },
-          { title: 'Add tests', description: 'Cover edge cases' },
-        ],
-      })) as { plan: { tasks: Array<{ title: string }> } };
-
-      expect(result.plan.tasks).toHaveLength(2);
-      expect(result.plan.tasks[0].title).toBe('Extract interfaces');
-      expect(result.plan.tasks[1].title).toBe('Add tests');
-    });
-
-    it('should work without optional domain parameter', async () => {
-      const op = findOp('orchestrate_plan');
-      const result = (await op.handler({
-        objective: 'Quick fix',
-        scope: 'all',
-      })) as { plan: { id: string } };
-
-      expect(result.plan.id).toBeDefined();
-    });
-  });
-
-  // ─── orchestrate_execute ────────────────────────────────────────
-
-  describe('orchestrate_execute', () => {
-    it('should start plan execution and open a brain session', async () => {
-      // Create and approve a plan first
-      const plan = runtime.planner.create({
-        objective: 'Test execution',
-        scope: 'test',
-      });
-      runtime.planner.approve(plan.id);
-
-      const op = findOp('orchestrate_execute');
-      const result = (await op.handler({
-        planId: plan.id,
-        domain: 'testing',
-        context: 'Running orchestration test',
-      })) as { plan: { status: string }; session: { id: string; domain: string | null } };
-
-      expect(result.plan.status).toBe('executing');
-      expect(result.session).toBeDefined();
-      expect(result.session.id).toBeDefined();
-      expect(result.session.domain).toBe('testing');
-    });
-
-    it('should throw when plan is not approved', async () => {
-      const plan = runtime.planner.create({
-        objective: 'Not approved',
-        scope: 'test',
-      });
-
-      const op = findOp('orchestrate_execute');
-      await expect(op.handler({ planId: plan.id })).rejects.toThrow(/Invalid transition/);
-    });
-  });
-
-  // ─── orchestrate_complete ───────────────────────────────────────
-
-  describe('orchestrate_complete', () => {
-    it('should complete plan, end session, and extract knowledge', async () => {
-      // Full lifecycle: create -> approve -> execute -> reconciling -> complete
-      const plan = runtime.planner.create({
-        objective: 'Full lifecycle test',
-        scope: 'test',
-      });
-      runtime.planner.approve(plan.id);
-      runtime.planner.startExecution(plan.id);
-      runtime.planner.startReconciliation(plan.id);
-
-      // Start a brain session
-      const session = runtime.brainIntelligence.lifecycle({
-        action: 'start',
-        domain: 'testing',
-        planId: plan.id,
-      });
-
-      const op = findOp('orchestrate_complete');
-      const result = (await op.handler({
-        planId: plan.id,
-        sessionId: session.id,
-        outcome: 'completed',
-        toolsUsed: ['tool1', 'tool2', 'tool1', 'tool1'],
-        filesModified: ['a.ts', 'b.ts'],
-      })) as {
-        plan: { status: string };
-        session: { endedAt: string | null; planOutcome: string | null };
-        extraction: unknown;
-      };
-
-      expect(result.plan.status).toBe('completed');
-      expect(result.session.endedAt).toBeDefined();
-      expect(result.session.planOutcome).toBe('completed');
-      // extraction may or may not produce proposals depending on heuristics
-    });
-
-    it('should handle abandoned outcome', async () => {
-      const plan = runtime.planner.create({ objective: 'Abandoned test', scope: 'test' });
-      runtime.planner.approve(plan.id);
-      runtime.planner.startExecution(plan.id);
-      runtime.planner.startReconciliation(plan.id);
-
-      const session = runtime.brainIntelligence.lifecycle({
-        action: 'start',
-        domain: 'testing',
-      });
-
-      const op = findOp('orchestrate_complete');
-      const result = (await op.handler({
-        planId: plan.id,
-        sessionId: session.id,
-        outcome: 'abandoned',
-      })) as { plan: { status: string }; session: { planOutcome: string | null } };
-
-      expect(result.plan.status).toBe('completed');
-      expect(result.session.planOutcome).toBe('abandoned');
-    });
-  });
-
-  // ─── orchestrate_status ─────────────────────────────────────────
-
-  describe('orchestrate_status', () => {
-    it('should return combined status', async () => {
-      const op = findOp('orchestrate_status');
-      const result = (await op.handler({})) as {
-        activePlans: unknown[];
-        sessionContext: { recentSessions: unknown[] };
-        vaultStats: { totalEntries: number };
-        recommendations: unknown[];
-        brainStats: { sessions: number };
-      };
-
-      expect(result.activePlans).toBeDefined();
-      expect(Array.isArray(result.activePlans)).toBe(true);
-      expect(result.sessionContext).toBeDefined();
-      expect(result.vaultStats).toBeDefined();
-      expect(result.recommendations).toBeDefined();
-      expect(result.brainStats).toBeDefined();
-    });
-
-    it('should include active plans in status', async () => {
-      runtime.planner.create({ objective: 'Active plan 1', scope: 'test' });
-      runtime.planner.create({ objective: 'Active plan 2', scope: 'test' });
-
-      const op = findOp('orchestrate_status');
-      const result = (await op.handler({})) as {
-        activePlans: Array<{ objective: string }>;
-      };
-
-      expect(result.activePlans).toHaveLength(2);
-    });
-
-    it('should respect sessionLimit parameter', async () => {
-      const op = findOp('orchestrate_status');
-      const result = (await op.handler({ sessionLimit: 2 })) as {
-        sessionContext: { recentSessions: unknown[] };
-      };
-
-      // No sessions exist, but the limit should be respected
-      expect(result.sessionContext.recentSessions).toBeDefined();
-    });
-  });
-
-  // ─── orchestrate_quick_capture ──────────────────────────────────
-
-  describe('orchestrate_quick_capture', () => {
-    it('should create, end, and extract in one call', async () => {
-      const op = findOp('orchestrate_quick_capture');
-      const result = (await op.handler({
-        domain: 'component',
-        context: 'Built a new date picker with keyboard navigation',
-        toolsUsed: ['validate_component_code', 'check_contrast'],
-        filesModified: ['src/DatePicker.tsx', 'src/DatePicker.test.tsx'],
-        outcome: 'completed',
-      })) as {
-        session: { id: string; endedAt: string | null; domain: string | null };
-        extraction: unknown;
-      };
-
-      expect(result.session).toBeDefined();
-      expect(result.session.endedAt).toBeDefined();
-      expect(result.session.domain).toBe('component');
-    });
-
-    it('should work with minimal params', async () => {
-      const op = findOp('orchestrate_quick_capture');
-      const result = (await op.handler({
-        domain: 'misc',
-        context: 'Fixed a typo',
-      })) as { session: { id: string } };
-
-      expect(result.session).toBeDefined();
-      expect(result.session.id).toBeDefined();
-    });
-
-    it('should handle abandoned outcome', async () => {
-      const op = findOp('orchestrate_quick_capture');
-      const result = (await op.handler({
-        domain: 'refactor',
-        context: 'Started refactor but rolled back',
-        outcome: 'abandoned',
-      })) as { session: { planOutcome: string | null } };
-
-      expect(result.session.planOutcome).toBe('abandoned');
-    });
-  });
-});