create-claude-cabinet 0.27.0 → 0.27.1

package/lib/migrate-from-omega.js

@@ -549,6 +549,111 @@ function buildEdgesJson(edges) {
   );
 }
 
+// ---------------------------------------------------------------------------
+// Merge mode — additive, never clobbers native memory
+// ---------------------------------------------------------------------------
+
+const OMEGA_SUBDIR = 'omega-migrated';
+
+/**
+ * Build the MEMORY.md section that indexes omega topic files living under
+ * the omega-migrated/ subdir. Carries the preamble marker so a re-run
+ * detects already-migrated. Paths are prefixed with the subdir.
+ */
+function buildMergeSection(topicFileMeta, summary) {
+  const lines = [
+    PREAMBLE_MARKER,
+    '',
+    `## Migrated from omega (${new Date().toISOString().slice(0, 10)})`,
+    '',
+    `_${summary.migrated} memories migrated from omega into \`${OMEGA_SUBDIR}/\`. ` +
+      `Native memory files above are unchanged. ${summary.edges} edges in ${OMEGA_SUBDIR}/edges.json._`,
+    '',
+  ];
+  for (const { topic, file, count } of topicFileMeta) {
+    const desc = describeTopic(topic);
+    lines.push(`- [${topic}](${OMEGA_SUBDIR}/${file}) (${count}) — ${desc}`);
+  }
+  return lines.join('\n') + '\n';
+}
+
+/**
+ * Additive merge: write omega topic files into an omega-migrated/ subdir
+ * (zero filename collision with native files), back up the existing dir
+ * first, and append/create a MEMORY.md section indexing them. Never
+ * overwrites a native file.
+ *
+ * @returns {{ backupDir, omegaDir, indexedInto }}
+ */
+function mergeIntoExisting(outputDir, topicFiles, edgesJson, mergeSection, opts = {}) {
+  const omegaDir = path.join(outputDir, OMEGA_SUBDIR);
+  const memoryMdPath = path.join(outputDir, 'MEMORY.md');
+
+  // GUARD: never clobber whatever already occupies the subdir path. If it
+  // exists, it is either a native item the user named `omega-migrated/`, or
+  // residue from an interrupted prior merge. We cannot safely tell them
+  // apart, and the cost of guessing wrong is permanent loss of native data.
+  // Refuse and instruct — the caller surfaces this as a failure with the
+  // native dir fully intact (nothing has been written yet at this point).
+  if (fs.existsSync(omegaDir)) {
+    throw new Error(
+      `Refusing to merge: '${OMEGA_SUBDIR}/' already exists at ${omegaDir}. ` +
+        `If it is leftover from an interrupted migration, remove it and re-run. ` +
+        `If it is your own data, rename it first, then re-run.`
+    );
+  }
+
+  // 1. Back up the existing memory dir wholesale, to a guaranteed-fresh path,
+  //    BEFORE any destructive step. Never proceed without a backup taken
+  //    this invocation (a stale/reused backup wouldn't reflect pristine
+  //    native state).
+  let backupDir = opts.backupDir;
+  if (!backupDir) {
+    const stamp = new Date().toISOString().slice(0, 19).replace(/[:T]/g, '-');
+    const base = `${outputDir}.pre-omega-merge-${stamp}`;
+    backupDir = base;
+    for (let n = 1; fs.existsSync(backupDir); n++) backupDir = `${base}-${n}`;
+  } else if (fs.existsSync(backupDir)) {
+    throw new Error(`Refusing to merge: backup path ${backupDir} already exists.`);
+  }
+  fs.cpSync(outputDir, backupDir, { recursive: true });
+
+  // 2. Write omega topic files + edges into the subdir (atomic via staging
+  //    rename of the subdir). omegaDir is known absent from the guard above.
+  const stagingDir = path.join(outputDir, `.${OMEGA_SUBDIR}-staging-${process.pid}`);
+  fs.rmSync(stagingDir, { recursive: true, force: true });
+  fs.mkdirSync(stagingDir, { recursive: true });
+  for (const [name, content] of Object.entries(topicFiles)) {
+    fs.writeFileSync(path.join(stagingDir, name), content, 'utf8');
+  }
+  if (edgesJson) fs.writeFileSync(path.join(stagingDir, 'edges.json'), edgesJson, 'utf8');
+  fs.renameSync(stagingDir, omegaDir);
+
+  // 3. Append/create MEMORY.md with the omega section (preamble marker
+  //    included so re-runs detect already-migrated). Idempotent: if the
+  //    marker is somehow already present, do not append a second section.
+  let indexedInto;
+  if (fs.existsSync(memoryMdPath)) {
+    const existing = fs.readFileSync(memoryMdPath, 'utf8');
+    if (existing.includes(PREAMBLE_MARKER)) {
+      indexedInto = 'already-indexed';
+    } else {
+      const sep = existing.endsWith('\n') ? '\n' : '\n\n';
+      const merged = existing + sep + mergeSection;
+      const tmp = memoryMdPath + '.tmp-' + process.pid;
+      fs.writeFileSync(tmp, merged, 'utf8');
+      fs.renameSync(tmp, memoryMdPath);
+      indexedInto = 'appended-to-existing';
+    }
+  } else {
+    const header = `# Memory Index\n\n_Native memory files in this directory predate the index; Claude reads them on demand._\n\n`;
+    fs.writeFileSync(memoryMdPath, header + mergeSection, 'utf8');
+    indexedInto = 'created-new';
+  }
+
+  return { backupDir, omegaDir, indexedInto };
+}
+
 // ---------------------------------------------------------------------------
 // Main orchestrator
 // ---------------------------------------------------------------------------
