echoctl 0.1.0

package/scripts/cli/commands/capture.js

@@ -0,0 +1,20 @@
+const { commandFor } = require("../../lib/cli/names");
+
+function run(args) {
+  const action = args[1];
+  const { isCaptureEnabled, setCaptureEnabled } = require("../../lib/infra/config");
+  if (action === "on") {
+    const r = setCaptureEnabled(true);
+    console.log(`Capture enabled (${r.configPath})`);
+  } else if (action === "off") {
+    const r = setCaptureEnabled(false);
+    console.log(`Capture disabled (${r.configPath})`);
+  } else if (action === "status") {
+    console.log(`Capture: ${isCaptureEnabled() ? "on" : "off"}`);
+  } else {
+    console.error(`Usage: ${commandFor(["capture", "on|off|status"])}`);
+    process.exit(1);
+  }
+}
+
+module.exports = run;

package/scripts/cli/commands/constants.js

@@ -0,0 +1,70 @@
+const { commandFor, cliNames } = require("../../lib/cli/names");
+
+const USAGE = `${cliNames.canonicalName} — Echo knowledge forum CLI
+
+Usage:
+  ${commandFor(["hook", "capture"])}          Read hook JSON from stdin, write to session-buffer
+  ${commandFor(["hook", "status"])}           Generate SessionStart status output
+  ${commandFor(["hook", "install", "<provider>", "[--write]"])}  Print or apply hook config
+  ${commandFor(["hook", "doctor"])}           Check hook health
+  ${commandFor(["init"])}                  Create workspace, write echo.json
+  ${commandFor(["init", "project", "[--path <dir>]"])}  Register project in ~/.echo-workspace/registry.json
+  ${commandFor(["doctor"])}                Check overall workspace health
+  ${commandFor(["migrate", "legacy-buffer", "--project <id>|--path <dir>", "[--apply]"])}  Migrate legacy session-buffer into a project
+  ${commandFor(["all"])}                   Run full pipeline (convert -> validate -> index -> resolve)
+  ${commandFor(["convert"])}               Run buffer -> article conversion
+  ${commandFor(["validate"])}              Validate all articles and comments
+  ${commandFor(["resolve"])}               Resolve all annotation anchors
+  ${commandFor(["search"])}                Full-text search
+  ${commandFor(["mcp"])}                   Start MCP server (stdio transport)
+  ${commandFor(["capture", "on|off|status"])}  Enable, disable, or check capture status
+  ${commandFor(["project", "list"])}    List all registered projects
+  ${commandFor(["project", "find", "<projectId>"])}  Show project details
+  ${commandFor(["tag", "list"])}    List all tags with usage counts
+  ${commandFor(["tag", "add", "<article-id>", "<tag1>", "[tag2...]"])}  Add one or more tags to an article
+  ${commandFor(["tag", "remove", "<article-id>", "<tag1>", "[tag2...]"])}  Remove one or more tags from an article
+  ${commandFor(["tag", "rename", "<old-tag>", "<new-tag>"])}  Rename a tag across all articles
+  ${commandFor(["tag", "purge", "<tag>"])}  Remove a tag from all articles
+  ${commandFor(["import", "claude", "--all", "--dry-run|--apply"])}  Import Claude Code sessions
+  ${commandFor(["import", "claude", "--project", "<dir>", "--as-project", "<id>"])}  Import single project
+  ${commandFor(["serve"])}              Start API + VitePress dev server in background
+  ${commandFor(["serve", "--foreground"])}  Start API + VitePress dev server in foreground
+  ${commandFor(["refresh"])}            Refresh pipeline + docs without restarting serve
+  ${commandFor(["stop"])}               Stop a running serve instance
+  ${commandFor(["status", "[--json]", "[--lang <en|zh-CN>]"])}  Show Echo status overview
+  ${commandFor(["mcp", "--help"])}           Show MCP setup instructions
+`;
+
+const MCP_HELP = `Echo MCP / Echo AI 访问接口
+
+MCP is the bridge that lets AI assistants read and search your Echo archive.
+MCP 是让 AI 助手读取、搜索 Echo 本地归档的桥。
+
+What it provides / 它提供：
+  search_articles    Search Echo articles / 搜索文章
+  get_article        Read one article / 读取文章
+  get_article_context  Read article with comments / 读取文章和评论
+  list_recent        List recent articles / 最近文章
+  list_tags          List tags / 标签列表
+  add_tags           Add tags / 添加标签
+  remove_tags        Remove tags / 移除标签
+  list_projects      List registered projects / 项目列表
+  get_project        Read one project / 读取项目信息
+
+Config / 配置：
+
+{
+  "mcpServers": {
+    "echo": {
+      "command": "${cliNames.canonicalName}",
+      "args": ["mcp"]
+    }
+  }
+}
+
+Verify / 验证：
+  ${cliNames.canonicalName} status        Check Echo status / 查看 Echo 状态
+  ${cliNames.canonicalName} doctor        Diagnose setup / 诊断配置
+`;
+
+module.exports = { USAGE, MCP_HELP };

