@mindrian_os/cli 1.13.0-beta.10 → 1.13.0-beta.44

package/lib/import/branding.test.cjs

@@ -1,235 +0,0 @@
-'use strict';
-
-/**
- * Phase 80-06 Task 1 -- branding.cjs tests.
- *
- * Zero-dep Node assert pattern. Uses os.tmpdir() for fixtures.
- */
-
-const assert = require('node:assert/strict');
-const fs = require('node:fs');
-const path = require('node:path');
-const os = require('node:os');
-const crypto = require('node:crypto');
-const matter = require('gray-matter');
-
-const branding = require('./branding.cjs');
-
-function tmpFile(contents) {
-  const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'br-' + crypto.randomBytes(4).toString('hex') + '-'));
-  const p = path.join(dir, 'artifact.md');
-  fs.writeFileSync(p, contents);
-  return p;
-}
-
-let passed = 0;
-let failed = 0;
-
-function test(name, fn) {
-  try {
-    fn();
-    process.stdout.write('ok ' + name + '\n');
-    passed++;
-  } catch (e) {
-    process.stderr.write('FAIL ' + name + '\n  ' + (e.stack || e.message) + '\n');
-    failed++;
-  }
-}
-
-// ---------------------------------------------------------------------------
-// Test 1: injectBrandedFooter
-// ---------------------------------------------------------------------------
-test('Test 1: injectBrandedFooter appends and is idempotent', function () {
-  const p = tmpFile('# Title\n\nBody text.\n');
-  const ctx = {
-    import_id: '2026-04-13-test',
-    source_vault: '/vault',
-    imported_at: '2026-04-13T10:00:00.000Z'
-  };
-
-  const first = branding.injectBrandedFooter(p, ctx);
-  assert.equal(first, true, 'first injection returns true');
-  let content = fs.readFileSync(p, 'utf8');
-  assert.ok(content.includes('MindrianOS'), 'footer contains MindrianOS');
-  assert.ok(content.includes('2026-04-13-test'), 'footer contains import_id');
-
-  const second = branding.injectBrandedFooter(p, ctx);
-  assert.equal(second, false, 'second injection returns false (idempotent)');
-  const content2 = fs.readFileSync(p, 'utf8');
-  const occurrences = (content2.match(/MindrianOS/g) || []).length;
-  assert.equal(occurrences, 1, 'footer appears exactly once');
-});
-
-// ---------------------------------------------------------------------------
-// Test 2: normalizeFrontmatter
-// ---------------------------------------------------------------------------
-test('Test 2: normalizeFrontmatter enforces canonical shape', function () {
-  const p = tmpFile('---\ntitle: Old\ncustom_field: x\nauthor: Jane\n---\n\nBody.\n');
-  const classification = { section: 'problem-definition' };
-  const ctx = {
-    import_id: '2026-04-13-test',
-    source_path: 'notes/old.md',
-    source_vault: '/vault'
-  };
-
-  const canonical = branding.normalizeFrontmatter(p, classification, ctx);
-
-  assert.equal(canonical.title, 'Old', 'title preserved');
-  assert.equal(canonical.section, 'problem-definition', 'section set');
-  assert.equal(canonical.status, 'imported', 'status imported');
-  assert.equal(canonical.imported_from, 'notes/old.md', 'imported_from set');
-  assert.ok(/^\d{4}-\d{2}-\d{2}T/.test(canonical.imported_at), 'imported_at is ISO-like');
-  assert.equal(canonical.import_id, '2026-04-13-test', 'import_id set');
-  assert.ok(Array.isArray(canonical.source_wikilinks), 'source_wikilinks is array');
-  assert.ok(Array.isArray(canonical.tags), 'tags is array');
-  assert.ok(canonical._source_frontmatter, '_source_frontmatter present');
-  assert.equal(canonical._source_frontmatter.custom_field, 'x', 'custom_field preserved');
-  assert.equal(canonical._source_frontmatter.author, 'Jane', 'author preserved');
-
-  // Re-read and verify serialized form
-  const reparsed = matter(fs.readFileSync(p, 'utf8'));
-  assert.equal(reparsed.data.title, 'Old');
-  assert.equal(reparsed.data.section, 'problem-definition');
-  assert.equal(reparsed.data.status, 'imported');
-});
-
-// ---------------------------------------------------------------------------
-// Test 3: promoteCalloutFields
-// ---------------------------------------------------------------------------
-test('Test 3: promoteCalloutFields produces callout blocks from _source_frontmatter', function () {
-  // Seed with a post-normalize shape
-  const fm = {
-    title: 'Meeting',
-    section: 'team-execution',
-    status: 'imported',
-    imported_from: 'm.md',
-    imported_at: '2026-04-13T10:00:00.000Z',
-    import_id: '2026-04-13-test',
-    source_wikilinks: [],
-    tags: [],
-    _source_frontmatter: {
-      author: 'Jane Doe',
-      attendees: ['Jane Doe', 'John Roe'],
-      date: '2026-01-15'
-    }
-  };
-  const raw = matter.stringify('Meeting body.\n', fm);
-  const p = tmpFile(raw);
-
-  const changed = branding.promoteCalloutFields(p);
-  assert.equal(changed, true, 'promotion returned true');
-
-  const content = fs.readFileSync(p, 'utf8');
-  assert.ok(content.includes('<!-- destijl-callout -->'), 'callout marker present');
-  assert.ok(content.includes('> [!author] Jane Doe'), 'author callout');
-  assert.ok(content.includes('> [!attendees] Jane Doe, John Roe'), 'attendees callout');
-  assert.ok(content.includes('> [!date] 2026-01-15'), 'date callout');
-
-  // Idempotent
-  const again = branding.promoteCalloutFields(p);
-  assert.equal(again, false, 'second promotion returns false');
-  const content2 = fs.readFileSync(p, 'utf8');
-  const markers = (content2.match(/destijl-callout/g) || []).length;
-  assert.equal(markers, 1, 'exactly one callout marker');
-});
-
-// ---------------------------------------------------------------------------
-// Test 4: applyBranding idempotent end-to-end
-// ---------------------------------------------------------------------------
-test('Test 4: applyBranding is fully idempotent on second run', function () {
-  const p = tmpFile('---\ntitle: Notes\nauthor: Jane\ndate: 2026-02-01\ncustom: keep\n---\n\n# Heading\n\nBody paragraph.\n');
-  const cls = { section: 'market-analysis' };
-  const ctx = {
-    import_id: '2026-04-13-test',
-    source_path: 'notes/n.md',
-    source_vault: '/vault',
-    imported_at: '2026-04-13T10:00:00.000Z'
-  };
-
-  branding.applyBranding(p, cls, ctx);
-  const first = fs.readFileSync(p, 'utf8');
-  branding.applyBranding(p, cls, ctx);
-  const second = fs.readFileSync(p, 'utf8');
-
-  assert.equal(first, second, 'second applyBranding produced identical content');
-
-  // Checks
-  assert.ok(first.includes('MindrianOS'), 'footer present');
-  assert.ok(first.includes('<!-- destijl-callout -->'), 'callout marker present');
-  assert.ok(first.includes('> [!author] Jane'), 'author callout rendered');
-  assert.ok(first.includes('> [!date] 2026-02-01'), 'date callout rendered');
-
-  const fmParsed = matter(first);
-  assert.equal(fmParsed.data.section, 'market-analysis');
-  assert.equal(fmParsed.data.status, 'imported');
-  assert.ok(fmParsed.data._source_frontmatter, '_source_frontmatter preserved');
-  assert.equal(fmParsed.data._source_frontmatter.custom, 'keep', 'non-canonical field preserved');
-
-  const footerOccurrences = (first.match(/MindrianOS/g) || []).length;
-  assert.equal(footerOccurrences, 1, 'footer appears exactly once after double apply');
-});
-
-// ---------------------------------------------------------------------------
-// Test 5: enricher hook -- after enrichRoom runs, each file has branding
-// ---------------------------------------------------------------------------
-test('Test 5: enrichRoom hook applies branding to routed files', function () {
-  const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'br-enrich-' + crypto.randomBytes(4).toString('hex') + '-'));
-  const roomDir = path.join(dir, 'room');
-  const section = path.join(roomDir, 'problem-definition', 'onboarding');
-  fs.mkdirSync(section, { recursive: true });
-  const artifactPath = path.join(section, 'onboarding.md');
-  fs.writeFileSync(
-    artifactPath,
-    '---\ntitle: Onboarding\nauthor: Jane\n---\n\n# Onboarding\n\nBody.\n'
-  );
-
-  const manifest = {
-    import_id: '2026-04-13-enrich-test',
-    source_vault: '/vault',
-    destination_room: roomDir,
-    stage_states: { enrich: {} },
-    warnings: [],
-    people: [],
-    files: [
-      {
-        id: 'f1',
-        source_path: 'notes/onboarding.md',
-        destination_folder: path.join('problem-definition', 'onboarding'),
-        destination_path: path.join('problem-definition', 'onboarding', 'onboarding.md'),
-        destination_abs_path: artifactPath,
-        destination_section: 'problem-definition',
-        classification: { section: 'problem-definition', decision: 'AUTO', confidence: 0.9 },
-        source_wikilinks: []
-      }
-    ]
-  };
-
-  const { enrichRoom } = require('./enricher.cjs');
-  enrichRoom(manifest, { roomDir: roomDir });
-
-  const content = fs.readFileSync(artifactPath, 'utf8');
-  assert.ok(content.includes('MindrianOS'), 'branded footer present after enrichRoom');
-  const fm = matter(content).data;
-  assert.equal(fm.status, 'imported', 'canonical status set');
-  assert.equal(fm.section, 'problem-definition', 'section normalized');
-  assert.equal(fm.import_id, '2026-04-13-enrich-test', 'import_id in frontmatter');
-  assert.ok(content.includes('> [!author] Jane'), 'author callout promoted');
-
-  fs.rmSync(dir, { recursive: true, force: true });
-});
-
-// ---------------------------------------------------------------------------
-// Test 6: no em-dashes
-// ---------------------------------------------------------------------------
-test('Test 6: branding.cjs and branding.test.cjs contain no em-dashes', function () {
-  const emDash = '\u2014';
-  const mod = fs.readFileSync(path.join(__dirname, 'branding.cjs'), 'utf8');
-  const tst = fs.readFileSync(__filename, 'utf8');
-  assert.equal(mod.indexOf(emDash), -1, 'branding.cjs has no em-dash');
-  assert.equal(tst.indexOf(emDash), -1, 'branding.test.cjs has no em-dash');
-});
-
-// ---------------------------------------------------------------------------
-process.stdout.write('\n' + passed + ' passed, ' + failed + ' failed\n');
-if (failed > 0) process.exit(1);
-process.stdout.write('all passing\n');

