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

package/lib/import/smoke-test.test.cjs

@@ -1,148 +0,0 @@
-'use strict';
-
-/**
- * Phase 80-06 Task 2 -- smoke-test.cjs tests.
- *
- * Uses compute-state fallback by default (mindrian-tools is blocked by the
- * lazygraph-ops PRECONDITIONS issue).
- */
-
-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 { runMosSmokeTest, renderSmokeTestSection, parseSectionCounts } = require('./smoke-test.cjs');
-
-function tmpRoom(prefix) {
-  const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'st-' + prefix + '-' + crypto.randomBytes(4).toString('hex') + '-'));
-  fs.writeFileSync(path.join(dir, 'STATE.md'), '---\nstatus: executing\n---\n\n# Room\n');
-  return dir;
-}
-
-function cleanup(dir) {
-  try { fs.rmSync(dir, { recursive: true, force: true }); } catch (e) { /* soft */ }
-}
-
-function writeArtifact(roomDir, relPath, body) {
-  const abs = path.join(roomDir, relPath);
-  fs.mkdirSync(path.dirname(abs), { recursive: true });
-  fs.writeFileSync(abs, body || '---\ntitle: x\n---\n\n# x\n');
-}
-
-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: happy path -- populated problem-definition passes
-// ---------------------------------------------------------------------------
-test('Test 1: runMosSmokeTest passes on populated room', function () {
-  const room = tmpRoom('happy');
-  try {
-    writeArtifact(room, 'problem-definition/onboarding.md');
-    writeArtifact(room, 'problem-definition/pricing.md');
-    const r = runMosSmokeTest(room);
-    assert.equal(typeof r, 'object');
-    assert.equal(typeof r.passed, 'boolean');
-    assert.ok(r.method, 'method set (got ' + r.method + ')');
-    assert.ok((r.sectionCounts['problem-definition'] || 0) >= 1, 'problem-definition counted (got ' + r.sectionCounts['problem-definition'] + ')');
-    assert.equal(r.passed, true, 'passed=true when canonical section populated');
-  } finally { cleanup(room); }
-});
-
-// ---------------------------------------------------------------------------
-// Test 2: empty room -- warning + passed false
-// ---------------------------------------------------------------------------
-test('Test 2: empty room returns passed=false with warning', function () {
-  const room = tmpRoom('empty');
-  try {
-    const r = runMosSmokeTest(room);
-    assert.equal(r.passed, false, 'empty room passed=false');
-    assert.ok(r.warnings.some(function (w) { return /no populated canonical sections/.test(w); }), 'warning present (got: ' + JSON.stringify(r.warnings) + ')');
-  } finally { cleanup(room); }
-});
-
-// ---------------------------------------------------------------------------
-// Test 3: team count via filesystem walk
-// ---------------------------------------------------------------------------
-test('Test 3: team count picked up via filesystem walk', function () {
-  const room = tmpRoom('team');
-  try {
-    writeArtifact(room, 'team/core-team/jane-doe/jane-doe.md');
-    writeArtifact(room, 'team/core-team/jane-doe/ROOM.md', '# ROOM\n');
-    const r = runMosSmokeTest(room);
-    assert.ok((r.sectionCounts.team || 0) >= 1, 'team >= 1 (got ' + r.sectionCounts.team + ')');
-  } finally { cleanup(room); }
-});
-
-// ---------------------------------------------------------------------------
-// Test 4: forceFallback path
-// ---------------------------------------------------------------------------
-test('Test 4: forceFallback reaches compute-state and returns result', function () {
-  const room = tmpRoom('fb');
-  try {
-    writeArtifact(room, 'solution-design/arch.md');
-    const r = runMosSmokeTest(room, { forceFallback: true });
-    assert.equal(r.method, 'compute-state', 'method=compute-state (got ' + r.method + ')');
-    assert.ok((r.sectionCounts['solution-design'] || 0) >= 1, 'solution-design counted');
-    assert.equal(r.passed, true);
-  } finally { cleanup(room); }
-});
-
-// ---------------------------------------------------------------------------
-// Test 5: renderSmokeTestSection emits the required heading
-// ---------------------------------------------------------------------------
-test('Test 5: renderSmokeTestSection contains "/mos: Usability Check" heading', function () {
-  const md = renderSmokeTestSection({ passed: true, method: 'compute-state', sectionCounts: { 'problem-definition': 3 }, warnings: [] });
-  assert.match(md, /## \/mos: Usability Check/, 'heading present');
-  assert.match(md, /problem-definition: 3/, 'section count rendered');
-});
-
-// ---------------------------------------------------------------------------
-// Test 6: parseSectionCounts handles compute-state table fragment
-// ---------------------------------------------------------------------------
-test('Test 6: parseSectionCounts parses a compute-state-style table', function () {
-  const sample = [
-    '# Data Room State',
-    '',
-    '## Sections',
-    '| Section | Entries | Progress | Status | Last Updated |',
-    '|---------|---------|----------|--------|-------------|',
-    '| problem-definition | 3 | [bar] | Well-developed | 2026-04-13 |',
-    '| inbox | 1 | [bar] | Active | 2026-04-13 |',
-    '',
-    '## Gaps',
-    '- nothing'
-  ].join('\n');
-  const counts = parseSectionCounts(sample);
-  assert.equal(counts['problem-definition'], 3);
-  assert.equal(counts['inbox'], 1);
-});
-
-// ---------------------------------------------------------------------------
-// Test 7: no em-dashes
-// ---------------------------------------------------------------------------
-test('Test 7: smoke-test.cjs and smoke-test.test.cjs contain no em-dashes', function () {
-  const emDash = '\u2014';
-  const mod = fs.readFileSync(path.join(__dirname, 'smoke-test.cjs'), 'utf8');
-  const tst = fs.readFileSync(__filename, 'utf8');
-  assert.equal(mod.indexOf(emDash), -1);
-  assert.equal(tst.indexOf(emDash), -1);
-});
-
-// ---------------------------------------------------------------------------
-process.stdout.write('\n' + passed + ' passed, ' + failed + ' failed\n');
-if (failed > 0) process.exit(1);
-process.stdout.write('all passing\n');

package/lib/import/test-fixtures/collision-vault/preexisting-room/STATE.md

@@ -1,8 +0,0 @@
----
-gsd_state_version: 1.0
-status: executing
----
-
-# Project State
-
-Minimal preexisting room used by Phase 80 collision tests.

package/lib/import/test-fixtures/collision-vault/preexisting-room/problem-definition/onboarding/onboarding.md

@@ -1,7 +0,0 @@
----
-title: Onboarding pain (preexisting)
-section: problem-definition
----
-This is the preexisting artifact in the collision target location. Phase 80
-router tests will detect the filename collision against this file and route
-the incoming onboarding.md into an `-imported-{date}` sibling folder.

package/lib/import/test-fixtures/collision-vault/source/onboarding.md

@@ -1,5 +0,0 @@
----
-title: Onboarding pain
-section: problem-definition
----
-A colliding onboarding note that should trigger the -imported-{date} suffix path.

package/lib/import/test-fixtures/obsidian-vault/.obsidian/workspace.json

@@ -1 +0,0 @@
-{"main": "scanner-must-skip-this"}

package/lib/import/test-fixtures/obsidian-vault/notes/with-wikilinks.md

@@ -1,4 +0,0 @@
----
-title: Wikilink sample
----
-see [[dror-cohen]] and [[activation-funnel]]

package/lib/import/test-fixtures/tiny-vault/notes/2026-01-15-team-sync.md

@@ -1,9 +0,0 @@
----
-title: Team sync
-attendees: ["Jane Doe", "John Roe"]
----
-## Attendees
-- Jane Doe
-- John Roe
-
-Discussed onboarding flow and pricing. Jane Doe, co-founder.

package/lib/import/test-fixtures/tiny-vault/notes/empty.md

@@ -1,3 +0,0 @@
----
-title: Empty placeholder
----

package/lib/import/test-fixtures/tiny-vault/notes/onboarding.md

@@ -1,5 +0,0 @@
----
-title: Onboarding pain
-tags: [activation, dror]
----
-Dror could not activate alone. The funnel is broken at step 3.

package/lib/import/test-fixtures/tiny-vault/notes/pricing.md

@@ -1,5 +0,0 @@
----
-title: Pricing notes
-tags: [business-model, freemium]
----
-Freemium tier with usage-based upgrade path. Convert at 10% target.

package/lib/import/test-fixtures/tiny-vault/notes/random.md

@@ -1,4 +0,0 @@
----
-title: Random thoughts
----
-Unsorted note with no clear section signal. Placeholder content for inbox routing test.

package/lib/import/undo.test.cjs

@@ -1,199 +0,0 @@
-'use strict';
-
-/**
- * Phase 80 Plan 80-05 -- undo roundtrip end-to-end.
- *
- * Runs scripts/vault-import.cjs as a subprocess against tiny-vault, captures
- * routed files, then runs --undo and asserts:
- *   1. Routed files are moved to imports/{id}/undone/ (not deleted, not
- *      restored to source)
- *   2. Running --undo again is idempotent (exit 0, no errors, no changes)
- *   3. IMPORT-REPORT.md gains UNDONE: true in its frontmatter after undo
- *   4. The source vault is untouched
- *   5. --undo against a missing import id exits non-zero
- */
-
-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 { spawnSync } = require('node:child_process');
-
-const pluginRoot = path.resolve(__dirname, '../..');
-const script = path.join(pluginRoot, 'scripts/vault-import.cjs');
-const tinyVault = path.join(pluginRoot, 'lib/import/test-fixtures/tiny-vault');
-
-function tmpDir(prefix) {
-  return fs.mkdtempSync(path.join(os.tmpdir(), 'vi-undo-' + prefix + '-' + crypto.randomBytes(4).toString('hex') + '-'));
-}
-
-function copyDir(src, dst) {
-  fs.mkdirSync(dst, { recursive: true });
-  for (const entry of fs.readdirSync(src, { withFileTypes: true })) {
-    const s = path.join(src, entry.name);
-    const d = path.join(dst, entry.name);
-    if (entry.isDirectory()) copyDir(s, d);
-    else if (entry.isFile()) fs.copyFileSync(s, d);
-  }
-}
-
-function scaffoldMinimalRoom(dir) {
-  fs.mkdirSync(dir, { recursive: true });
-  fs.writeFileSync(path.join(dir, 'STATE.md'), '---\ngsd_state_version: 1.0\nstatus: executing\n---\n\n# Room\n');
-}
-
-function run(args) {
-  const res = spawnSync(process.execPath, [script].concat(args), {
-    encoding: 'utf8',
-    stdio: ['ignore', 'pipe', 'pipe']
-  });
-  return { code: res.status, stdout: res.stdout || '', stderr: res.stderr || '' };
-}
-
-function cleanup(dir) {
-  try { fs.rmSync(dir, { recursive: true, force: true }); } catch (e) { /* soft */ }
-}
-
-function snapshotSourceVault(dir) {
-  const out = {};
-  function walk(d, rel) {
-    for (const entry of fs.readdirSync(d, { withFileTypes: true })) {
-      const full = path.join(d, entry.name);
-      const r = path.join(rel, entry.name);
-      if (entry.isDirectory()) walk(full, r);
-      else if (entry.isFile()) out[r] = fs.readFileSync(full, 'utf8');
-    }
-  }
-  walk(dir, '');
-  return out;
-}
-
-let passed = 0, 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: roundtrip -- import then undo
-// ---------------------------------------------------------------------------
-test('undo moves routed files to imports/{id}/undone/ and marks report', function () {
-  const src = tmpDir('rt-src');
-  const dst = tmpDir('rt-dst');
-  try {
-    copyDir(tinyVault, src);
-    scaffoldMinimalRoom(dst);
-    const sourceBefore = snapshotSourceVault(src);
-
-    // Run full pipeline
-    let r = run(['--path', src, '--room', dst, '--yes']);
-    assert.equal(r.code, 0, 'import exit 0 (stderr=' + r.stderr + ')');
-
-    const importsRoot = path.join(dst, 'imports');
-    const importIds = fs.readdirSync(importsRoot);
-    assert.equal(importIds.length, 1, 'one import dir');
-    const importId = importIds[0];
-    const importDir = path.join(importsRoot, importId);
-    const manifestPath = path.join(importDir, '01-ingest/output/MANIFEST.json');
-    const m = JSON.parse(fs.readFileSync(manifestPath, 'utf8'));
-
-    // Capture routed destinations that actually exist on disk
-    const routedExisting = [];
-    for (const f of m.files) {
-      if (f.destination_abs_path && fs.existsSync(f.destination_abs_path)) {
-        routedExisting.push(f.destination_abs_path);
-      }
-    }
-    assert.ok(routedExisting.length > 0, 'at least one routed file exists pre-undo');
-
-    // Run undo
-    r = run(['--undo', importId, '--room', dst]);
-    assert.equal(r.code, 0, 'undo exit 0 (stderr=' + r.stderr + ')');
-
-    // Every previously routed file must now be gone from its destination
-    for (const abs of routedExisting) {
-      assert.ok(!fs.existsSync(abs), 'routed file removed from destination: ' + abs);
-    }
-
-    // All moved files must be present somewhere under imports/{id}/undone/
-    const undoneRoot = path.join(importDir, 'undone');
-    assert.ok(fs.existsSync(undoneRoot), 'undone/ exists');
-    const undoneFiles = [];
-    (function walk(d) {
-      for (const entry of fs.readdirSync(d, { withFileTypes: true })) {
-        const p = path.join(d, entry.name);
-        if (entry.isDirectory()) walk(p);
-        else if (entry.isFile()) undoneFiles.push(p);
-      }
-    })(undoneRoot);
-    assert.ok(undoneFiles.length >= routedExisting.length, 'undone/ holds at least routed count (got ' + undoneFiles.length + ', expected >= ' + routedExisting.length + ')');
-
-    // Manifest marked undone
-    const mAfter = JSON.parse(fs.readFileSync(manifestPath, 'utf8'));
-    assert.equal(mAfter.undo.is_undone, true, 'manifest.undo.is_undone');
-    assert.ok(mAfter.undo.undone_at, 'undone_at set');
-
-    // Report has UNDONE: true
-    const report = fs.readFileSync(path.join(importDir, 'IMPORT-REPORT.md'), 'utf8');
-    assert.ok(/^---\nUNDONE: true\n/.test(report), 'IMPORT-REPORT.md has UNDONE: true');
-
-    // Source vault untouched
-    const sourceAfter = snapshotSourceVault(src);
-    assert.deepEqual(sourceAfter, sourceBefore, 'source vault unchanged by undo');
-  } finally {
-    cleanup(src);
-    cleanup(dst);
-  }
-});
-
-// ---------------------------------------------------------------------------
-// Test 2: idempotent -- running undo twice is a no-op exit 0
-// ---------------------------------------------------------------------------
-test('undo is idempotent (second run exits 0)', function () {
-  const src = tmpDir('idem-src');
-  const dst = tmpDir('idem-dst');
-  try {
-    copyDir(tinyVault, src);
-    scaffoldMinimalRoom(dst);
-
-    let r = run(['--path', src, '--room', dst, '--yes']);
-    assert.equal(r.code, 0, 'import exit 0');
-
-    const importId = fs.readdirSync(path.join(dst, 'imports'))[0];
-
-    r = run(['--undo', importId, '--room', dst]);
-    assert.equal(r.code, 0, 'first undo exit 0');
-
-    r = run(['--undo', importId, '--room', dst]);
-    assert.equal(r.code, 0, 'second undo exit 0');
-    assert.ok(/already undone/.test(r.stdout), 'second undo reports already undone');
-  } finally {
-    cleanup(src);
-    cleanup(dst);
-  }
-});
-
-// ---------------------------------------------------------------------------
-// Test 3: missing import id -> non-zero exit
-// ---------------------------------------------------------------------------
-test('undo against missing import id exits non-zero', function () {
-  const dst = tmpDir('miss-dst');
-  try {
-    scaffoldMinimalRoom(dst);
-    const r = run(['--undo', '9999-99-99-nothing', '--room', dst]);
-    assert.notEqual(r.code, 0, 'non-zero exit for missing id');
-    assert.ok(/manifest not found/.test(r.stderr), 'stderr mentions manifest not found');
-  } finally {
-    cleanup(dst);
-  }
-});
-
-process.stdout.write('\n' + passed + ' passed, ' + failed + ' failed\n');
-if (failed > 0) process.exit(1);

package/lib/import/vault-scanner.cjs

@@ -1,105 +0,0 @@
-'use strict';
-
-/**
- * Deterministic vault scanner for Phase 80 Stage 01 (ingest).
- *
- * Walks a directory of .md/.markdown files and returns the files[] array
- * consumed by Stage 02. No AI. No file moves. Safe to re-run.
- *
- * Skips .obsidian/, .git/, node_modules/, .trash/, hidden dirs, and any
- * folder in SKIP_DIRS. Parses YAML frontmatter via gray-matter with a
- * try/catch that swallows malformed YAML (sets source_frontmatter = {}).
- */
-
-const fs = require('node:fs');
-const path = require('node:path');
-const crypto = require('node:crypto');
-const matter = require('gray-matter');
-
-const SKIP_DIRS = new Set([
-  '.obsidian',
-  '.git',
-  'node_modules',
-  '.trash',
-  '.context',
-  '.lazygraph',
-  '.mindrian'
-]);
-const MD_EXT = new Set(['.md', '.markdown']);
-const WIKILINK_RE = /\[\[([^\]]+)\]\]/g;
-
-function scanVault(sourcePath, opts) {
-  opts = opts || {};
-  if (!fs.existsSync(sourcePath)) {
-    throw new Error('source path not found: ' + sourcePath);
-  }
-  const files = [];
-  const skipped = [];
-  let counter = 0;
-
-  function walk(dir, rel) {
-    let entries;
-    try {
-      entries = fs.readdirSync(dir, { withFileTypes: true });
-    } catch (e) {
-      return;
-    }
-    // Stable ordering for deterministic output
-    entries.sort(function (a, b) { return a.name < b.name ? -1 : a.name > b.name ? 1 : 0; });
-    for (const entry of entries) {
-      const relPath = rel ? path.join(rel, entry.name) : entry.name;
-      if (entry.isDirectory()) {
-        if (SKIP_DIRS.has(entry.name) || (entry.name.startsWith('.') && entry.name !== '.')) {
-          skipped.push(relPath);
-          continue;
-        }
-        walk(path.join(dir, entry.name), relPath);
-        continue;
-      }
-      if (!entry.isFile()) continue;
-      const ext = path.extname(entry.name).toLowerCase();
-      if (!MD_EXT.has(ext)) continue;
-
-      const abs = path.join(dir, entry.name);
-      let content;
-      try {
-        content = fs.readFileSync(abs, 'utf8');
-      } catch (e) {
-        skipped.push(relPath);
-        continue;
-      }
-      let parsed = { data: {}, content: content };
-      try {
-        parsed = matter(content);
-      } catch (e) {
-        parsed = { data: {}, content: content };
-      }
-      const wikilinks = [];
-      let m;
-      const body = parsed.content || '';
-      WIKILINK_RE.lastIndex = 0;
-      while ((m = WIKILINK_RE.exec(body)) !== null) {
-        const target = m[1].split('|')[0].trim();
-        if (target) wikilinks.push(target);
-      }
-      const stat = fs.statSync(abs);
-      counter += 1;
-      files.push({
-        id: 'f_' + String(counter).padStart(3, '0'),
-        source_path: relPath,
-        source_abs_path: abs,
-        source_size: stat.size,
-        source_mtime: stat.mtime.toISOString(),
-        source_hash: 'sha1:' + crypto.createHash('sha1').update(content).digest('hex'),
-        source_frontmatter: parsed.data || {},
-        source_wikilinks: wikilinks,
-        parent_folder: rel ? path.basename(rel) : null
-      });
-    }
-  }
-
-  walk(sourcePath, '');
-  return { files: files, skipped: skipped };
-}
-
-module.exports = { scanVault: scanVault, SKIP_DIRS: SKIP_DIRS };