package/scripts/cli/commands/doctor.js

@@ -0,0 +1,10 @@
+const { printDoctorResults } = require("./helpers");
+
+function run() {
+  const { runDoctor } = require("../../lib/usecases/run-doctor");
+  const results = runDoctor({ hookOnly: false });
+  console.log("Workspace health check:\n");
+  printDoctorResults(results);
+}
+
+module.exports = run;

package/scripts/cli/commands/helpers.js

@@ -0,0 +1,27 @@
+const { spawn } = require("child_process");
+const path = require("path");
+
+function scheduleRefreshIfServeRunning(entryPath) {
+  const { getRunningServeInfo } = require("../../lib/usecases/refresh-serve");
+  if (!getRunningServeInfo()) return false;
+  const child = spawn(process.execPath, [entryPath || path.resolve(__dirname, "../echoctl.js"), "refresh", "--quiet"], {
+    detached: true,
+    stdio: "ignore",
+    env: process.env,
+  });
+  child.unref();
+  return true;
+}
+
+function printDoctorResults(results) {
+  let hasError = false;
+  for (const r of results) {
+    const icon = r.status === "ok" ? "  OK" : r.status === "warn" ? "WARN" : "ERR ";
+    console.log(`  ${icon}  ${r.name}: ${r.message}`);
+    if (r.status === "error") hasError = true;
+  }
+  console.log(`\n${results.length} checks.`);
+  if (hasError) process.exit(1);
+}
+
+module.exports = { scheduleRefreshIfServeRunning, printDoctorResults };

package/scripts/cli/commands/hook.js

@@ -0,0 +1,48 @@
+const { commandFor } = require("../../lib/cli/names");
+const { USAGE } = require("./constants");
+const { printDoctorResults } = require("./helpers");
+
+function run(args) {
+  const sub = args[1];
+  if (sub === "capture") require("../../lib/hooks/capture");
+  else if (sub === "status") require("../../lib/hooks/status");
+  else if (sub === "install") {
+    const provider = args[2];
+    if (!provider || provider.startsWith("-")) {
+      console.error(`Error: provider required. Usage: ${commandFor(["hook", "install", "claude", "[--write]"])}`);
+      process.exit(1);
+    }
+    if (provider !== "claude") {
+      console.error(`Error: unknown provider '${provider}'. Only 'claude' is supported.`);
+      process.exit(1);
+    }
+    const write = args.includes("--write");
+    const { installClaudeHook } = require("../../lib/usecases/install-claude-hook");
+    const result = installClaudeHook({ write });
+    if (result.legacy.length > 0) {
+      console.log("Legacy .sh hooks detected:");
+      for (const l of result.legacy) console.log(`  ${l.event}: ${l.command}`);
+      console.log("");
+    }
+    if (result.toAdd.length > 0) {
+      console.log(write ? "Installed:" : "Will install:");
+      for (const a of result.toAdd) console.log(`  ${a.event}: ${a.command}`);
+    }
+    if (result.alreadyInstalled.length > 0) {
+      console.log("Already installed:");
+      for (const a of result.alreadyInstalled) console.log(`  ${a.event}: ${a.command}`);
+    }
+    if (result.toAdd.length === 0) console.log("All hooks already up to date.");
+    if (!write) console.log("\nRun with --write to apply this configuration.");
+    else console.log("\nHook configuration written to ~/.claude/settings.json");
+  }
+  else if (sub === "doctor") {
+    const { runDoctor } = require("../../lib/usecases/run-doctor");
+    const results = runDoctor({ hookOnly: true });
+    console.log("Hook health check:\n");
+    printDoctorResults(results);
+  }
+  else console.log(USAGE);
+}
+
+module.exports = run;