package/lib/import/classifications-sync.cjs

@@ -1,104 +0,0 @@
-'use strict';
-
-/**
- * classifications-sync.cjs -- round-trip Larry/human edits from the Stage 02
- * classifications.md review gate back into MANIFEST.json.
- *
- * Addresses Blocker 4 from the Phase 80 plan-check (CONTEXT.md Locked Fix 4):
- * when a human opens classifications.md, edits a row, and saves, those edits
- * MUST persist into manifest.files[].classification before Stage 03 routes.
- *
- * The classifications.md table shape (rendered by Stage 02) is:
- *   | File | Section | Confidence | Evidence | Decision |
- *   |------|---------|------------|----------|----------|
- *   | notes/onboarding.md | problem-definition | 0.84 | "..." | AUTO |
- */
-
-const fs = require('node:fs');
-const manifestMod = require('./manifest.cjs');
-
-function parseClassificationsMarkdown(mdPath) {
-  const raw = fs.readFileSync(mdPath, 'utf8');
-  const lines = raw.split(/\r?\n/);
-  const rows = [];
-  let inTable = false;
-  for (const line of lines) {
-    if (/^\|\s*File\s*\|/i.test(line)) {
-      inTable = true;
-      continue;
-    }
-    if (!inTable) continue;
-    if (/^\|\s*-+/.test(line)) continue;
-    if (line.trim() === '') {
-      if (rows.length > 0) break;
-      continue;
-    }
-    if (!line.trim().startsWith('|')) {
-      if (rows.length > 0) break;
-      continue;
-    }
-    const cells = line.split('|').slice(1, -1).map(function (c) { return c.trim(); });
-    if (cells.length < 5) {
-      throw new Error('malformed classifications row (expected 5 columns, got ' + cells.length + '): ' + line);
-    }
-    const file = cells[0];
-    const section = cells[1];
-    const confidenceRaw = cells[2];
-    const evidence = cells[3];
-    const decision = cells[4];
-    const confidence = Number(confidenceRaw);
-    if (!Number.isFinite(confidence)) {
-      throw new Error('malformed classifications row (confidence not numeric): ' + line);
-    }
-    rows.push({
-      file: file,
-      section: section,
-      confidence: confidence,
-      evidence: evidence,
-      decision: decision
-    });
-  }
-  return rows;
-}
-
-function syncClassificationsToManifest(mdPath, manifestPath) {
-  const rows = parseClassificationsMarkdown(mdPath);
-  const manifest = manifestMod.readManifest(manifestPath);
-  const byPath = new Map();
-  for (const f of manifest.files) {
-    byPath.set(f.source_path, f);
-  }
-  let edits = 0;
-  for (const row of rows) {
-    const f = byPath.get(row.file);
-    if (!f) {
-      manifest.warnings = manifest.warnings || [];
-      manifest.warnings.push({ type: 'classification_unmatched', context: row.file });
-      continue;
-    }
-    const prev = f.classification || {};
-    if (
-      prev.section !== row.section ||
-      prev.decision !== row.decision ||
-      prev.confidence !== row.confidence
-    ) {
-      edits += 1;
-    }
-    f.classification = {
-      section: row.section,
-      confidence: row.confidence,
-      evidence: row.evidence,
-      decision: row.decision,
-      stage: 'classify'
-    };
-  }
-  manifest.stage_states.classify.human_edited = edits > 0 || manifest.stage_states.classify.human_edited === true;
-  manifest.stage_states.classify.edits_count = (manifest.stage_states.classify.edits_count || 0) + edits;
-  manifestMod.writeManifest(manifestPath, manifest);
-  return { rows: rows.length, edits: edits };
-}
-
-module.exports = {
-  parseClassificationsMarkdown: parseClassificationsMarkdown,
-  syncClassificationsToManifest: syncClassificationsToManifest
-};

