@soleri/core 9.0.4 → 9.2.0

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

@@ -1,268 +0,0 @@
-import { describe, it, expect, afterEach } from 'vitest';
-import { createAgentRuntime } from '../runtime/runtime.js';
-import { createAdminOps } from '../runtime/admin-ops.js';
-import type { AgentRuntime } from '../runtime/types.js';
-import type { OpDefinition } from '../facades/types.js';
-
-describe('createAdminOps', () => {
-  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-admin',
-      vaultPath: ':memory:',
-    });
-    ops = createAdminOps(runtime);
-  }
-
-  it('should return 8 ops', () => {
-    setup();
-    expect(ops).toHaveLength(8);
-    const names = ops.map((o) => o.name);
-    expect(names).toEqual([
-      'admin_health',
-      'admin_tool_list',
-      'admin_config',
-      'admin_vault_size',
-      'admin_uptime',
-      'admin_version',
-      'admin_reset_cache',
-      'admin_diagnostic',
-    ]);
-  });
-
-  // ─── admin_health ──────────────────────────────────────────────
-
-  describe('admin_health', () => {
-    it('should return comprehensive health status', async () => {
-      setup();
-      const result = (await findOp('admin_health').handler({})) as Record<string, unknown>;
-
-      expect(result.status).toBe('ok');
-      expect(result.vault).toEqual({ entries: 0, domains: [] });
-      expect(result.llm).toHaveProperty('openai');
-      expect(result.llm).toHaveProperty('anthropic');
-      expect(result.brain).toHaveProperty('vocabularySize');
-      expect(result.brain).toHaveProperty('feedbackCount');
-      expect(result.curator).toEqual({ initialized: true });
-    });
-
-    it('should reflect vault entries after seed', async () => {
-      setup();
-      runtime.vault.seed([
-        {
-          id: 'ah-1',
-          type: 'pattern',
-          domain: 'testing',
-          title: 'Health Test',
-          severity: 'warning',
-          description: 'Test entry.',
-          tags: ['test'],
-        },
-      ]);
-      const result = (await findOp('admin_health').handler({})) as Record<string, unknown>;
-      const vault = result.vault as { entries: number; domains: string[] };
-      expect(vault.entries).toBe(1);
-      expect(vault.domains).toContain('testing');
-    });
-  });
-
-  // ─── admin_tool_list ───────────────────────────────────────────
-
-  describe('admin_tool_list', () => {
-    it('should return fallback list without _allOps', async () => {
-      setup();
-      const result = (await findOp('admin_tool_list').handler({})) as {
-        count: number;
-        ops: Array<{ name: string }>;
-      };
-
-      expect(result.count).toBe(8);
-      expect(result.ops.map((o) => o.name)).toContain('admin_health');
-      expect(result.ops.map((o) => o.name)).toContain('admin_diagnostic');
-    });
-
-    it('should return injected ops when _allOps is provided', async () => {
-      setup();
-      const allOps = [
-        { name: 'search', description: 'Search vault', auth: 'read' },
-        { name: 'admin_health', description: 'Health check', auth: 'read' },
-      ];
-      const result = (await findOp('admin_tool_list').handler({ _allOps: allOps })) as {
-        count: number;
-        ops: Array<{ name: string; description: string; auth: string }>;
-      };
-
-      expect(result.count).toBe(2);
-      expect(result.ops[0].name).toBe('search');
-      expect(result.ops[1].name).toBe('admin_health');
-    });
-  });
-
-  // ─── admin_config ──────────────────────────────────────────────
-
-  describe('admin_config', () => {
-    it('should return runtime config', async () => {
-      setup();
-      const result = (await findOp('admin_config').handler({})) as Record<string, unknown>;
-
-      expect(result.agentId).toBe('test-admin');
-      expect(result.vaultPath).toBe(':memory:');
-      expect(result.logLevel).toBe('info');
-    });
-  });
-
-  // ─── admin_vault_size ──────────────────────────────────────────
-
-  describe('admin_vault_size', () => {
-    it('should return null size for in-memory vault', async () => {
-      setup();
-      const result = (await findOp('admin_vault_size').handler({})) as Record<string, unknown>;
-
-      expect(result.path).toBe(':memory:');
-      expect(result.sizeBytes).toBeNull();
-      expect(result.sizeHuman).toBe('in-memory');
-    });
-  });
-
-  // ─── admin_uptime ──────────────────────────────────────────────
-
-  describe('admin_uptime', () => {
-    it('should return uptime since creation', async () => {
-      setup();
-      const result = (await findOp('admin_uptime').handler({})) as Record<string, unknown>;
-
-      expect(result.createdAt).toBeDefined();
-      expect(typeof result.uptimeMs).toBe('number');
-      expect(typeof result.uptimeSec).toBe('number');
-      expect(typeof result.uptimeHuman).toBe('string');
-      expect(result.uptimeMs as number).toBeGreaterThanOrEqual(0);
-      expect(result.uptimeMs as number).toBeLessThan(5000); // should be nearly instant
-    });
-
-    it('should have valid ISO date in createdAt', async () => {
-      setup();
-      const result = (await findOp('admin_uptime').handler({})) as { createdAt: string };
-      const parsed = new Date(result.createdAt);
-      expect(parsed.getTime()).toBeGreaterThan(0);
-    });
-  });
-
-  // ─── admin_version ─────────────────────────────────────────────
-
-  describe('admin_version', () => {
-    it('should return version information', async () => {
-      setup();
-      const result = (await findOp('admin_version').handler({})) as Record<string, unknown>;
-
-      expect(typeof result.core).toBe('string');
-      expect(result.node).toMatch(/^v\d+/);
-      expect(typeof result.platform).toBe('string');
-      expect(typeof result.arch).toBe('string');
-    });
-  });
-
-  // ─── admin_reset_cache ─────────────────────────────────────────
-
-  describe('admin_reset_cache', () => {
-    it('should clear caches and return status', async () => {
-      setup();
-      const result = (await findOp('admin_reset_cache').handler({})) as Record<string, unknown>;
-
-      expect(result.cleared).toContain('brain_vocabulary');
-      expect(typeof (result as { brainVocabularySize: number }).brainVocabularySize).toBe('number');
-    });
-
-    it('should have write auth', () => {
-      setup();
-      const op = findOp('admin_reset_cache');
-      expect(op.auth).toBe('write');
-    });
-  });
-
-  // ─── admin_diagnostic ──────────────────────────────────────────
-
-  describe('admin_diagnostic', () => {
-    it('should return diagnostic report with all checks', async () => {
-      setup();
-      const result = (await findOp('admin_diagnostic').handler({})) as {
-        overall: string;
-        checks: Array<{ name: string; status: string; detail: string }>;
-        summary: string;
-      };
-
-      expect(['healthy', 'degraded', 'unhealthy']).toContain(result.overall);
-      expect(result.checks.length).toBeGreaterThanOrEqual(6);
-
-      const checkNames = result.checks.map((c) => c.name);
-      expect(checkNames).toContain('vault');
-      expect(checkNames).toContain('brain_vocabulary');
-      expect(checkNames).toContain('brain_intelligence');
-      expect(checkNames).toContain('llm_openai');
-      expect(checkNames).toContain('llm_anthropic');
-      expect(checkNames).toContain('curator');
-    });
-
-    it('should report vault as ok for empty vault', async () => {
-      setup();
-      const result = (await findOp('admin_diagnostic').handler({})) as {
-        checks: Array<{ name: string; status: string }>;
-      };
-
-      const vaultCheck = result.checks.find((c) => c.name === 'vault');
-      expect(vaultCheck?.status).toBe('ok');
-    });
-
-    it('should report curator as ok', async () => {
-      setup();
-      const result = (await findOp('admin_diagnostic').handler({})) as {
-        checks: Array<{ name: string; status: string }>;
-      };
-
-      const curatorCheck = result.checks.find((c) => c.name === 'curator');
-      expect(curatorCheck?.status).toBe('ok');
-    });
-
-    it('should include summary string', async () => {
-      setup();
-      const result = (await findOp('admin_diagnostic').handler({})) as { summary: string };
-      expect(result.summary).toMatch(/\d+ checks:/);
-    });
-  });
-
-  // ─── Auth levels ───────────────────────────────────────────────
-
-  describe('auth levels', () => {
-    it('should use read auth for status ops', () => {
-      setup();
-      const readOps = [
-        'admin_health',
-        'admin_tool_list',
-        'admin_config',
-        'admin_vault_size',
-        'admin_uptime',
-        'admin_version',
-        'admin_diagnostic',
-      ];
-      for (const name of readOps) {
-        expect(findOp(name).auth).toBe('read');
-      }
-    });
-
-    it('should use write auth for mutation ops', () => {
-      setup();
-      expect(findOp('admin_reset_cache').auth).toBe('write');
-    });
-  });
-});

