@cleocode/core 2026.4.11 → 2026.4.13

package/src/store/__tests__/regenerators.test.ts

@@ -0,0 +1,234 @@
+/**
+ * Tests for T352 dry-run JSON file generators.
+ *
+ * Verifies:
+ *   1. All generators return the correct `filename` field.
+ *   2. No generator writes anything to disk.
+ *   3. Machine-local fields reflect the `projectRoot` argument.
+ *   4. Different `projectRoot` values produce distinguishable output.
+ *   5. `regenerateAllJson` returns all three files.
+ *
+ * @task T352
+ * @epic T311
+ */
+
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import { afterEach, beforeEach, describe, expect, it } from 'vitest';
+import {
+  regenerateAllJson,
+  regenerateConfigJson,
+  regenerateProjectContextJson,
+  regenerateProjectInfoJson,
+} from '../regenerators.js';
+
+describe('T352 regenerators (dry-run init JSON generators)', () => {
+  let tmpRoot: string;
+
+  beforeEach(() => {
+    tmpRoot = fs.mkdtempSync(path.join(os.tmpdir(), 'cleo-t352-'));
+  });
+
+  afterEach(() => {
+    fs.rmSync(tmpRoot, { recursive: true, force: true });
+  });
+
+  // ── regenerateConfigJson ────────────────────────────────────────────
+
+  describe('regenerateConfigJson', () => {
+    it('returns filename="config.json"', () => {
+      const result = regenerateConfigJson(tmpRoot);
+      expect(result.filename).toBe('config.json');
+    });
+
+    it('returns a non-null object as content', () => {
+      const result = regenerateConfigJson(tmpRoot);
+      expect(result.content).toBeTypeOf('object');
+      expect(result.content).not.toBeNull();
+    });
+
+    it('does NOT write config.json to disk', () => {
+      regenerateConfigJson(tmpRoot);
+      expect(fs.existsSync(path.join(tmpRoot, '.cleo', 'config.json'))).toBe(false);
+      expect(fs.existsSync(path.join(tmpRoot, '.cleo'))).toBe(false);
+    });
+
+    it('content has expected top-level keys from createDefaultConfig', () => {
+      const result = regenerateConfigJson(tmpRoot);
+      const content = result.content as Record<string, unknown>;
+      // These keys mirror createDefaultConfig() in scaffold.ts
+      expect(content).toHaveProperty('version');
+      expect(content).toHaveProperty('output');
+      expect(content).toHaveProperty('backup');
+      expect(content).toHaveProperty('hierarchy');
+      expect(content).toHaveProperty('session');
+      expect(content).toHaveProperty('lifecycle');
+    });
+
+    it('is stable across two calls to the same projectRoot (modulo timestamps)', () => {
+      const a = regenerateConfigJson(tmpRoot);
+      const b = regenerateConfigJson(tmpRoot);
+      // All non-timestamp fields must be identical
+      expect(typeof a.content).toBe(typeof b.content);
+      expect((a.content as Record<string, unknown>)['version']).toBe(
+        (b.content as Record<string, unknown>)['version'],
+      );
+    });
+  });
+
+  // ── regenerateProjectInfoJson ───────────────────────────────────────
+
+  describe('regenerateProjectInfoJson', () => {
+    it('returns filename="project-info.json"', () => {
+      const result = regenerateProjectInfoJson(tmpRoot);
+      expect(result.filename).toBe('project-info.json');
+    });
+
+    it('returns a non-null object as content', () => {
+      const result = regenerateProjectInfoJson(tmpRoot);
+      expect(result.content).toBeTypeOf('object');
+      expect(result.content).not.toBeNull();
+    });
+
+    it('does NOT write project-info.json to disk', () => {
+      regenerateProjectInfoJson(tmpRoot);
+      expect(fs.existsSync(path.join(tmpRoot, '.cleo', 'project-info.json'))).toBe(false);
+      expect(fs.existsSync(path.join(tmpRoot, '.cleo'))).toBe(false);
+    });
+
+    it('content includes required machine-local fields', () => {
+      const result = regenerateProjectInfoJson(tmpRoot);
+      const content = result.content as Record<string, unknown>;
+      expect(content).toHaveProperty('projectHash');
+      expect(content).toHaveProperty('projectId');
+      expect(content).toHaveProperty('cleoVersion');
+      expect(content).toHaveProperty('lastUpdated');
+      expect(content).toHaveProperty('schemas');
+    });
+
+    it('projectHash reflects the resolved projectRoot path', () => {
+      const result = regenerateProjectInfoJson(tmpRoot);
+      const content = result.content as Record<string, unknown>;
+      // projectHash must be a non-empty string (SHA-256 prefix)
+      expect(typeof content['projectHash']).toBe('string');
+      expect((content['projectHash'] as string).length).toBeGreaterThan(0);
+    });
+
+    it('produces different projectHash for different projectRoots', () => {
+      const root2 = fs.mkdtempSync(path.join(os.tmpdir(), 'cleo-t352-other-'));
+      try {
+        const a = regenerateProjectInfoJson(tmpRoot);
+        const b = regenerateProjectInfoJson(root2);
+        expect((a.content as Record<string, unknown>)['projectHash']).not.toBe(
+          (b.content as Record<string, unknown>)['projectHash'],
+        );
+      } finally {
+        fs.rmSync(root2, { recursive: true, force: true });
+      }
+    });
+
+    it('schemas block contains config, sqlite, and projectContext keys', () => {
+      const result = regenerateProjectInfoJson(tmpRoot);
+      const schemas = (result.content as Record<string, unknown>)['schemas'] as Record<
+        string,
+        unknown
+      >;
+      expect(schemas).toHaveProperty('config');
+      expect(schemas).toHaveProperty('sqlite');
+      expect(schemas).toHaveProperty('projectContext');
+    });
+  });
+
+  // ── regenerateProjectContextJson ───────────────────────────────────
+
+  describe('regenerateProjectContextJson', () => {
+    it('returns filename="project-context.json"', () => {
+      const result = regenerateProjectContextJson(tmpRoot);
+      expect(result.filename).toBe('project-context.json');
+    });
+
+    it('returns a non-null object as content', () => {
+      const result = regenerateProjectContextJson(tmpRoot);
+      expect(result.content).toBeTypeOf('object');
+      expect(result.content).not.toBeNull();
+    });
+
+    it('does NOT write project-context.json to disk', () => {
+      regenerateProjectContextJson(tmpRoot);
+      expect(fs.existsSync(path.join(tmpRoot, '.cleo', 'project-context.json'))).toBe(false);
+      expect(fs.existsSync(path.join(tmpRoot, '.cleo'))).toBe(false);
+    });
+
+    it('content has required schema fields from detectProjectType', () => {
+      const result = regenerateProjectContextJson(tmpRoot);
+      const content = result.content as Record<string, unknown>;
+      expect(content).toHaveProperty('schemaVersion');
+      expect(content).toHaveProperty('detectedAt');
+      expect(content).toHaveProperty('projectTypes');
+      expect(content).toHaveProperty('monorepo');
+    });
+
+    it('detectedAt is a valid ISO timestamp', () => {
+      const result = regenerateProjectContextJson(tmpRoot);
+      const content = result.content as Record<string, unknown>;
+      const detectedAt = content['detectedAt'] as string;
+      expect(typeof detectedAt).toBe('string');
+      const parsed = new Date(detectedAt);
+      expect(Number.isNaN(parsed.getTime())).toBe(false);
+    });
+  });
+
+  // ── regenerateAllJson ───────────────────────────────────────────────
+
+  describe('regenerateAllJson', () => {
+    it('returns all three files', () => {
+      const all = regenerateAllJson(tmpRoot);
+      expect(all.config.filename).toBe('config.json');
+      expect(all.projectInfo.filename).toBe('project-info.json');
+      expect(all.projectContext.filename).toBe('project-context.json');
+    });
+
+    it('does NOT write any files to disk', () => {
+      regenerateAllJson(tmpRoot);
+      expect(fs.existsSync(path.join(tmpRoot, '.cleo'))).toBe(false);
+    });
+
+    it('all three content values are non-null objects', () => {
+      const all = regenerateAllJson(tmpRoot);
+      for (const file of [all.config, all.projectInfo, all.projectContext]) {
+        expect(file.content).toBeTypeOf('object');
+        expect(file.content).not.toBeNull();
+      }
+    });
+  });
+
+  // ── Cross-projectRoot differentiation ──────────────────────────────
+
+  describe('cross-projectRoot differentiation', () => {
+    it('regenerated project-info differs across different projectRoots', () => {
+      const root2 = fs.mkdtempSync(path.join(os.tmpdir(), 'cleo-t352-other-'));
+      try {
+        const a = regenerateProjectInfoJson(tmpRoot);
+        const b = regenerateProjectInfoJson(root2);
+        // At minimum the projectHash must differ (different paths)
+        expect(JSON.stringify(a.content)).not.toBe(JSON.stringify(b.content));
+      } finally {
+        fs.rmSync(root2, { recursive: true, force: true });
+      }
+    });
+  });
+
+  // ── Stability / shape ───────────────────────────────────────────────
+
+  describe('stability', () => {
+    it('config content has the same type shape across two calls', () => {
+      const a = regenerateConfigJson(tmpRoot);
+      const b = regenerateConfigJson(tmpRoot);
+      expect(typeof a.content).toBe(typeof b.content);
+      expect(Object.keys(a.content as Record<string, unknown>).sort()).toEqual(
+        Object.keys(b.content as Record<string, unknown>).sort(),
+      );
+    });
+  });
+});