package/lib/import/classifications-sync.test.cjs

@@ -1,129 +0,0 @@
-#!/usr/bin/env node
-'use strict';
-
-/**
- * Unit tests for lib/import/classifications-sync.cjs
- * Run: node lib/import/classifications-sync.test.cjs
- */
-
-const assert = require('node:assert/strict');
-const fs = require('node:fs');
-const os = require('node:os');
-const path = require('node:path');
-const manifestMod = require('./manifest.cjs');
-const sync = require('./classifications-sync.cjs');
-
-let passed = 0;
-let failed = 0;
-function test(name, fn) {
-  try {
-    fn();
-    passed += 1;
-    process.stdout.write('  ok  ' + name + '\n');
-  } catch (err) {
-    failed += 1;
-    process.stdout.write('  FAIL ' + name + '\n    ' + err.message + '\n');
-  }
-}
-
-const tmpRoot = fs.mkdtempSync(path.join(os.tmpdir(), 'cs-test-'));
-
-function seedManifest(fileRows) {
-  const manifest = manifestMod.createManifest('/tmp/v', '2026-04-13-cs');
-  fileRows.forEach(function (row, i) {
-    manifest.files.push({
-      id: 'f_' + String(i + 1).padStart(3, '0'),
-      source_path: row.source_path,
-      source_size: 1,
-      source_mtime: '2026-01-01T00:00:00.000Z',
-      source_hash: 'sha1:aaa',
-      source_frontmatter: {},
-      source_wikilinks: [],
-      parent_folder: null,
-      classification: row.classification || null
-    });
-  });
-  return manifest;
-}
-
-function writeClassificationsMd(filePath, rows) {
-  let out = '| File | Section | Confidence | Evidence | Decision |\n';
-  out += '|------|---------|------------|----------|----------|\n';
-  for (const r of rows) {
-    out += '| ' + r.file + ' | ' + r.section + ' | ' + r.confidence + ' | ' + r.evidence + ' | ' + r.decision + ' |\n';
-  }
-  fs.writeFileSync(filePath, out, 'utf8');
-}
-
-test('round-trip: write classifications.md, parse, get back same rows', function () {
-  const mdPath = path.join(tmpRoot, 'rt.md');
-  const rows = [
-    { file: 'notes/a.md', section: 'problem-definition', confidence: '0.84', evidence: 'clear signal', decision: 'AUTO' },
-    { file: 'notes/b.md', section: 'business-model', confidence: '0.58', evidence: 'freemium', decision: 'SUGGEST' },
-    { file: 'notes/c.md', section: 'inbox', confidence: '0.31', evidence: 'no signal', decision: 'INBOX' }
-  ];
-  writeClassificationsMd(mdPath, rows);
-  const parsed = sync.parseClassificationsMarkdown(mdPath);
-  assert.equal(parsed.length, 3);
-  assert.equal(parsed[0].file, 'notes/a.md');
-  assert.equal(parsed[0].section, 'problem-definition');
-  assert.equal(parsed[0].confidence, 0.84);
-  assert.equal(parsed[0].decision, 'AUTO');
-});
-
-test('section edit: inbox -> problem-definition persists into manifest', function () {
-  const manifestPath = path.join(tmpRoot, 'sec.json');
-  const mdPath = path.join(tmpRoot, 'sec.md');
-  const manifest = seedManifest([
-    { source_path: 'notes/a.md', classification: { section: 'inbox', confidence: 0.31, evidence: 'no signal', decision: 'INBOX', stage: 'classify' } }
-  ]);
-  manifestMod.writeManifest(manifestPath, manifest);
-  writeClassificationsMd(mdPath, [
-    { file: 'notes/a.md', section: 'problem-definition', confidence: '0.80', evidence: 'edited', decision: 'AUTO' }
-  ]);
-  const result = sync.syncClassificationsToManifest(mdPath, manifestPath);
-  assert.equal(result.rows, 1);
-  assert.equal(result.edits, 1);
-  const back = manifestMod.readManifest(manifestPath);
-  assert.equal(back.files[0].classification.section, 'problem-definition');
-  assert.equal(back.stage_states.classify.human_edited, true);
-  assert.equal(back.stage_states.classify.edits_count, 1);
-});
-
-test('decision edit: INBOX -> AUTO persists into manifest', function () {
-  const manifestPath = path.join(tmpRoot, 'dec.json');
-  const mdPath = path.join(tmpRoot, 'dec.md');
-  const manifest = seedManifest([
-    { source_path: 'notes/a.md', classification: { section: 'problem-definition', confidence: 0.5, evidence: 'ok', decision: 'INBOX', stage: 'classify' } }
-  ]);
-  manifestMod.writeManifest(manifestPath, manifest);
-  writeClassificationsMd(mdPath, [
-    { file: 'notes/a.md', section: 'problem-definition', confidence: '0.5', evidence: 'ok', decision: 'AUTO' }
-  ]);
-  sync.syncClassificationsToManifest(mdPath, manifestPath);
-  const back = manifestMod.readManifest(manifestPath);
-  assert.equal(back.files[0].classification.decision, 'AUTO');
-});
-
-test('malformed row (missing Decision column) throws', function () {
-  const mdPath = path.join(tmpRoot, 'bad.md');
-  let out = '| File | Section | Confidence | Evidence | Decision |\n';
-  out += '|------|---------|------------|----------|----------|\n';
-  out += '| notes/a.md | problem-definition | 0.84 | "ok" |\n';
-  fs.writeFileSync(mdPath, out, 'utf8');
-  assert.throws(function () { sync.parseClassificationsMarkdown(mdPath); }, /malformed classifications row/);
-});
-
-test('confidence "0.84" parses as Number 0.84 (not string)', function () {
-  const mdPath = path.join(tmpRoot, 'num.md');
-  writeClassificationsMd(mdPath, [
-    { file: 'notes/a.md', section: 'problem-definition', confidence: '0.84', evidence: 'ok', decision: 'AUTO' }
-  ]);
-  const parsed = sync.parseClassificationsMarkdown(mdPath);
-  assert.equal(typeof parsed[0].confidence, 'number');
-  assert.equal(parsed[0].confidence, 0.84);
-});
-
-process.stdout.write('\n' + passed + ' passed, ' + failed + ' failed\n');
-if (failed > 0) process.exit(1);
-process.stdout.write('PASS\n');