package/scripts/cli/commands/import_cmd.js

@@ -0,0 +1,184 @@
+const { commandFor } = require("../../lib/cli/names");
+
+function run(args) {
+    const sub = args[1];
+    if (sub !== "claude") {
+      console.error(`Error: unknown provider '${sub || "(none)"}'. Only 'claude' is supported.`);
+      console.error(`Usage: ${commandFor(["import", "claude", "--all", "--dry-run|--apply"])}`);
+      process.exit(1);
+    }
+
+    const all = args.includes("--all");
+    const dryRun = args.includes("--dry-run");
+    const apply = args.includes("--apply");
+    const projectIdx = args.indexOf("--project");
+    const asProjectIdx = args.indexOf("--as-project");
+    const excludeIdx = args.indexOf("--exclude");
+
+    const targetProject = projectIdx !== -1 ? args[projectIdx + 1] : null;
+    const asProject = asProjectIdx !== -1 ? args[asProjectIdx + 1] : null;
+    const excludeDirs = excludeIdx !== -1 ? args[excludeIdx + 1].split(",").map((s) => s.trim()) : [];
+
+    if (!all && !targetProject) {
+      console.error("Error: need --all or --project <dir>");
+      console.error(`Usage: ${commandFor(["import", "claude", "--all", "--dry-run|--apply"])}`);
+      process.exit(1);
+    }
+
+    if (!dryRun && !apply) {
+      console.error("Error: need --dry-run or --apply");
+      process.exit(1);
+    }
+
+    const claudeProjectsDir = path.join(os.homedir(), ".claude", "projects");
+
+    if (!fs.existsSync(claudeProjectsDir)) {
+      console.error(`Error: ${claudeProjectsDir} not found. No Claude Code sessions to import.`);
+      process.exit(1);
+    }
+
+    const { scanClaudeProjects, buildImportPlan } = require("../../lib/import/scanner");
+    const mf = require("../../lib/import/manifest");
+    const provider = require("../../lib/import/providers/claude-code");
+    const { resolveEchoHomePath } = require("../../lib/infra/workspace");
+    const store = require("../../lib/infra/markdown-store");
+
+    const echoHome = resolveEchoHomePath();
+    const manifestPath = path.join(echoHome, "import-manifest.json");
+    const manifest = mf.loadManifest(manifestPath);
+
+    const scanOpts = {};
+    if (excludeDirs.length > 0) scanOpts.excludeDirs = excludeDirs;
+
+    let projects;
+    if (targetProject) {
+      const dirName = path.basename(targetProject);
+      const fullPath = path.join(claudeProjectsDir, dirName);
+      if (!fs.existsSync(fullPath)) {
+        console.error(`Error: project directory not found: ${fullPath}`);
+        process.exit(1);
+      }
+      projects = [{
+        dirName, absPath: fullPath, jsonlFiles: [], sessionCount: 0,
+        decodedPath: targetProject, pathConfidence: "inferred",
+      }];
+      const entries = fs.readdirSync(fullPath).filter((f) => f.endsWith(".jsonl"));
+      projects[0].jsonlFiles = entries.map((f) => ({
+        sessionId: f.replace(/\.jsonl$/, ""),
+        fileName: f,
+        absPath: path.join(fullPath, f),
+      }));
+      projects[0].sessionCount = projects[0].jsonlFiles.length;
+    } else {
+      projects = scanClaudeProjects(claudeProjectsDir, scanOpts);
+    }
+
+    if (projects.length === 0) {
+      console.log("No Claude Code projects found.");
+      process.exit(0);
+    }
+
+    const plan = buildImportPlan(projects, manifest, {});
+
+    console.log("");
+    console.log(`Claude Code projects: ${projects.length}`);
+    console.log(`Sessions found:      ${plan.summary.total}`);
+    console.log(`  New:               ${plan.summary.newCount}`);
+    console.log(`  Updated:           ${plan.summary.updatedCount}`);
+    console.log(`  Skipped (same):    ${plan.summary.skippedCount}`);
+    console.log("");
+
+    if (dryRun) {
+      if (plan.new.length > 0 || plan.updated.length > 0) {
+        console.log("Would import:");
+        for (const entry of plan.new.slice(0, 20)) {
+          console.log(`  [NEW]     ${entry.sessionId}  (${entry.projectDir}, ${entry.turnCount} turns)`);
+        }
+        if (plan.new.length > 20) console.log(`  ... and ${plan.new.length - 20} more`);
+        for (const entry of plan.updated.slice(0, 10)) {
+          console.log(`  [UPDATED] ${entry.sessionId}  (${entry.projectDir})`);
+        }
+        if (plan.updated.length > 10) console.log(`  ... and ${plan.updated.length - 10} more`);
+      }
+      if (plan.skipped.length > 0) {
+        console.log("Would skip (already imported, unchanged):");
+        for (const entry of plan.skipped.slice(0, 5)) {
+          console.log(`  ${entry.sessionId}  ->  ${entry.articleId}`);
+        }
+        if (plan.skipped.length > 5) console.log(`  ... and ${plan.skipped.length - 5} more`);
+      }
+      if (plan.new.length === 0 && plan.updated.length === 0) {
+        console.log("Nothing to import. All sessions already imported and unchanged.");
+      }
+      console.log(`\nRun with --apply to execute.`);
+      process.exit(0);
+    }
+
+    if (apply) {
+      const { resolveDataDirs } = require("../../lib/infra/echo-paths");
+      const dirs = resolveDataDirs();
+      const targetArticlesDir = asProject
+        ? path.join(echoHome, "projects", asProject, "articles")
+        : dirs.articlesDir;
+
+      const opts = {
+        userSpeaker: process.env.ECHO_USER_SPEAKER || "vincent",
+        aiSpeaker: process.env.ECHO_AI_SPEAKER || "ai",
+        project: asProject || dirs.projectId || null,
+      };
+
+      let imported = 0;
+      let skipped = 0;
+
+      const toProcess = [...plan.new, ...plan.updated];
+      for (const entry of toProcess) {
+        const articlePath = path.join(targetArticlesDir, `session-${entry.sessionId.slice(0, 8)}.md`);
+
+        if (fs.existsSync(articlePath)) {
+          console.log(`  SKIP  ${entry.sessionId}  (article exists)`);
+          skipped++;
+          continue;
+        }
+
+        try {
+          const turns = provider.readSessionTurns(entry.filePath);
+          const classification = provider.classifySession(turns);
+          if (!classification.isMeaningful) {
+            console.log(`  SKIP  ${entry.sessionId}  (${classification.reason})`);
+            skipped++;
+            continue;
+          }
+
+          const metadata = provider.extractMetadata(turns);
+          const markdown = provider.toEchoArticle(turns, metadata, {
+            sessionId: entry.sessionId,
+            project: opts.project,
+          });
+
+          fs.mkdirSync(path.dirname(articlePath), { recursive: true });
+          fs.writeFileSync(articlePath, markdown);
+          mf.recordImport(manifest, entry.sessionId, `session-${entry.sessionId.slice(0, 8)}`, entry.fileHash, { provider: "claude-code" });
+
+          console.log(`  OK    ${entry.sessionId}  ->  session-${entry.sessionId.slice(0, 8)}.md  (${classification.estimatedQuality}, ${classification.turnCount} turns)`);
+          imported++;
+        } catch (err) {
+          console.error(`  FAIL  ${entry.sessionId}: ${err.message}`);
+        }
+      }
+
+      mf.saveManifest(manifest, manifestPath);
+
+      console.log(`\nImported: ${imported}  Skipped: ${skipped + plan.skipped.length}`);
+      console.log(`Articles: ${targetArticlesDir}`);
+
+      const { runValidate } = require("../../validate");
+      const result = runValidate();
+      if (result.success) {
+        console.log(`Validate: OK — ${result.articleCount} articles, ${result.commentCount} comments`);
+      } else {
+        console.log(`Validate: ${result.errors.length} error(s) — see above`);
+      }
+    }
+}
+
+module.exports = run;

