echoctl 0.1.0

package/scripts/lib/usecases/migrate-legacy-buffer.js

@@ -0,0 +1,209 @@
+const fs = require("fs");
+const os = require("os");
+const path = require("path");
+const { resolveEchoHomePath, ensureDir } = require("../infra/workspace");
+const { findProjectById, registerProject } = require("./project-registry");
+
+function defaultLegacyBufferDir(echoHome) {
+  return path.join(echoHome, "session-buffer");
+}
+
+function listMarkdownFiles(dir) {
+  try {
+    return fs.readdirSync(dir)
+      .filter((name) => name.endsWith(".md"))
+      .sort();
+  } catch (err) {
+    if (err.code === "ENOENT") return [];
+    throw err;
+  }
+}
+
+function readSessionMap(mapPath) {
+  const rows = [];
+  try {
+    const raw = fs.readFileSync(mapPath, "utf-8");
+    for (const line of raw.split(/\r?\n/)) {
+      if (!line.trim()) continue;
+      const idx = line.indexOf("=");
+      if (idx === -1) continue;
+      rows.push({ sessionId: line.slice(0, idx), filePath: line.slice(idx + 1) });
+    }
+  } catch (err) {
+    if (err.code !== "ENOENT") throw err;
+  }
+  return rows;
+}
+
+function writeSessionMap(mapPath, rows) {
+  const body = rows.map((row) => `${row.sessionId}=${row.filePath}`).join("\n");
+  fs.writeFileSync(mapPath, body ? body + "\n" : "");
+}
+
+function appendFileIfExists(source, dest, apply) {
+  if (!fs.existsSync(source)) return false;
+  if (!apply) return true;
+  ensureDir(path.dirname(dest));
+  fs.appendFileSync(dest, fs.readFileSync(source, "utf-8"));
+  return true;
+}
+
+function copyPendingFiles(sourcePendingDir, targetPendingDir, apply, overwrite) {
+  let names;
+  try {
+    names = fs.readdirSync(sourcePendingDir).filter((name) => name.endsWith(".json")).sort();
+  } catch (err) {
+    if (err.code === "ENOENT") return [];
+    throw err;
+  }
+
+  const pending = [];
+  for (const name of names) {
+    const source = path.join(sourcePendingDir, name);
+    const dest = path.join(targetPendingDir, name);
+    const exists = fs.existsSync(dest);
+    const status = exists && !overwrite ? "skipped_existing" : exists ? "overwrite" : "copy";
+    pending.push({ name, source, dest, status });
+    if (apply && status !== "skipped_existing") {
+      ensureDir(targetPendingDir);
+      fs.copyFileSync(source, dest);
+    }
+  }
+  return pending;
+}
+
+function resolveTargetProject(opts) {
+  if (opts.projectId) {
+    const project = findProjectById(opts.projectId, { echoHome: opts.echoHome });
+    if (!project) throw new Error(`Project "${opts.projectId}" not found. Run echoctl project list or use --path <dir>.`);
+    return project;
+  }
+  if (opts.projectPath) {
+    const result = registerProject(opts.projectPath, { echoHome: opts.echoHome });
+    return {
+      projectId: result.projectId,
+      projectRoot: result.projectRoot,
+      dataRoot: result.dataRoot,
+      registered: result.created,
+    };
+  }
+  throw new Error("Target project required: use --project <id> or --path <dir>.");
+}
+
+function migrateLegacyBuffer(opts = {}) {
+  const echoHome = opts.echoHome || resolveEchoHomePath(opts);
+  const apply = opts.apply === true;
+  const overwrite = opts.overwrite === true;
+  const move = opts.move === true;
+  const sourceDir = path.resolve(opts.from || defaultLegacyBufferDir(echoHome));
+  const project = resolveTargetProject({ ...opts, echoHome });
+  const targetDir = path.join(project.dataRoot, "session-buffer");
+
+  if (path.resolve(sourceDir) === path.resolve(targetDir)) {
+    throw new Error("Source legacy buffer and target project buffer are the same directory.");
+  }
+
+  const markdownNames = listMarkdownFiles(sourceDir);
+  const filterNames = opts.filterFileNames || null;
+  const filteredNames = filterNames
+    ? markdownNames.filter((n) => filterNames.includes(n))
+    : markdownNames;
+  const files = [];
+  const copiedNames = new Set();
+
+  for (const name of filteredNames) {
+    const source = path.join(sourceDir, name);
+    const dest = path.join(targetDir, name);
+    const exists = fs.existsSync(dest);
+    const status = exists && !overwrite ? "skipped_existing" : exists ? "overwrite" : "copy";
+    files.push({ name, source, dest, status });
+    if (status !== "skipped_existing") copiedNames.add(name);
+    if (apply && status !== "skipped_existing") {
+      ensureDir(targetDir);
+      fs.copyFileSync(source, dest);
+      if (move) fs.unlinkSync(source);
+    }
+  }
+
+  const sourceMapPath = path.join(sourceDir, "session-map.txt");
+  const targetMapPath = path.join(targetDir, "session-map.txt");
+  const sourceMapRows = readSessionMap(sourceMapPath);
+  const targetMapRows = readSessionMap(targetMapPath);
+  const targetBySession = new Map(targetMapRows.map((row) => [row.sessionId, row.filePath]));
+  const mapUpdates = [];
+  const mapConflicts = [];
+
+  for (const row of sourceMapRows) {
+    const name = path.basename(row.filePath);
+    if (!copiedNames.has(name)) continue;
+    const nextPath = path.join(targetDir, name);
+    const existing = targetBySession.get(row.sessionId);
+    if (existing && path.resolve(existing) !== path.resolve(nextPath) && !overwrite) {
+      mapConflicts.push({ sessionId: row.sessionId, existing, next: nextPath });
+      continue;
+    }
+    targetBySession.set(row.sessionId, nextPath);
+    mapUpdates.push({ sessionId: row.sessionId, filePath: nextPath });
+  }
+
+  if (apply && mapUpdates.length > 0) {
+    const merged = [...targetBySession.entries()]
+      .sort(([a], [b]) => a.localeCompare(b))
+      .map(([sessionId, filePath]) => ({ sessionId, filePath }));
+    ensureDir(targetDir);
+    writeSessionMap(targetMapPath, merged);
+  }
+
+  const pending = copyPendingFiles(
+    path.join(sourceDir, "pending"),
+    path.join(targetDir, "pending"),
+    apply,
+    overwrite
+  );
+
+  const failuresCopied = appendFileIfExists(
+    path.join(sourceDir, "failures.jsonl"),
+    path.join(targetDir, "failures.jsonl"),
+    apply
+  );
+
+  const auqCopied = fs.existsSync(path.join(sourceDir, "auq-counter.txt"));
+  if (apply && auqCopied) {
+    const sourceAuq = path.join(sourceDir, "auq-counter.txt");
+    const targetAuq = path.join(targetDir, "auq-counter.txt");
+    if (overwrite || !fs.existsSync(targetAuq)) {
+      ensureDir(targetDir);
+      fs.copyFileSync(sourceAuq, targetAuq);
+    }
+  }
+
+  return {
+    applied: apply,
+    moved: apply && move,
+    sourceDir,
+    targetDir,
+    projectId: project.projectId,
+    projectRoot: project.projectRoot,
+    registered: project.registered === true,
+    files,
+    mapUpdates,
+    mapConflicts,
+    pending,
+    failuresCopied,
+    auqCopied,
+    summary: {
+      copy: files.filter((f) => f.status === "copy").length,
+      overwrite: files.filter((f) => f.status === "overwrite").length,
+      skippedExisting: files.filter((f) => f.status === "skipped_existing").length,
+      mapUpdates: mapUpdates.length,
+      mapConflicts: mapConflicts.length,
+      pending: pending.length,
+    },
+  };
+}
+
+module.exports = {
+  migrateLegacyBuffer,
+  defaultLegacyBufferDir,
+  readSessionMap,
+};