package/src/store/__tests__/restore-conflict-report.test.ts

@@ -0,0 +1,274 @@
+/**
+ * Tests for the T357 conflict report generator.
+ *
+ * Verifies that {@link buildConflictReport} and {@link writeConflictReport}
+ * produce correctly structured markdown output per T311 spec §6.5 and that
+ * all edge-cases (empty warnings, missing values, multi-file reports) are
+ * handled consistently.
+ *
+ * @task T357
+ * @epic T311
+ */
+
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import { afterEach, beforeEach, describe, expect, it } from 'vitest';
+
+import { buildConflictReport, writeConflictReport } from '../restore-conflict-report.js';
+import type { JsonRestoreReport } from '../restore-json-merge.js';
+
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+
+function makeReport(
+  filename: 'config.json' | 'project-info.json' | 'project-context.json',
+): JsonRestoreReport {
+  return {
+    filename,
+    localGenerated: { x: 1 },
+    imported: { x: 2 },
+    classifications: [
+      {
+        path: 'projectRoot',
+        local: '/local',
+        imported: '/source',
+        category: 'machine-local',
+        resolution: 'A',
+        rationale: 'expected to differ between machines',
+      },
+      {
+        path: 'brain.embeddingProvider',
+        local: 'local',
+        imported: 'openai',
+        category: 'user-intent',
+        resolution: 'B',
+        rationale: 'user intent — preserve from source',
+      },
+      {
+        path: 'somethingNew',
+        local: undefined,
+        imported: 'value',
+        category: 'unknown',
+        resolution: 'manual-review',
+        rationale: 'unclassified field — needs human review',
+      },
+    ],
+    applied: {},
+    conflictCount: 1,
+  };
+}
+
+// ---------------------------------------------------------------------------
+// Suite
+// ---------------------------------------------------------------------------
+
+describe('T357 conflict report generator', () => {
+  let tmpRoot: string;
+
+  beforeEach(() => {
+    tmpRoot = fs.mkdtempSync(path.join(os.tmpdir(), 'cleo-t357-'));
+  });
+
+  afterEach(() => {
+    fs.rmSync(tmpRoot, { recursive: true, force: true });
+  });
+
+  it('buildConflictReport returns a non-empty markdown string', () => {
+    const md = buildConflictReport({
+      reports: [makeReport('config.json')],
+      bundlePath: '/tmp/test.cleobundle.tar.gz',
+      sourceMachineFingerprint: 'aaaa',
+      targetMachineFingerprint: 'bbbb',
+      cleoVersion: '2026.4.13',
+    });
+    expect(md).toContain('# T311 Import Conflict Report');
+    expect(md).toContain('config.json');
+    expect(md).toContain('projectRoot');
+    expect(md).toContain('brain.embeddingProvider');
+    expect(md).toContain('somethingNew');
+    expect(md).toContain('manual-review');
+  });
+
+  it('groups Resolved and Manual review sections separately', () => {
+    const md = buildConflictReport({
+      reports: [makeReport('config.json')],
+      bundlePath: '/tmp/x',
+      sourceMachineFingerprint: 'a',
+      targetMachineFingerprint: 'b',
+      cleoVersion: '2026.4.13',
+    });
+    const resolvedIdx = md.indexOf('Resolved');
+    const manualIdx = md.indexOf('Manual review');
+    expect(resolvedIdx).toBeGreaterThanOrEqual(0);
+    expect(manualIdx).toBeGreaterThanOrEqual(0);
+    expect(manualIdx).toBeGreaterThan(resolvedIdx);
+  });
+
+  it('includes reauth warnings section when warnings present', () => {
+    const md = buildConflictReport({
+      reports: [makeReport('config.json')],
+      bundlePath: '/tmp/x',
+      sourceMachineFingerprint: 'a',
+      targetMachineFingerprint: 'b',
+      cleoVersion: '2026.4.13',
+      reauthWarnings: [
+        { agentId: 'agent-1', reason: 'KDF mismatch' },
+        { agentId: 'agent-2', reason: 'KDF mismatch' },
+      ],
+    });
+    expect(md).toContain('Agent re-authentication required');
+    expect(md).toContain('agent-1');
+    expect(md).toContain('agent-2');
+  });
+
+  it('includes schema warnings section when present', () => {
+    const md = buildConflictReport({
+      reports: [makeReport('config.json')],
+      bundlePath: '/tmp/x',
+      sourceMachineFingerprint: 'a',
+      targetMachineFingerprint: 'b',
+      cleoVersion: '2026.4.13',
+      schemaWarnings: [
+        { db: 'tasks', bundleVersion: '1', localVersion: '2', severity: 'older-bundle' },
+      ],
+    });
+    expect(md).toContain('Schema compatibility warnings');
+    expect(md).toContain('tasks');
+    expect(md).toContain('older-bundle');
+  });
+
+  it('handles empty reauth and schema warnings gracefully', () => {
+    const md = buildConflictReport({
+      reports: [makeReport('config.json')],
+      bundlePath: '/tmp/x',
+      sourceMachineFingerprint: 'a',
+      targetMachineFingerprint: 'b',
+      cleoVersion: '2026.4.13',
+    });
+    // Should still produce valid markdown — either skip the empty sections or print "None"
+    expect(md.length).toBeGreaterThan(100);
+  });
+
+  it('writeConflictReport writes to .cleo/restore-conflicts.md', () => {
+    const md = '# Test Report\n';
+    fs.mkdirSync(path.join(tmpRoot, '.cleo'), { recursive: true });
+    const written = writeConflictReport(tmpRoot, md);
+    expect(written).toBe(path.join(tmpRoot, '.cleo', 'restore-conflicts.md'));
+    expect(fs.readFileSync(written, 'utf-8')).toBe(md);
+  });
+
+  it('writeConflictReport creates .cleo/ if missing', () => {
+    const md = '# Test\n';
+    const written = writeConflictReport(tmpRoot, md);
+    expect(fs.existsSync(written)).toBe(true);
+  });
+
+  it('handles missing fields (undefined values) in formatValue', () => {
+    const md = buildConflictReport({
+      reports: [makeReport('config.json')],
+      bundlePath: '/tmp/x',
+      sourceMachineFingerprint: 'a',
+      targetMachineFingerprint: 'b',
+      cleoVersion: '2026.4.13',
+    });
+    // somethingNew has local=undefined → should render as "(not present)"
+    expect(md).toContain('not present');
+  });
+
+  it('multi-file reports include all three filenames', () => {
+    const md = buildConflictReport({
+      reports: [
+        makeReport('config.json'),
+        makeReport('project-info.json'),
+        makeReport('project-context.json'),
+      ],
+      bundlePath: '/tmp/x',
+      sourceMachineFingerprint: 'a',
+      targetMachineFingerprint: 'b',
+      cleoVersion: '2026.4.13',
+    });
+    expect(md).toContain('## config.json');
+    expect(md).toContain('## project-info.json');
+    expect(md).toContain('## project-context.json');
+  });
+
+  it('includes RESOLVED placeholder in manual-review items', () => {
+    const md = buildConflictReport({
+      reports: [makeReport('config.json')],
+      bundlePath: '/tmp/x',
+      sourceMachineFingerprint: 'a',
+      targetMachineFingerprint: 'b',
+      cleoVersion: '2026.4.13',
+    });
+    expect(md).toContain('RESOLVED:');
+    expect(md).toContain('cleo restore finalize');
+  });
+
+  it('includes source bundle path in header', () => {
+    const bundlePath = '/home/user/my-project.cleobundle.tar.gz';
+    const md = buildConflictReport({
+      reports: [makeReport('config.json')],
+      bundlePath,
+      sourceMachineFingerprint: 'src-fingerprint',
+      targetMachineFingerprint: 'tgt-fingerprint',
+      cleoVersion: '2026.4.13',
+    });
+    expect(md).toContain(bundlePath);
+    expect(md).toContain('src-fingerprint');
+    expect(md).toContain('tgt-fingerprint');
+    expect(md).toContain('2026.4.13');
+  });
+
+  it('shows _None_ for empty reauth warnings', () => {
+    const md = buildConflictReport({
+      reports: [makeReport('config.json')],
+      bundlePath: '/tmp/x',
+      sourceMachineFingerprint: 'a',
+      targetMachineFingerprint: 'b',
+      cleoVersion: '2026.4.13',
+      reauthWarnings: [],
+    });
+    // When no re-auth warnings, the section should contain _None_
+    const reauthIdx = md.indexOf('Agent re-authentication required');
+    expect(reauthIdx).toBeGreaterThanOrEqual(0);
+    const afterReauth = md.slice(reauthIdx);
+    expect(afterReauth).toContain('_None_');
+  });
+
+  it('shows _None_ for empty schema warnings', () => {
+    const md = buildConflictReport({
+      reports: [makeReport('config.json')],
+      bundlePath: '/tmp/x',
+      sourceMachineFingerprint: 'a',
+      targetMachineFingerprint: 'b',
+      cleoVersion: '2026.4.13',
+      schemaWarnings: [],
+    });
+    const schemaIdx = md.indexOf('Schema compatibility warnings');
+    expect(schemaIdx).toBeGreaterThanOrEqual(0);
+    const afterSchema = md.slice(schemaIdx);
+    expect(afterSchema).toContain('_None_');
+  });
+
+  it('newer-bundle schema warning contains correct status text', () => {
+    const md = buildConflictReport({
+      reports: [makeReport('config.json')],
+      bundlePath: '/tmp/x',
+      sourceMachineFingerprint: 'a',
+      targetMachineFingerprint: 'b',
+      cleoVersion: '2026.4.13',
+      schemaWarnings: [
+        { db: 'conduit', bundleVersion: '99', localVersion: '1', severity: 'newer-bundle' },
+      ],
+    });
+    expect(md).toContain('newer-bundle: upgrade cleo for full support');
+  });
+
+  it('writeConflictReport returns absolute path', () => {
+    const md = '# X\n';
+    const written = writeConflictReport(tmpRoot, md);
+    expect(path.isAbsolute(written)).toBe(true);
+  });
+});