package/scripts/cli/commands/init.js

@@ -0,0 +1,45 @@
+const { scheduleRefreshIfServeRunning } = require("./helpers");
+
+function run(args) {
+  const sub = args[1];
+  if (sub === "project") {
+    const projectPath = args.includes("--path") ? args[args.indexOf("--path") + 1] : process.cwd();
+    if (!projectPath || projectPath.startsWith("-")) {
+      console.error("Error: --path requires a directory path");
+      process.exit(1);
+    }
+    const { registerProject } = require("../../lib/usecases/project-registry");
+    const result = registerProject(projectPath);
+    console.log(`Project: ${result.projectId}`);
+    console.log(`Root: ${result.projectRoot}`);
+    console.log(`Data: ${result.dataRoot}`);
+    if (result.created) {
+      console.log(`Registered: yes`);
+      if (result.dirsCreated.length > 0) console.log(`Created: ${result.dirsCreated.join(", ")}`);
+      if (result.dirsSkipped.length > 0) console.log(`Skipped (exists): ${result.dirsSkipped.join(", ")}`);
+    } else {
+      console.log(`Registered: no (already exists)`);
+    }
+    try {
+      const { importClaudeProject } = require("../../lib/usecases/import-claude-project");
+      const imported = importClaudeProject(result.projectId);
+      if (imported.total > 0) {
+        console.log(`Claude transcripts: ${imported.total} found, ${imported.imported} imported, ${imported.skipped} skipped`);
+      } else {
+        console.log(`Claude transcripts: none found`);
+      }
+    } catch (err) {
+      console.log(`Claude transcripts: import skipped (${err.message})`);
+    }
+    if (scheduleRefreshIfServeRunning()) console.log(`Serve refresh: scheduled`);
+  } else {
+    const { initWorkspace } = require("../../lib/usecases/init-workspace");
+    const result = initWorkspace();
+    console.log(`Workspace: ${result.workspace}`);
+    if (result.created.length > 0) console.log(`Created: ${result.created.join(", ")}`);
+    if (result.skipped.length > 0) console.log(`Skipped (exists): ${result.skipped.join(", ")}`);
+    console.log(`echo.json: ${result.configAction}`);
+  }
+}
+
+module.exports = run;