package/scripts/lib/usecases/project-registry.js

@@ -0,0 +1,170 @@
+const path = require("path");
+const fs = require("fs");
+const {
+  resolveEchoHomePath,
+  projectIdFromPath,
+  resolveProjectDataRoot,
+} = require("../infra/workspace");
+
+const PROJECT_DATA_DIRS = ["session-buffer", "articles", "comments", "index"];
+
+/**
+ * @param {string} echoHome
+ * @returns {{ projects: Record<string, { root: string, registeredAt: string }> }}
+ */
+function loadRegistry(echoHome) {
+  const registryPath = path.join(echoHome, "registry.json");
+  let raw;
+  try {
+    raw = fs.readFileSync(registryPath, "utf-8");
+  } catch (_) {
+    return { projects: {} };
+  }
+  try {
+    return JSON.parse(raw);
+  } catch (_) {
+    const backup = registryPath + ".corrupt-" + Date.now();
+    fs.renameSync(registryPath, backup);
+    throw new Error(
+      `registry.json is corrupt — backed up to ${backup}. Restore manually or re-register projects.`
+    );
+  }
+}
+
+/**
+ * @param {string} echoHome
+ * @param {{ projects: Record<string, { root: string, registeredAt: string }> }} registry
+ */
+function saveRegistry(echoHome, registry) {
+  const registryPath = path.join(echoHome, "registry.json");
+  if (!fs.existsSync(echoHome)) {
+    fs.mkdirSync(echoHome, { recursive: true });
+  }
+  const tmp = registryPath + ".tmp-" + Date.now();
+  fs.writeFileSync(tmp, JSON.stringify(registry, null, 2) + "\n");
+  fs.renameSync(tmp, registryPath);
+}
+
+/**
+ * @param {string} projectPath
+ * @param {{ echoHome?: string, projectId?: string }} [opts]
+ */
+function registerProject(projectPath, opts = {}) {
+  const echoHome = opts.echoHome || resolveEchoHomePath(opts);
+  const absolutePath = path.resolve(projectPath);
+  const projectId = opts.projectId || projectIdFromPath(projectPath);
+  const registry = loadRegistry(echoHome);
+
+  const existing = registry.projects[projectId];
+  if (existing) {
+    if (path.resolve(existing.root) !== absolutePath) {
+      throw new Error(
+        `Project "${projectId}" is already registered at ${existing.root} — ` +
+        `cannot register a different path ${absolutePath} under the same id. ` +
+        `Use a unique directory name or unregister the existing one first.`
+      );
+    }
+    return {
+      projectId,
+      projectRoot: existing.root,
+      dataRoot: resolveProjectDataRoot(projectPath, { echoHome, projectId }),
+      created: false,
+      dirsCreated: [],
+      dirsSkipped: [],
+    };
+  }
+
+  registry.projects[projectId] = {
+    root: absolutePath,
+    registeredAt: new Date().toISOString(),
+  };
+  saveRegistry(echoHome, registry);
+
+  const dataRoot = resolveProjectDataRoot(projectPath, { echoHome, projectId });
+  const dirsCreated = [];
+  const dirsSkipped = [];
+  for (const d of PROJECT_DATA_DIRS) {
+    const full = path.join(dataRoot, d);
+    if (!fs.existsSync(full)) {
+      fs.mkdirSync(full, { recursive: true });
+      dirsCreated.push(d);
+    } else {
+      dirsSkipped.push(d);
+    }
+  }
+
+  return {
+    projectId,
+    projectRoot: absolutePath,
+    dataRoot,
+    created: true,
+    dirsCreated,
+    dirsSkipped,
+  };
+}
+
+/**
+ * @param {string} searchPath
+ * @param {{ echoHome?: string }} [opts]
+ */
+function findProjectForPath(searchPath, opts = {}) {
+  const echoHome = opts.echoHome || resolveEchoHomePath(opts);
+  const registry = loadRegistry(echoHome);
+  const resolved = path.resolve(searchPath);
+
+  const entries = Object.entries(registry.projects)
+    .map(([id, entry]) => ({ id, root: path.resolve(entry.root) }))
+    .sort((a, b) => b.root.length - a.root.length);
+
+  for (const { id, root } of entries) {
+    if (resolved === root || resolved.startsWith(root + path.sep)) {
+      return {
+        projectId: id,
+        projectRoot: root,
+        dataRoot: resolveProjectDataRoot(root, { echoHome, projectId: id }),
+      };
+    }
+  }
+
+  return null;
+}
+
+/**
+ * @param {string} echoHome
+ * @returns {Array<{ projectId: string, root: string, dataRoot: string, registeredAt: string }>}
+ */
+function listProjects(echoHome) {
+  const home = echoHome || resolveEchoHomePath();
+  const registry = loadRegistry(home);
+  return Object.entries(registry.projects).map(([projectId, entry]) => ({
+    projectId,
+    root: entry.root,
+    dataRoot: resolveProjectDataRoot(entry.root, { echoHome: home, projectId }),
+    registeredAt: entry.registeredAt,
+  }));
+}
+
+/**
+ * @param {string} projectId
+ * @param {{ echoHome?: string }} [opts]
+ */
+function findProjectById(projectId, opts = {}) {
+  const echoHome = opts.echoHome || resolveEchoHomePath(opts);
+  const registry = loadRegistry(echoHome);
+  const entry = registry.projects[projectId];
+  if (!entry) return null;
+  return {
+    projectId,
+    projectRoot: entry.root,
+    dataRoot: resolveProjectDataRoot(entry.root, { echoHome, projectId }),
+  };
+}
+
+module.exports = {
+  loadRegistry,
+  saveRegistry,
+  registerProject,
+  findProjectForPath,
+  findProjectById,
+  listProjects,
+};