@@ -564,19 +669,17 @@ async function migrateFromOmega(opts = {}) {
   const currentProject = opts.currentProject || resolveCurrentProject(cwd, homeDir);
   const outputDir = resolveOutputDir({ ...opts, cwd, homeDir });
 
+  // Determine write mode. Foreign content (native memory present, no
+  // migration preamble) triggers MERGE — additive, never clobbers — so
+  // omega memories land alongside native memory instead of being skipped.
+  let mode = 'fresh';
   if (!opts.force) {
     const existing = checkExistingMigration(outputDir);
     if (existing.state === 'migrated') {
       return { migrated: 0, reason: 'already-migrated', outputDir };
     }
     if (existing.state === 'foreign-content' || existing.state === 'partial-or-foreign') {
-      return {
-        migrated: 0,
-        reason: existing.state,
-        outputDir,
-        details: existing.files || ['MEMORY.md without migration preamble'],
-        hint: 'Inspect outputDir. If safe to overwrite, re-run with { force: true }.',
-      };
+      mode = 'merge';
     }
   }
 
@@ -587,6 +690,10 @@ async function migrateFromOmega(opts = {}) {
     const { memories, edges } = readVault(vaultDir);
 
     if (memories.length === 0) {
+      // Nothing to migrate. In merge mode, leave native memory untouched.
+      if (mode === 'merge') {
+        return { migrated: 0, reason: 'empty-db', outputDir, mode: 'merge', noop: true };
+      }
       const minimalIndex = `${PREAMBLE_MARKER}\n# Memory Index\n\n_Source: migrated from omega on ${new Date()
         .toISOString()
         .slice(0, 10)}. No prior memories migrated — omega database was empty._\n`;
@@ -636,11 +743,7 @@ async function migrateFromOmega(opts = {}) {
     }
 
     const memoryMd = buildMemoryMd(topicFileMeta, summary);
-    filesToWrite['MEMORY.md'] = memoryMd;
-
-    if (edges.length > 0) {
-      filesToWrite['edges.json'] = buildEdgesJson(edges);
-    }
+    const edgesJson = edges.length > 0 ? buildEdgesJson(edges) : null;
 
     if (opts.dryRun) {
       return {
@@ -648,13 +751,39 @@ async function migrateFromOmega(opts = {}) {
         edges: edges.length,
         outputDir,
         dryRun: true,
+        mode,
         topicFiles: topicFileMeta,
-        memoryMdPreview: memoryMd,
+        memoryMdPreview: mode === 'merge' ? buildMergeSection(topicFileMeta, summary) : memoryMd,
         omegaBin,
         currentProject,
       };
     }
 
+    if (mode === 'merge') {
+      const mergeSection = buildMergeSection(topicFileMeta, summary);
+      const { backupDir, omegaDir, indexedInto } = mergeIntoExisting(
+        outputDir,
+        filesToWrite,
+        edgesJson,
+        mergeSection,
+        opts
+      );
+      return {
+        migrated: memories.length,
+        edges: edges.length,
+        outputDir,
+        mode: 'merge',
+        backupDir,
+        omegaDir,
+        indexedInto,
+        topicFiles: topicFileMeta,
+        currentProject,
+      };
+    }
+
+    // Fresh write (empty dir, or force clobber).
+    filesToWrite['MEMORY.md'] = memoryMd;
+    if (edgesJson) filesToWrite['edges.json'] = edgesJson;
     const stagingDir = path.join(path.dirname(outputDir), STAGING_PREFIX + process.pid);
     writeStaging(stagingDir, filesToWrite);
     commitStaging(stagingDir, outputDir, { force: opts.force });
@@ -663,6 +792,7 @@ async function migrateFromOmega(opts = {}) {
       migrated: memories.length,
       edges: edges.length,
       outputDir,
+      mode: 'fresh',
       topicFiles: topicFileMeta,
       currentProject,
     };

package/lib/migrate-memory-cmd.js

@@ -221,15 +221,20 @@ async function stepMigrateMemories(ctx) {
   if (result.reason === 'already-migrated') {
     return { action: `memories already migrated; reusing existing output at ${result.outputDir}` };
   }
-  if (result.reason === 'foreign-content' || result.reason === 'partial-or-foreign') {
-    return {
-      action: `migrate-from-omega refused: ${result.reason} at ${result.outputDir}. ` +
-        `Hint: ${result.hint || 'inspect manually'}. Continuing — omega cleanup steps will still run.`,
-    };
-  }
   if (result.reason === 'empty-db') {
+    if (result.mode === 'merge') {
+      return { action: `omega DB was empty; native memory at ${result.outputDir} left untouched` };
+    }
     return { action: `omega DB was empty; minimal MEMORY.md written at ${result.outputDir}` };
   }
+  if (result.mode === 'merge') {
+    return {
+      action:
+        `merged ${result.migrated} omega memories (${result.edges || 0} edges) into existing native ` +
+        `memory at ${result.outputDir} (omega content under omega-migrated/; backup at ${result.backupDir}). ` +
+        `Native memories preserved.`,
+    };
+  }
   return {
     action: `migrated ${result.migrated} memories (${result.edges || 0} edges) → ${result.outputDir}`,
   };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "create-claude-cabinet",
-  "version": "0.27.0",
+  "version": "0.27.1",
   "description": "Claude Cabinet — opinionated process scaffolding for Claude Code projects",
   "bin": {
     "create-claude-cabinet": "bin/create-claude-cabinet.js"