package/scripts/cli/commands/mcp.js

@@ -0,0 +1,16 @@
+const { MCP_HELP } = require("./constants");
+
+function run(args) {
+  if (args[1] === "--help") {
+    console.log(MCP_HELP);
+    return;
+  }
+  const { start } = require("../../lib/interfaces/mcp/server");
+  try {
+    start();
+  } catch (err) {
+    process.exit(1);
+  }
+}
+
+module.exports = run;

package/scripts/cli/commands/migrate.js

@@ -0,0 +1,65 @@
+const { commandFor } = require("../../lib/cli/names");
+const { scheduleRefreshIfServeRunning } = require("./helpers");
+
+function run(args) {
+    const sub = args[1];
+    if (sub !== "legacy-buffer") {
+      console.error(`Usage: ${commandFor(["migrate", "legacy-buffer", "--project <id>|--path <dir>", "[--apply]"])}`);
+      process.exit(1);
+    }
+
+    function valueAfter(flag) {
+      const idx = args.indexOf(flag);
+      if (idx === -1) return null;
+      const value = args[idx + 1];
+      return value && !value.startsWith("-") ? value : null;
+    }
+
+    const projectId = valueAfter("--project");
+    const projectPath = valueAfter("--path");
+    const from = valueAfter("--from");
+    const apply = args.includes("--apply");
+    const overwrite = args.includes("--overwrite");
+    const move = args.includes("--move");
+
+    if ((args.includes("--project") && !projectId) || (args.includes("--path") && !projectPath) || (args.includes("--from") && !from)) {
+      console.error("Error: --project, --path, and --from require a value.");
+      process.exit(1);
+    }
+    if (projectId && projectPath) {
+      console.error("Error: use only one target: --project <id> or --path <dir>.");
+      process.exit(1);
+    }
+
+    try {
+      const { migrateLegacyBuffer } = require("../../lib/usecases/migrate-legacy-buffer");
+      const result = migrateLegacyBuffer({ projectId, projectPath, from, apply, overwrite, move });
+      console.log(apply ? "Legacy buffer migration applied." : "Legacy buffer migration preview. Re-run with --apply to write changes.");
+      console.log(`Project: ${result.projectId}`);
+      console.log(`Source:  ${result.sourceDir}`);
+      console.log(`Target:  ${result.targetDir}`);
+      if (result.registered) console.log("Registered: yes");
+      console.log(`Files:   copy ${result.summary.copy}, overwrite ${result.summary.overwrite}, skipped ${result.summary.skippedExisting}`);
+      console.log(`Map:     update ${result.summary.mapUpdates}, conflicts ${result.summary.mapConflicts}`);
+      console.log(`Pending: ${result.summary.pending}`);
+      if (result.failuresCopied) console.log("Failures: append failures.jsonl");
+      if (result.auqCopied) console.log("AUQ:     copy auq-counter.txt when target is empty");
+      if (result.mapConflicts.length > 0) {
+        console.log("\nSession map conflicts:");
+        for (const c of result.mapConflicts) {
+          console.log(`  ${c.sessionId}`);
+          console.log(`    existing: ${c.existing}`);
+          console.log(`    legacy:   ${c.next}`);
+        }
+        console.log("Use --overwrite only if these sessions should point to the migrated legacy files.");
+      }
+      if (apply && scheduleRefreshIfServeRunning()) {
+        console.log(`Serve refresh: scheduled`);
+      }
+    } catch (err) {
+      console.error(`Error: ${err.message}`);
+      process.exit(1);
+    }
+}
+
+module.exports = run;