package/src/__tests__/admin-setup-ops.test.ts

@@ -1,355 +0,0 @@
-import { describe, it, expect, afterEach, beforeEach } from 'vitest';
-import { mkdirSync, writeFileSync, existsSync, readFileSync, rmSync } from 'node:fs';
-import { join } from 'node:path';
-import { tmpdir } from 'node:os';
-import { createAgentRuntime } from '../runtime/runtime.js';
-import { createAdminSetupOps } from '../runtime/admin-setup-ops.js';
-import type { AgentRuntime } from '../runtime/types.js';
-import type { OpDefinition } from '../facades/types.js';
-import {
-  hasSections,
-  removeSections,
-  injectAtPosition,
-  buildInjectionContent,
-  wrapInMarkers,
-  composeAgentModeSection,
-  composeIntegrationSection,
-} from '../runtime/claude-md-helpers.js';
-
-// ─── claude-md-helpers tests ──────────────────────────────────────────
-
-describe('claude-md-helpers', () => {
-  const agentId = 'test-agent';
-  const config = { agentId } as any;
-
-  describe('hasSections', () => {
-    it('returns true when markers present', () => {
-      const content = `# Hello\n<!-- agent:${agentId}:mode -->\nstuff\n<!-- /agent:${agentId}:mode -->\n`;
-      expect(hasSections(content, agentId)).toBe(true);
-    });
-
-    it('returns false when no markers', () => {
-      expect(hasSections('# Hello\nWorld', agentId)).toBe(false);
-    });
-
-    it('returns false for different agent', () => {
-      const content = `<!-- agent:other:mode -->\nstuff\n<!-- /agent:other:mode -->`;
-      expect(hasSections(content, agentId)).toBe(false);
-    });
-  });
-
-  describe('removeSections', () => {
-    it('removes agent section cleanly', () => {
-      const content = `# Hello\n\n<!-- agent:${agentId}:mode -->\nstuff\n<!-- /agent:${agentId}:mode -->\n\n# Footer`;
-      const result = removeSections(content, agentId);
-      expect(result).not.toContain('stuff');
-      expect(result).toContain('# Hello');
-      expect(result).toContain('# Footer');
-    });
-
-    it('returns unchanged content if no markers', () => {
-      const content = '# Hello\nWorld';
-      expect(removeSections(content, agentId)).toBe(content);
-    });
-  });
-
-  describe('injectAtPosition', () => {
-    const section = '## Injected';
-
-    it('injects at start', () => {
-      const result = injectAtPosition('# Hello', section, 'start');
-      expect(result.startsWith('## Injected')).toBe(true);
-    });
-
-    it('injects at end', () => {
-      const result = injectAtPosition('# Hello', section, 'end');
-      expect(result.endsWith('## Injected\n')).toBe(true);
-    });
-
-    it('injects after title', () => {
-      const content = '# My Project\n\nSome content here.';
-      const result = injectAtPosition(content, section, 'after-title');
-      const lines = result.split('\n');
-      const titleIdx = lines.indexOf('# My Project');
-      expect(titleIdx).toBe(0);
-      // Section should appear before "Some content here."
-      expect(result.indexOf('## Injected')).toBeLessThan(result.indexOf('Some content here.'));
-    });
-
-    it('falls back to start if no title found', () => {
-      const content = 'No heading here.';
-      const result = injectAtPosition(content, section, 'after-title');
-      expect(result.startsWith('## Injected')).toBe(true);
-    });
-  });
-
-  describe('wrapInMarkers', () => {
-    it('wraps content in agent markers', () => {
-      const result = wrapInMarkers(agentId, 'hello');
-      expect(result).toContain(`<!-- agent:${agentId}:mode -->`);
-      expect(result).toContain('hello');
-      expect(result).toContain(`<!-- /agent:${agentId}:mode -->`);
-    });
-  });
-
-  describe('composeAgentModeSection', () => {
-    it('generates activation commands', () => {
-      const result = composeAgentModeSection(config);
-      expect(result).toContain('## Test-agent Mode');
-      expect(result).toContain('test-agent_core op:activate');
-      expect(result).toContain('deactivate: true');
-    });
-  });
-
-  describe('composeIntegrationSection', () => {
-    it('generates default tools table when no facades provided', () => {
-      const result = composeIntegrationSection(config);
-      expect(result).toContain('## Test-agent Integration');
-      expect(result).toContain('test-agent_vault');
-      expect(result).toContain('test-agent_admin');
-    });
-
-    it('uses provided facades', () => {
-      const facades = [{ name: 'test-agent_custom', ops: ['op_a', 'op_b'] }];
-      const result = composeIntegrationSection(config, facades);
-      expect(result).toContain('test-agent_custom');
-      expect(result).toContain('`op_a`');
-    });
-  });
-
-  describe('buildInjectionContent', () => {
-    it('wraps in markers', () => {
-      const result = buildInjectionContent(config);
-      expect(result).toContain(`<!-- agent:${agentId}:mode -->`);
-      expect(result).toContain(`<!-- /agent:${agentId}:mode -->`);
-    });
-
-    it('excludes integration when disabled', () => {
-      const result = buildInjectionContent(config, { includeIntegration: false });
-      expect(result).toContain('Mode');
-      expect(result).not.toContain('Integration');
-    });
-  });
-});
-
-// ─── admin-setup-ops tests ────────────────────────────────────────────
-
-describe('createAdminSetupOps', () => {
-  let runtime: AgentRuntime;
-  let ops: OpDefinition[];
-  let tmpDir: string;
-
-  function findOp(name: string): OpDefinition {
-    const op = ops.find((o) => o.name === name);
-    if (!op) throw new Error(`Op "${name}" not found`);
-    return op;
-  }
-
-  beforeEach(() => {
-    tmpDir = join(tmpdir(), `soleri-test-${Date.now()}-${Math.random().toString(36).slice(2)}`);
-    mkdirSync(tmpDir, { recursive: true });
-
-    runtime = createAgentRuntime({
-      agentId: 'test-setup',
-      vaultPath: ':memory:',
-    });
-    ops = createAdminSetupOps(runtime);
-  });
-
-  afterEach(() => {
-    runtime?.close();
-    try {
-      rmSync(tmpDir, { recursive: true, force: true });
-    } catch {
-      // cleanup best-effort
-    }
-  });
-
-  it('should return 4 ops', () => {
-    expect(ops).toHaveLength(4);
-    const names = ops.map((o) => o.name);
-    expect(names).toEqual([
-      'admin_inject_claude_md',
-      'admin_setup_global',
-      'admin_setup_project',
-      'admin_check_persistence',
-    ]);
-  });
-
-  // ─── inject_claude_md ───────────────────────────────────────────
-
-  describe('admin_inject_claude_md', () => {
-    it('creates CLAUDE.md when createIfMissing is true', async () => {
-      const result = (await findOp('admin_inject_claude_md').handler({
-        projectPath: tmpDir,
-        createIfMissing: true,
-        includeIntegration: true,
-        position: 'after-title',
-        dryRun: false,
-        global: false,
-      })) as any;
-
-      expect(result.action).toBe('created');
-      expect(existsSync(result.path)).toBe(true);
-      const content = readFileSync(result.path, 'utf-8');
-      expect(content).toContain('<!-- agent:test-setup:mode -->');
-      expect(content).toContain('test-setup_core op:activate');
-    });
-
-    it('errors when CLAUDE.md not found and createIfMissing is false', async () => {
-      const result = (await findOp('admin_inject_claude_md').handler({
-        projectPath: tmpDir,
-        createIfMissing: false,
-        includeIntegration: true,
-        position: 'after-title',
-        dryRun: false,
-        global: false,
-      })) as any;
-
-      expect(result.action).toBe('error');
-      expect(result.error).toContain('not found');
-    });
-
-    it('injects into existing CLAUDE.md', async () => {
-      writeFileSync(join(tmpDir, 'CLAUDE.md'), '# My Project\n\nExisting content.\n');
-
-      const result = (await findOp('admin_inject_claude_md').handler({
-        projectPath: tmpDir,
-        createIfMissing: false,
-        includeIntegration: true,
-        position: 'after-title',
-        dryRun: false,
-        global: false,
-      })) as any;
-
-      expect(result.action).toBe('injected');
-      const content = readFileSync(result.path, 'utf-8');
-      expect(content).toContain('# My Project');
-      expect(content).toContain('<!-- agent:test-setup:mode -->');
-      expect(content).toContain('Existing content.');
-    });
-
-    it('is idempotent — updates existing sections', async () => {
-      writeFileSync(join(tmpDir, 'CLAUDE.md'), '# My Project\n\nExisting content.\n');
-
-      // First injection
-      await findOp('admin_inject_claude_md').handler({
-        projectPath: tmpDir,
-        createIfMissing: false,
-        includeIntegration: true,
-        position: 'after-title',
-        dryRun: false,
-        global: false,
-      });
-
-      // Second injection — should update, not duplicate
-      const result = (await findOp('admin_inject_claude_md').handler({
-        projectPath: tmpDir,
-        createIfMissing: false,
-        includeIntegration: true,
-        position: 'after-title',
-        dryRun: false,
-        global: false,
-      })) as any;
-
-      expect(result.action).toBe('updated');
-      const content = readFileSync(result.path, 'utf-8');
-      // Should have exactly one pair of markers
-      const markerCount = (content.match(/<!-- agent:test-setup:mode -->/g) ?? []).length;
-      expect(markerCount).toBe(1);
-    });
-
-    it('supports dry-run mode', async () => {
-      writeFileSync(join(tmpDir, 'CLAUDE.md'), '# My Project\n');
-
-      const result = (await findOp('admin_inject_claude_md').handler({
-        projectPath: tmpDir,
-        createIfMissing: false,
-        includeIntegration: true,
-        position: 'after-title',
-        dryRun: true,
-        global: false,
-      })) as any;
-
-      expect(result.action).toBe('would_inject');
-      expect(result.preview).toBeDefined();
-      // File should not be modified
-      const content = readFileSync(join(tmpDir, 'CLAUDE.md'), 'utf-8');
-      expect(content).not.toContain('agent:test-setup:mode');
-    });
-  });
-
-  // ─── setup_global ───────────────────────────────────────────────
-
-  describe('admin_setup_global', () => {
-    it('returns dry-run analysis when install is false', async () => {
-      const result = (await findOp('admin_setup_global').handler({
-        install: false,
-        hooksOnly: false,
-        settingsJsonOnly: false,
-        skillsOnly: false,
-      })) as any;
-
-      expect(result.dryRun).toBe(true);
-      expect(result.agentId).toBe('test-setup');
-      expect(result.hookifyRules).toBeDefined();
-      expect(result.skills).toBeDefined();
-      expect(result.settingsJson).toBeDefined();
-    });
-  });
-
-  // ─── setup_project ─────────────────────────────────────────────
-
-  describe('admin_setup_project', () => {
-    it('returns analysis in default mode', async () => {
-      const result = (await findOp('admin_setup_project').handler({
-        projectPath: tmpDir,
-        cleanup: false,
-        install: false,
-      })) as any;
-
-      expect(result.mode).toBe('analyze');
-      expect(result.projectPath).toBe(tmpDir);
-      expect(typeof result.globalHooks).toBe('number');
-      expect(typeof result.projectHooks).toBe('number');
-    });
-
-    it('returns error for non-existent project', async () => {
-      const result = (await findOp('admin_setup_project').handler({
-        projectPath: '/nonexistent/path',
-        cleanup: false,
-        install: false,
-      })) as any;
-
-      expect(result.error).toBe('PROJECT_NOT_FOUND');
-    });
-  });
-
-  // ─── check_persistence ──────────────────────────────────────────
-
-  describe('admin_check_persistence', () => {
-    it('returns persistence diagnostic', async () => {
-      const result = (await findOp('admin_check_persistence').handler({})) as any;
-
-      expect(result.agentId).toBe('test-setup');
-      expect(result.storageDirectory).toBeDefined();
-      expect(result.files).toBeDefined();
-      expect(result.files.plans).toBeDefined();
-      expect(result.files.vault).toBeDefined();
-      expect(result.status).toBeDefined();
-      expect(result.recommendation).toBeDefined();
-      expect(Array.isArray(result.activePlans)).toBe(true);
-    });
-
-    it('reports correct status for in-memory vault', async () => {
-      const result = (await findOp('admin_check_persistence').handler({})) as any;
-
-      // In-memory vault + no plans file = NO_STORAGE_DIRECTORY or PERSISTENCE_CONFIGURED_BUT_INCOMPLETE
-      expect([
-        'NO_STORAGE_DIRECTORY',
-        'PERSISTENCE_CONFIGURED_BUT_INCOMPLETE',
-        'PERSISTENCE_ACTIVE',
-      ]).toContain(result.status);
-    });
-  });
-});