@research-copilot/cli 1.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 ldm2060
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/dist/rc.js

@@ -0,0 +1,203 @@
+#!/usr/bin/env node
+
+// src/program.ts
+import { Command } from "commander";
+
+// src/commands/context.ts
+import { buildContext } from "@research-copilot/core";
+function runContext(args) {
+  return buildContext(args.repo, { format: args.format, now: args.now, eventName: args.eventName });
+}
+
+// src/commands/doctor.ts
+import * as fs from "fs";
+import * as path from "path";
+function runDoctor(repo) {
+  const report = [];
+  let ok = true;
+  const checks = [
+    [".research/ exists", fs.existsSync(path.join(repo, ".research"))],
+    ["workflow.md exists", fs.existsSync(path.join(repo, ".research/workflow.md"))],
+    [".claude/settings.json exists", fs.existsSync(path.join(repo, ".claude/settings.json"))]
+  ];
+  for (const [name, pass] of checks) {
+    report.push(`${pass ? "OK " : "FAIL"} ${name}`);
+    if (!pass) ok = false;
+  }
+  return { ok, report };
+}
+
+// src/commands/init.ts
+import * as fs2 from "fs";
+import * as path2 from "path";
+import { fileURLToPath } from "url";
+import { researchPaths } from "@research-copilot/core";
+import { configurePlatform, kitRoot } from "@research-copilot/adapters";
+var __dirname = path2.dirname(fileURLToPath(import.meta.url));
+function runInit(args) {
+  const p = researchPaths(args.repo);
+  for (const d of [p.tasks, p.spec, p.workspace, p.runtime]) fs2.mkdirSync(d, { recursive: true });
+  for (const s of ["venue", "writing", "baselines", "methodology", "novelty"])
+    fs2.mkdirSync(path2.join(p.spec, s), { recursive: true });
+  const KIT = kitRoot(__dirname);
+  fs2.copyFileSync(path2.join(KIT, "workflow.md"), p.workflow);
+  fs2.copyFileSync(path2.join(KIT, "config.defaults.yaml"), p.config);
+  for (const p2 of args.platforms) configurePlatform(args.repo, p2);
+}
+function registerInit(program2, repo) {
+  program2.command("init").option("--claude", "Claude Code", false).option("--codex", "OpenAI Codex", false).option("--opencode", "OpenCode", false).option("--gemini", "Gemini CLI", false).option("--cursor", "Cursor", false).option("--windsurf", "Windsurf", false).requiredOption("-u, --user <name>", "developer identity").action((opts) => {
+    const platforms = [];
+    if (opts.claude) platforms.push("claude-code");
+    if (opts.codex) platforms.push("codex");
+    if (opts.opencode) platforms.push("opencode");
+    if (opts.gemini) platforms.push("gemini");
+    if (opts.cursor) platforms.push("cursor");
+    if (opts.windsurf) platforms.push("windsurf");
+    if (platforms.length === 0) platforms.push("claude-code");
+    runInit({ repo, platforms, user: opts.user });
+    process.stdout.write(`Initialized .research/ for: ${platforms.join(", ")}
+`);
+  });
+}
+
+// src/commands/task.ts
+import * as fs3 from "fs";
+import * as path3 from "path";
+import {
+  createTask,
+  readTask,
+  writeTask,
+  setStatus,
+  setActive,
+  getActive,
+  numberTraceability,
+  researchPaths as researchPaths2
+} from "@research-copilot/core";
+function taskCreate(repo, i) {
+  const t = createTask(repo, i);
+  setActive(repo, t.id);
+  return t;
+}
+function taskSetStatus(repo, id, to, now) {
+  setStatus(repo, id, to, now);
+}
+function taskAddGap(repo, id, desc, suggest_kind) {
+  const t = readTask(repo, id);
+  t.gaps.push({ desc, suggest_kind, status: "open" });
+  writeTask(repo, t, (/* @__PURE__ */ new Date()).toISOString());
+}
+function taskCurrent(repo) {
+  return getActive(repo);
+}
+function runVerifyGate(repo, id, now) {
+  const t = readTask(repo, id);
+  const dir = path3.join(researchPaths2(repo).taskDir(id), "artifacts");
+  const read = (glob) => fs3.existsSync(dir) ? fs3.readdirSync(dir).filter((f) => glob.test(f)).map((f) => fs3.readFileSync(path3.join(dir, f), "utf8")).join("\n") : "";
+  let result = { ok: true, missing: [] };
+  if (t.kind === "writing") {
+    const draft = read(/\.tex$/);
+    const artifacts = read(/\.(log|txt|json|csv)$/);
+    result = numberTraceability(draft, artifacts);
+  }
+  if (!result.ok && t.status === "verify") setStatus(repo, id, "in_progress", now);
+  return result;
+}
+function registerTask(program2, repo) {
+  const today = () => (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
+  const task = program2.command("task");
+  task.command("create").requiredOption("--kind <k>").requiredOption("--title <t>").option("--venue <v>").option("--parent <p>").action((o) => {
+    const t = taskCreate(repo, { title: o.title, kind: o.kind, date: today(), venue: o.venue, parent: o.parent });
+    process.stdout.write(t.id + "\n");
+  });
+  for (const [cmd, to] of [["start", "in_progress"], ["complete", "completed"]])
+    task.command(cmd).argument("<id>").action((id) => taskSetStatus(repo, id, to, (/* @__PURE__ */ new Date()).toISOString()));
+  task.command("verify").argument("<id>").action((id) => {
+    const r = runVerifyGate(repo, id, (/* @__PURE__ */ new Date()).toISOString());
+    if (r.ok) process.stdout.write(`verify OK for ${id}
+`);
+    else {
+      process.stdout.write(`verify FAILED (untraceable: ${r.missing.join(", ")}); rolled back to in_progress
+`);
+      process.exitCode = 1;
+    }
+  });
+  task.command("set-status").argument("<id>").argument("<state>").action((id, state) => taskSetStatus(repo, id, state, (/* @__PURE__ */ new Date()).toISOString()));
+  task.command("add-gap").argument("<id>").requiredOption("--desc <d>").requiredOption("--suggest <k>").action((id, o) => taskAddGap(repo, id, o.desc, o.suggest));
+  task.command("current").action(() => process.stdout.write((taskCurrent(repo) ?? "none") + "\n"));
+}
+
+// src/commands/sync.ts
+import { homedir } from "os";
+import { join as join4 } from "path";
+import { syncSkillpacks, writeLockFile } from "@research-copilot/core";
+function sync(args) {
+  const repoRoot = args.repo;
+  const cacheDir = args.cacheDir || join4(homedir(), ".cache", "research-copilot", "skillpacks");
+  const targetDir = args.targetDir || join4(repoRoot, "research-kit");
+  console.error(`[sync] Repository: ${repoRoot}`);
+  console.error(`[sync] Cache: ${cacheDir}`);
+  console.error(`[sync] Target: ${targetDir}`);
+  console.error("");
+  const lock = syncSkillpacks(repoRoot, cacheDir, targetDir);
+  const lockPath = join4(repoRoot, "skillpacks.lock.yaml");
+  writeLockFile(lockPath, lock);
+  console.error("");
+  console.error(`[sync] Lock file written: ${lockPath}`);
+  console.error(`[sync] Synced ${lock.packs.length} packs with ${lock.packs.reduce((sum, p) => sum + p.agentCount, 0)} agents and ${lock.packs.reduce((sum, p) => sum + p.specCount, 0)} specs`);
+}
+
+// src/program.ts
+function buildProgram(repo = process.cwd()) {
+  const program2 = new Command("rc");
+  program2.command("context").option("--platform <p>", "platform", "claude-code").option("--inject", "inject mode", false).option("--format <f>", "text|json", "text").option("--event <name>", "hook event name for json envelope").action((opts) => {
+    process.stdout.write(runContext({ repo, format: opts.format, now: (/* @__PURE__ */ new Date()).toISOString(), eventName: opts.event }));
+  });
+  program2.command("doctor").action(() => {
+    const { ok, report } = runDoctor(repo);
+    process.stdout.write(report.join("\n") + "\n");
+    process.exitCode = ok ? 0 : 1;
+  });
+  registerInit(program2, repo);
+  registerTask(program2, repo);
+  program2.command("sync").description("Fetch skillpacks and render agents/specs").option("--repo <path>", "Repository root", repo).option("--cache-dir <path>", "Cache directory for skillpacks").option("--target-dir <path>", "Target directory for rendered files").action((opts) => {
+    sync({
+      repo: opts.repo,
+      cacheDir: opts.cacheDir,
+      targetDir: opts.targetDir
+    });
+  });
+  return program2;
+}
+
+// src/errors.ts
+function classifyCliError(err) {
+  const e = err;
+  if (e && typeof e.code === "string" && e.code.startsWith("commander.")) {
+    if (e.code === "commander.helpDisplayed" || e.code === "commander.version") {
+      return { exitCode: 0, message: null };
+    }
+    return { exitCode: 2, message: null };
+  }
+  const raw = err instanceof Error ? err.message : String(err);
+  if (/illegal transition/i.test(raw)) return { exitCode: 2, message: raw };
+  if (e?.code === "ENOENT" || /ENOENT|no such file/i.test(raw)) {
+    return { exitCode: 1, message: "not found: the requested task or a required file does not exist" };
+  }
+  return { exitCode: 1, message: raw };
+}
+function applyExitOverride(cmd) {
+  cmd.exitOverride();
+  for (const sub of cmd.commands) applyExitOverride(sub);
+}
+
+// bin/rc.ts
+var program = buildProgram();
+applyExitOverride(program);
+try {
+  program.parse(process.argv);
+} catch (err) {
+  const { exitCode, message } = classifyCliError(err);
+  if (message) process.stderr.write(`rc: ${message}
+`);
+  process.exit(exitCode);
+}

package/package.json

@@ -0,0 +1,38 @@
+{
+  "name": "@research-copilot/cli",
+  "version": "1.0.0",
+  "description": "Multi-platform AI research assistant with MCP integration and skillpacks",
+  "type": "module",
+  "bin": {
+    "rc": "./dist/rc.js"
+  },
+  "files": [
+    "dist",
+    "README.md"
+  ],
+  "keywords": [
+    "ai",
+    "research",
+    "mcp",
+    "claude",
+    "gemini",
+    "cursor"
+  ],
+  "author": "ldm2060",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/ldm2060/research_copilot.git"
+  },
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "dependencies": {
+    "@research-copilot/core": "^1.0.0",
+    "@research-copilot/adapters": "^1.0.0",
+    "commander": "^12.1.0"
+  },
+  "scripts": {
+    "build": "tsup bin/rc.ts --format esm"
+  }
+}