package/scripts/cli/commands/pipeline.js

@@ -0,0 +1,26 @@
+function run(args) {
+  const { runPipeline } = require("../../lib/usecases/run-pipeline");
+  const cmd = args[0];
+
+  if (cmd === "all") {
+    runPipeline({ allProjects: true, silent: true });
+    console.log("Pipeline complete.");
+  } else if (cmd === "convert") {
+    runPipeline({ allProjects: true, silent: true, steps: ["convert"] });
+  } else if (cmd === "validate") {
+    const { resolveDataDirs } = require("../../lib/infra/echo-paths");
+    const dirs = resolveDataDirs();
+    const { validateWorkspace } = require("../../lib/domain/validation");
+    const results = validateWorkspace(dirs);
+    console.log(`Validation: ${results.errors.length} error(s), ${results.warnings.length} warning(s)`);
+    if (results.errors.length > 0) process.exit(1);
+  } else if (cmd === "resolve") {
+    const { resolveDataDirs } = require("../../lib/infra/echo-paths");
+    const dirs = resolveDataDirs();
+    const { resolveAnchors } = require("../../lib/domain/anchor");
+    resolveAnchors(dirs);
+    console.log("Anchors resolved.");
+  }
+}
+
+module.exports = run;

package/scripts/cli/commands/project.js

@@ -0,0 +1,35 @@
+const { USAGE } = require("./constants");
+
+function run(args) {
+  const sub = args[1];
+  if (sub === "list") {
+    const { listProjects } = require("../../lib/usecases/project-registry");
+    const projects = listProjects();
+    if (projects.length === 0) {
+      console.log("No registered projects.");
+    } else {
+      for (const p of projects) {
+        console.log(`  ${p.projectId.padEnd(20)} ${p.root.padEnd(45)} ${(p.registeredAt || "").slice(0, 10)}`);
+      }
+    }
+  } else if (sub === "find") {
+    const targetId = args[2];
+    if (!targetId || targetId.startsWith("-")) {
+      console.error("Error: project ID required. Usage: echoctl project find <projectId>");
+      process.exit(1);
+    }
+    const { findProjectById } = require("../../lib/usecases/project-registry");
+    const project = findProjectById(targetId);
+    if (!project) {
+      console.error(`Project "${targetId}" not found.`);
+      process.exit(1);
+    }
+    console.log(`Project:  ${project.projectId}`);
+    console.log(`Root:     ${project.projectRoot}`);
+    console.log(`Data:     ${project.dataRoot}`);
+  } else {
+    console.log(USAGE);
+  }
+}
+
+module.exports = run;

