@jaimevalasek/aioson 1.20.0 → 1.21.3

package/src/commands/memory-reflect-commit.js

@@ -1,6 +1,6 @@
 'use strict';
 
-// aioson memory:reflect-commit [.] --agent=<name> [--output=<path-to-json>] [--json]
+// aioson memory:reflect-commit [.] --agent=<name> [--output=<path-to-json>] [--json] [--dry-run]
 //
 // Reads the reflect manifest written by memory:reflect-prepare, accepts the
 // agent's reflected output (as a JSON map of relative path → new content),
@@ -63,13 +63,14 @@ async function emitEvent(targetDir, agent, type, message, payload) {
 async function runMemoryReflectCommit({ args, options = {}, logger }) {
   const targetDir = path.resolve(process.cwd(), args?.[0] || '.');
   const agent = String(options.agent || '').trim() || 'unknown';
+  const dryRun = Boolean(options['dry-run'] || options.dryRun);
 
   const manifestPath = path.join(targetDir, REFLECT_PROMPT_RELATIVE);
   let manifest;
   try {
     manifest = await readJsonFile(manifestPath);
   } catch {
-    const message = `manifest not found at ${path.relative(targetDir, manifestPath)} — run memory:reflect-prepare first`;
+    const message = `manifest not found at ${path.relative(targetDir, manifestPath)} — it may have been consumed by a previous successful reflect-commit; run memory:reflect-prepare to generate a new one`;
     if (!options.json) logger.log(`✗ ${message}`);
     return { ok: false, error: 'missing_manifest', message };
   }
@@ -102,9 +103,11 @@ async function runMemoryReflectCommit({ args, options = {}, logger }) {
   // verify that every resolved absolute path stays under the project's
   // bootstrap directory. validate() already rejects absolute paths and
   // `..` segments, but this is the second wall in case the manifest's
-  // allowed_paths is ever extended beyond bootstrap/.
+  // allowed_paths is ever extended beyond bootstrap/. Run this for BOTH
+  // dry-run and real commits so a dry-run validates exactly what a real
+  // commit would do.
   const bootstrapRoot = path.resolve(targetDir, '.aioson/context/bootstrap');
-  const written = [];
+  const planned = [];
   for (const [relPath, content] of Object.entries(files)) {
     const absPath = path.resolve(targetDir, relPath);
     if (!absPath.startsWith(bootstrapRoot + path.sep) && absPath !== bootstrapRoot) {
@@ -116,6 +119,27 @@ async function runMemoryReflectCommit({ args, options = {}, logger }) {
       });
       return { ok: false, error: 'path_escape', message: msg };
     }
+    planned.push({ relPath, absPath, content });
+  }
+
+  // --dry-run: validation + path containment already passed. Report what WOULD
+  // be written and stop — no disk writes, and crucially the manifest is NOT
+  // consumed, so a real commit can still follow. A dry-run must never mutate
+  // state (this is the bug fix: previously --dry-run was ignored and ran the
+  // full destructive commit).
+  if (dryRun) {
+    const wouldWrite = planned.map((p) => p.relPath);
+    if (!options.json) {
+      logger.log('• reflect-commit DRY RUN — no files written, manifest preserved');
+      for (const w of wouldWrite) logger.log(`  - would write: ${w}`);
+    }
+    await emitEvent(targetDir, agent, 'memory_reflect_dry_run',
+      `dry-run validated ${wouldWrite.length} file(s)`, { would_write: wouldWrite });
+    return { ok: true, dryRun: true, would_write: wouldWrite };
+  }
+
+  const written = [];
+  for (const { relPath, absPath, content } of planned) {
     // SF-project-22: scrub zero-width / bidi / HTML-comment injection carriers
     // from the LLM-authored content before it lands in bootstrap. Path
     // containment is already enforced above; this is the content layer of the

package/src/commands/memory-restore.js

@@ -1,177 +1,177 @@
-'use strict';
-
-/**
- * aioson memory:restore --id=<rule|learning|brain>:<slug> [--reason="<text>"] [--dry-run] [--json]
- *
- * Tier-2 human-actioned command. Moves an archived artifact back to its
- * active path and records an `event_type='restored'` entry with a fresh
- * `start_at` (PMD-10). History is preserved: the prior `archived` entry
- * keeps its `end_at`.
- *
- * Refuses to run when `process.env.AIOSON_RUNTIME_HOOK === '1'` (BR-ALL-01).
- * Emits `aioson notify --level=warn` BEFORE mutation (BR-ALL-06).
- */
-
-const path = require('node:path');
-const { openRuntimeDb } = require('../runtime-store');
-const { runNotify } = require('./notify');
-const {
-  parseTargetId,
-  normalizeKind,
-  restoreTarget,
-  TARGET_TYPES
-} = require('../learning-loop-archive');
-
-function tFn(t, key, params) {
-  if (typeof t === 'function') {
-    try { return t(key, params || {}); } catch { /* fall through */ }
-  }
-  return null;
-}
-
-function isHookContext() {
-  return process.env.AIOSON_RUNTIME_HOOK === '1';
-}
-
-async function runMemoryRestore({ args, options = {}, logger, t }) {
-  const targetDir = path.resolve(process.cwd(), args && args[0] ? args[0] : '.');
-  const wantJson = Boolean(options.json);
-  const dryRun = Boolean(options['dry-run'] || options.dryRun);
-  const log = (msg) => { if (logger && typeof logger.log === 'function') logger.log(msg); };
-
-  if (isHookContext()) {
-    const msg = tFn(t, 'memory_restore.hook_blocked')
-      || 'memory:restore cannot be invoked from a runtime hook (BR-ALL-01: tier-2 requires human action).';
-    if (wantJson) return { ok: false, reason: 'hook_blocked' };
-    log(msg);
-    return { ok: false, reason: 'hook_blocked' };
-  }
-
-  const rawId = options.id || options.target || '';
-  const reason = options.reason ? String(options.reason).trim() : '';
-
-  if (!rawId) {
-    const msg = tFn(t, 'memory_restore.id_required')
-      || 'memory:restore requires --id=<rule|learning|brain>:<slug>.';
-    if (wantJson) return { ok: false, reason: 'missing_id' };
-    log(msg);
-    return { ok: false, reason: 'missing_id' };
-  }
-
-  const parsed = parseTargetId(rawId);
-  const kind = normalizeKind(parsed.kind);
-  if (!kind || !TARGET_TYPES.has(kind) || !parsed.slug) {
-    const msg = tFn(t, 'memory_restore.invalid_id', { value: rawId })
-      || `memory:restore invalid --id value: "${rawId}". Expected rule|learning|brain:<slug>.`;
-    if (wantJson) return { ok: false, reason: 'invalid_id', value: rawId };
-    log(msg);
-    return { ok: false, reason: 'invalid_id' };
-  }
-
-  const notifyMessage = tFn(t, 'memory_restore.notify_template', {
-    kind,
-    slug: parsed.slug,
-    reason: reason || 'restoring archived artifact'
-  }) || `restoring ${kind} "${parsed.slug}"${reason ? `: ${reason}` : ''}`;
-  let notifyResult;
-  try {
-    notifyResult = await runNotify({
-      args: [targetDir],
-      options: {
-        level: 'warn',
-        topic: 'memory',
-        message: notifyMessage,
-        agent: 'memory-restore',
-        json: wantJson ? true : undefined
-      },
-      logger: logger || { log: () => {} }
-    });
-  } catch (err) {
-    if (wantJson) return { ok: false, reason: 'notify_failed', error: String(err && err.message || err) };
-    log(`memory:restore notify failed: ${err && err.message ? err.message : err}`);
-    return { ok: false, reason: 'notify_failed' };
-  }
-  if (notifyResult && notifyResult.ok === false) {
-    if (wantJson) return { ok: false, reason: 'notify_blocked', exitCode: notifyResult.exitCode };
-    log('memory:restore aborted: tier-2 notify returned non-zero exit code.');
-    return { ok: false, reason: 'notify_blocked' };
-  }
-
-  let dbHandle;
-  try {
-    dbHandle = await openRuntimeDb(targetDir);
-  } catch (err) {
-    if (wantJson) return { ok: false, reason: 'runtime_db_unavailable', error: String(err && err.message || err) };
-    log(`memory:restore runtime db unavailable: ${err && err.message ? err.message : err}`);
-    return { ok: false, reason: 'runtime_db_unavailable' };
-  }
-
-  const { db } = dbHandle;
-  let outcome;
-  try {
-    outcome = restoreTarget(db, {
-      targetDir,
-      kind,
-      slug: parsed.slug,
-      reason: reason || null,
-      actor: 'human',
-      featureSlug: options.feature ? String(options.feature).trim() : null,
-      dryRun
-    });
-  } finally {
-    db.close();
-  }
-
-  if (!outcome.ok) {
-    if (wantJson) return outcome;
-    if (outcome.reason === 'target_not_archived') {
-      const msg = tFn(t, 'memory_restore.target_not_archived', { kind, slug: parsed.slug })
-        || `memory:restore: ${kind} "${parsed.slug}" not found in archive.`;
-      log(msg);
-    } else if (outcome.reason === 'target_already_active') {
-      const msg = tFn(t, 'memory_restore.target_already_active', { kind, slug: parsed.slug })
-        || `memory:restore: ${kind} "${parsed.slug}" already active. No-op.`;
-      log(msg);
-    } else if (outcome.reason === 'target_not_found') {
-      const msg = tFn(t, 'memory_restore.target_not_found', { kind, slug: parsed.slug })
-        || `memory:restore: ${kind} "${parsed.slug}" not found.`;
-      log(msg);
-    } else {
-      log(`memory:restore failed: ${outcome.reason}${outcome.error ? ' — ' + outcome.error : ''}`);
-    }
-    return outcome;
-  }
-
-  if (wantJson) {
-    return {
-      ok: true,
-      dry_run: Boolean(outcome.dryRun),
-      kind,
-      slug: parsed.slug,
-      source_path: outcome.sourcePath,
-      dest_path: outcome.destPath,
-      restored_entry_id: outcome.restoredEntryId || null,
-      start_at: outcome.startAt || null
-    };
-  }
-
-  if (outcome.dryRun) {
-    const msg = tFn(t, 'memory_restore.dry_run_summary', {
-      kind,
-      slug: parsed.slug,
-      source: outcome.sourcePath || kind,
-      dest: outcome.destPath || '(no dest)'
-    }) || `memory:restore [dry-run]: would move ${outcome.sourcePath || kind} → ${outcome.destPath || '(no dest)'}.`;
-    log(msg);
-  } else {
-    const msg = tFn(t, 'memory_restore.restored_success', {
-      kind,
-      slug: parsed.slug,
-      dest: outcome.destPath || ''
-    }) || `memory:restore ✓ ${kind} "${parsed.slug}" restored${outcome.destPath ? ' to ' + outcome.destPath : ''}.`;
-    log(msg);
-  }
-  return outcome;
-}
-
-module.exports = { runMemoryRestore };
+'use strict';
+
+/**
+ * aioson memory:restore --id=<rule|learning|brain>:<slug> [--reason="<text>"] [--dry-run] [--json]
+ *
+ * Tier-2 human-actioned command. Moves an archived artifact back to its
+ * active path and records an `event_type='restored'` entry with a fresh
+ * `start_at` (PMD-10). History is preserved: the prior `archived` entry
+ * keeps its `end_at`.
+ *
+ * Refuses to run when `process.env.AIOSON_RUNTIME_HOOK === '1'` (BR-ALL-01).
+ * Emits `aioson notify --level=warn` BEFORE mutation (BR-ALL-06).
+ */
+
+const path = require('node:path');
+const { openRuntimeDb } = require('../runtime-store');
+const { runNotify } = require('./notify');
+const {
+  parseTargetId,
+  normalizeKind,
+  restoreTarget,
+  TARGET_TYPES
+} = require('../learning-loop-archive');
+
+function tFn(t, key, params) {
+  if (typeof t === 'function') {
+    try { return t(key, params || {}); } catch { /* fall through */ }
+  }
+  return null;
+}
+
+function isHookContext() {
+  return process.env.AIOSON_RUNTIME_HOOK === '1';
+}
+
+async function runMemoryRestore({ args, options = {}, logger, t }) {
+  const targetDir = path.resolve(process.cwd(), args && args[0] ? args[0] : '.');
+  const wantJson = Boolean(options.json);
+  const dryRun = Boolean(options['dry-run'] || options.dryRun);
+  const log = (msg) => { if (logger && typeof logger.log === 'function') logger.log(msg); };
+
+  if (isHookContext()) {
+    const msg = tFn(t, 'cli.memory_restore.hook_blocked')
+      || 'memory:restore cannot be invoked from a runtime hook (BR-ALL-01: tier-2 requires human action).';
+    if (wantJson) return { ok: false, reason: 'hook_blocked' };
+    log(msg);
+    return { ok: false, reason: 'hook_blocked' };
+  }
+
+  const rawId = options.id || options.target || '';
+  const reason = options.reason ? String(options.reason).trim() : '';
+
+  if (!rawId) {
+    const msg = tFn(t, 'cli.memory_restore.id_required')
+      || 'memory:restore requires --id=<rule|learning|brain>:<slug>.';
+    if (wantJson) return { ok: false, reason: 'missing_id' };
+    log(msg);
+    return { ok: false, reason: 'missing_id' };
+  }
+
+  const parsed = parseTargetId(rawId);
+  const kind = normalizeKind(parsed.kind);
+  if (!kind || !TARGET_TYPES.has(kind) || !parsed.slug) {
+    const msg = tFn(t, 'cli.memory_restore.invalid_id', { value: rawId })
+      || `memory:restore invalid --id value: "${rawId}". Expected rule|learning|brain:<slug>.`;
+    if (wantJson) return { ok: false, reason: 'invalid_id', value: rawId };
+    log(msg);
+    return { ok: false, reason: 'invalid_id' };
+  }
+
+  const notifyMessage = tFn(t, 'cli.memory_restore.notify_template', {
+    kind,
+    slug: parsed.slug,
+    reason: reason || 'restoring archived artifact'
+  }) || `restoring ${kind} "${parsed.slug}"${reason ? `: ${reason}` : ''}`;
+  let notifyResult;
+  try {
+    notifyResult = await runNotify({
+      args: [targetDir],
+      options: {
+        level: 'warn',
+        topic: 'memory',
+        message: notifyMessage,
+        agent: 'memory-restore',
+        json: wantJson ? true : undefined
+      },
+      logger: logger || { log: () => {} }
+    });
+  } catch (err) {
+    if (wantJson) return { ok: false, reason: 'notify_failed', error: String(err && err.message || err) };
+    log(`memory:restore notify failed: ${err && err.message ? err.message : err}`);
+    return { ok: false, reason: 'notify_failed' };
+  }
+  if (notifyResult && notifyResult.ok === false) {
+    if (wantJson) return { ok: false, reason: 'notify_blocked', exitCode: notifyResult.exitCode };
+    log('memory:restore aborted: tier-2 notify returned non-zero exit code.');
+    return { ok: false, reason: 'notify_blocked' };
+  }
+
+  let dbHandle;
+  try {
+    dbHandle = await openRuntimeDb(targetDir);
+  } catch (err) {
+    if (wantJson) return { ok: false, reason: 'runtime_db_unavailable', error: String(err && err.message || err) };
+    log(`memory:restore runtime db unavailable: ${err && err.message ? err.message : err}`);
+    return { ok: false, reason: 'runtime_db_unavailable' };
+  }
+
+  const { db } = dbHandle;
+  let outcome;
+  try {
+    outcome = restoreTarget(db, {
+      targetDir,
+      kind,
+      slug: parsed.slug,
+      reason: reason || null,
+      actor: 'human',
+      featureSlug: options.feature ? String(options.feature).trim() : null,
+      dryRun
+    });
+  } finally {
+    db.close();
+  }
+
+  if (!outcome.ok) {
+    if (wantJson) return outcome;
+    if (outcome.reason === 'target_not_archived') {
+      const msg = tFn(t, 'cli.memory_restore.target_not_archived', { kind, slug: parsed.slug })
+        || `memory:restore: ${kind} "${parsed.slug}" not found in archive.`;
+      log(msg);
+    } else if (outcome.reason === 'target_already_active') {
+      const msg = tFn(t, 'cli.memory_restore.target_already_active', { kind, slug: parsed.slug })
+        || `memory:restore: ${kind} "${parsed.slug}" already active. No-op.`;
+      log(msg);
+    } else if (outcome.reason === 'target_not_found') {
+      const msg = tFn(t, 'cli.memory_restore.target_not_found', { kind, slug: parsed.slug })
+        || `memory:restore: ${kind} "${parsed.slug}" not found.`;
+      log(msg);
+    } else {
+      log(`memory:restore failed: ${outcome.reason}${outcome.error ? ' — ' + outcome.error : ''}`);
+    }
+    return outcome;
+  }
+
+  if (wantJson) {
+    return {
+      ok: true,
+      dry_run: Boolean(outcome.dryRun),
+      kind,
+      slug: parsed.slug,
+      source_path: outcome.sourcePath,
+      dest_path: outcome.destPath,
+      restored_entry_id: outcome.restoredEntryId || null,
+      start_at: outcome.startAt || null
+    };
+  }
+
+  if (outcome.dryRun) {
+    const msg = tFn(t, 'cli.memory_restore.dry_run_summary', {
+      kind,
+      slug: parsed.slug,
+      source: outcome.sourcePath || kind,
+      dest: outcome.destPath || '(no dest)'
+    }) || `memory:restore [dry-run]: would move ${outcome.sourcePath || kind} → ${outcome.destPath || '(no dest)'}.`;
+    log(msg);
+  } else {
+    const msg = tFn(t, 'cli.memory_restore.restored_success', {
+      kind,
+      slug: parsed.slug,
+      dest: outcome.destPath || ''
+    }) || `memory:restore ✓ ${kind} "${parsed.slug}" restored${outcome.destPath ? ' to ' + outcome.destPath : ''}.`;
+    log(msg);
+  }
+  return outcome;
+}
+
+module.exports = { runMemoryRestore };