package/lib/import/vault-scanner.test.cjs

@@ -1,67 +0,0 @@
-#!/usr/bin/env node
-'use strict';
-
-/**
- * Unit tests for lib/import/vault-scanner.cjs
- * Run: node lib/import/vault-scanner.test.cjs
- */
-
-const assert = require('node:assert/strict');
-const path = require('node:path');
-const { scanVault } = require('./vault-scanner.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 TINY = path.join(__dirname, 'test-fixtures', 'tiny-vault');
-const OBS = path.join(__dirname, 'test-fixtures', 'obsidian-vault');
-
-test('scanVault on tiny-vault returns 5 files with full metadata', function () {
-  const r = scanVault(TINY);
-  assert.equal(r.files.length, 5, 'expected 5 files, got ' + r.files.length);
-  for (const f of r.files) {
-    assert.ok(f.source_path, 'source_path');
-    assert.ok(typeof f.source_size === 'number', 'source_size');
-    assert.ok(f.source_mtime, 'source_mtime');
-    assert.ok(/^sha1:[0-9a-f]{40}$/.test(f.source_hash), 'source_hash sha1');
-    assert.ok(f.source_frontmatter && typeof f.source_frontmatter === 'object', 'source_frontmatter');
-    assert.ok(Array.isArray(f.source_wikilinks), 'source_wikilinks array');
-    assert.ok('parent_folder' in f, 'parent_folder');
-  }
-});
-
-test('scanVault skips .obsidian/, .git/, hidden dirs', function () {
-  const r = scanVault(OBS);
-  for (const f of r.files) {
-    assert.ok(!f.source_path.includes('.obsidian'), 'should not include .obsidian paths: ' + f.source_path);
-  }
-  // skipped[] should have recorded .obsidian
-  const skippedJoined = r.skipped.join('|');
-  assert.ok(skippedJoined.includes('.obsidian'), 'expected .obsidian in skipped list, got: ' + skippedJoined);
-});
-
-test('scanVault extracts [[wikilinks]] from body into source_wikilinks', function () {
-  const r = scanVault(OBS);
-  const withLinks = r.files.find(function (f) { return f.source_path.indexOf('with-wikilinks') !== -1; });
-  assert.ok(withLinks, 'expected with-wikilinks.md in results');
-  assert.ok(withLinks.source_wikilinks.indexOf('dror-cohen') !== -1, 'expected dror-cohen wikilink');
-  assert.ok(withLinks.source_wikilinks.indexOf('activation-funnel') !== -1, 'expected activation-funnel wikilink');
-});
-
-test('scanVault throws on missing path', function () {
-  assert.throws(function () { scanVault('/nonexistent/path/xyz-123'); }, /source path not found/);
-});
-
-process.stdout.write('\n' + passed + ' passed, ' + failed + ' failed\n');
-if (failed > 0) process.exit(1);
-process.stdout.write('PASS\n');