package/scripts/cli/commands/refresh.js

@@ -0,0 +1,14 @@
+function run(args) {
+  const quiet = args.includes("--quiet");
+  (async () => {
+    try {
+      const { refreshServe } = require("../../lib/usecases/refresh-serve");
+      const ok = await refreshServe();
+      if (!quiet) console.log(ok ? "Refresh OK" : "Refresh failed");
+    } catch (e) {
+      if (!quiet) console.error("Refresh error:", e.message);
+    }
+  })();
+}
+
+module.exports = run;

package/scripts/cli/commands/search.js

@@ -0,0 +1,28 @@
+function run(args) {
+  const { runSearch } = require("../../lib/usecases/query-articles");
+  const { resolveDataDirs } = require("../../lib/infra/echo-paths");
+
+  const keywordIdx = args.indexOf("--keyword");
+  const tagIdx = args.indexOf("--tag");
+  const keyword = keywordIdx !== -1 ? args[keywordIdx + 1] : null;
+  const tag = tagIdx !== -1 ? args[tagIdx + 1] : null;
+
+  if (!keyword && !tag) {
+    console.error("Usage: echoctl search -- --keyword <keyword> [--tag <tag>]");
+    process.exit(1);
+  }
+
+  const dirs = resolveDataDirs();
+  const results = runSearch({ keyword, tag }, { dirs });
+  if (results.length === 0) {
+    console.log("No results found.");
+  } else {
+    for (const r of results) {
+      console.log(`${r.id} — ${r.title || "(untitled)"}`);
+      console.log(`  ${r.snippet}`);
+      console.log();
+    }
+  }
+}
+
+module.exports = run;

package/scripts/cli/commands/serve.js

@@ -0,0 +1,73 @@
+const path = require("path");
+
+function run(args) {
+    if (args.includes("--foreground")) {
+      require("../../serve").start().catch((err) => {
+        console.error(`${CLI} serve failed:`, err.message);
+        process.exit(1);
+      });
+    } else {
+      (async () => {
+        const fs = require("fs");
+        const { spawn } = require("child_process");
+        const {
+          readServeInfo,
+          serveLogFile,
+          formatServeSummary,
+          isPidRunning,
+        } = require("../../serve");
+        const { isCaptureEnabled } = require("../../lib/infra/config");
+
+        const existing = readServeInfo();
+        if (existing && isPidRunning(existing.pid)) {
+          console.log(formatServeSummary(existing, {
+            background: true,
+            captureEnabled: isCaptureEnabled(),
+            logFile: serveLogFile(),
+          }));
+          return;
+        }
+
+        const logFile = serveLogFile();
+        fs.mkdirSync(require("path").dirname(logFile), { recursive: true });
+        const logFd = fs.openSync(logFile, "a");
+        const child = spawn(process.execPath, [path.resolve(__dirname, "../echoctl.js"), "serve", "--foreground"], {
+          detached: true,
+          stdio: ["ignore", logFd, logFd],
+          env: process.env,
+        });
+        child.unref();
+
+        const startedAt = Date.now();
+        let info = null;
+        while (Date.now() - startedAt < 20000) {
+          await new Promise((r) => setTimeout(r, 250));
+          try {
+            info = readServeInfo();
+          } catch (_) {
+            info = null;
+          }
+          if (info && info.pid === child.pid && isPidRunning(info.pid)) break;
+        }
+
+        fs.closeSync(logFd);
+
+        if (!info || info.pid !== child.pid || !isPidRunning(info.pid)) {
+          console.error(`${CLI} serve failed to start in background.`);
+          console.error(`See log: ${logFile}`);
+          process.exit(1);
+        }
+
+        console.log(formatServeSummary(info, {
+          background: true,
+          captureEnabled: isCaptureEnabled(),
+          logFile,
+        }));
+      })().catch((err) => {
+        console.error(`${CLI} serve failed:`, err.message);
+        process.exit(1);
+      });
+    }
+}
+
+module.exports = run;