@tricknowtech/context 0.1.1 → 0.3.0

package/dist/cli.js

@@ -3,6 +3,7 @@ import {
   ALL_TIERS,
   LOCAL_TIERS,
   LocalStore,
+  SLASH_COMMAND_PATH,
   collect,
   configPath,
   cwdKey,
@@ -11,18 +12,25 @@ import {
   ensureGitignoreEntries,
   findProjectRoot,
   formatBytes,
+  formatHandoff,
   formatHits,
+  handoffAge,
   installSlashCommand,
   isGitRepo,
+  isStale,
   loadConfig,
+  resolveTemplate,
   saveConfig,
   scanFiles,
   storeDir,
   summarize,
-  userClaudeDir
-} from "./chunk-BWATZKYM.js";
+  templateContextFor,
+  userClaudeDir,
+  validateHandoff
+} from "./chunk-BLEGQVXA.js";
 
 // src/commands.ts
+import { execFileSync } from "child_process";
 import fs from "fs";
 import path from "path";
 function ok(lines) {
@@ -46,7 +54,7 @@ function requireProject() {
   return { root, cfg };
 }
 function templateContext(root) {
-  return { userClaude: userClaudeDir(), project: root, cwdKey: cwdKey(root) };
+  return templateContextFor(root);
 }
 function effectiveTiers(cfg) {
   const tiers = cfg.tiers.filter((t) => LOCAL_TIERS.includes(t));
@@ -82,7 +90,7 @@ function cmdPush(opts = {}) {
   if ("code" in found) return found;
   const { root, cfg } = found;
   const { tiers, refused } = effectiveTiers(cfg);
-  const { files, skippedTracked } = collect(root, cfg, tiers);
+  const { files, skippedTracked, assistants } = collect(root, cfg, tiers);
   const lines = [];
   if (refused.length > 0) {
     lines.push(
@@ -127,6 +135,9 @@ function cmdPush(opts = {}) {
     const t = totals[tier];
     if (t.count > 0) lines.push(`  ${tier.padEnd(11)} ${String(t.count).padStart(4)} files  ${formatBytes(t.bytes)}`);
   }
+  if (assistants.length > 0) {
+    lines.push("", `Assistants: ${assistants.map((a) => a.name).join(", ")}`);
+  }
   if (skippedTracked.length > 0) {
     lines.push("", `${skippedTracked.length} project files skipped \u2014 git already tracks them.`);
   }
@@ -138,6 +149,20 @@ function cmdPush(opts = {}) {
     }
   }
   if (!opts.dryRun) {
+    const store = new LocalStore(root);
+    const raw = store.readHandoff();
+    const v = raw ? validateHandoff(raw) : null;
+    if (!raw) {
+      lines.push(
+        "",
+        "No handoff written \u2014 the other machine will get your project knowledge but",
+        "not where you left off. Use `/context push` in Claude Code to include one."
+      );
+    } else if (v && !v.ok) {
+      lines.push("", "Handoff present but malformed (it will be ignored):", ...v.errors.map((e) => `  \xB7 ${e}`));
+    } else if (v?.ok && isStale(v.handoff, Date.now())) {
+      lines.push("", `Handoff is ${handoffAge(v.handoff)} \u2014 re-run \`/context push\` to refresh it.`);
+    }
     lines.push("", "Commit .contextsync/ to carry this context with the repo.");
   }
   return ok(lines);
@@ -167,12 +192,114 @@ function cmdPull(opts = {}) {
       "Re-run with --force to overwrite them."
     );
   }
-  const handoff = store.readHandoff();
-  if (handoff) {
-    lines.push("", `Handoff (${handoff.updatedAt}):`, `  goal: ${handoff.goal}`, `  next: ${handoff.nextStep}`);
+  const raw = store.readHandoff();
+  if (!raw) {
+    lines.push(
+      "",
+      "No handoff in this store \u2014 you have the project knowledge, but not where the",
+      "last session stopped. Run `/context push` (not bare `ctx push`) on the other",
+      "machine: only the model can write the handoff, since only it has the conversation."
+    );
+    return ok(lines);
+  }
+  const check = validateHandoff(raw);
+  if (!check.ok) {
+    lines.push("", "A handoff exists but is malformed and was ignored:", ...check.errors.map((e) => `  \xB7 ${e}`));
+    return ok(lines);
   }
+  lines.push("", ...formatHandoff(check.handoff));
   return ok(lines);
 }
+function cmdHandoff(opts = {}) {
+  const found = requireProject();
+  if ("code" in found) return found;
+  const { root } = found;
+  const store = new LocalStore(root);
+  if (opts.set !== void 0) {
+    let parsed;
+    try {
+      parsed = JSON.parse(opts.set);
+    } catch (e) {
+      return fail([`Could not parse handoff JSON: ${e.message}`]);
+    }
+    const check2 = validateHandoff(parsed);
+    if (!check2.ok) return fail(["Handoff is not valid:", ...check2.errors.map((e) => `  \xB7 ${e}`)]);
+    store.writeHandoff(check2.handoff);
+    return ok([`Handoff saved (${path.relative(root, storeDir(root))}/handoff.json).`, "", ...formatHandoff(check2.handoff)]);
+  }
+  const raw = store.readHandoff();
+  if (!raw) {
+    return ok([
+      "No handoff yet.",
+      "",
+      "Write one with `/context push` in Claude Code, or pipe JSON:",
+      `  ctx handoff --set '{"goal":"\u2026","nextStep":"\u2026"}'`
+    ]);
+  }
+  const check = validateHandoff(raw);
+  if (!check.ok) return fail(["Handoff is malformed:", ...check.errors.map((e) => `  \xB7 ${e}`)]);
+  return ok(formatHandoff(check.handoff));
+}
+function cmdDoctor() {
+  const root = findProjectRoot();
+  if (!root) return fail(["Not inside a project. Run `ctx init` first."]);
+  const lines = [];
+  let problems = 0;
+  const check = (okFlag, label, detail) => {
+    if (!okFlag) problems++;
+    lines.push(`  ${okFlag ? "\u2713" : "\u2717"} ${label.padEnd(28)} ${detail}`);
+  };
+  const cfg = loadConfig(root);
+  check(Boolean(cfg), "store initialised", cfg ? `${path.relative(root, storeDir(root))}/` : "missing \u2014 run `ctx init`");
+  if (!cfg) return { code: 1, lines: ["Setup check", "", ...lines] };
+  const store = new LocalStore(root);
+  const manifest = store.readManifest();
+  check(Boolean(manifest), "pushed at least once", manifest ? `${manifest.entries.length} files` : "never \u2014 run `ctx push`");
+  const detected = collect(root, cfg, ["core"]).assistants;
+  check(
+    detected.length > 0,
+    "assistants detected",
+    detected.length > 0 ? detected.map((a) => a.name).join(", ") : "none \u2014 no known assistant config found"
+  );
+  check(
+    fs.existsSync(path.join(root, SLASH_COMMAND_PATH)),
+    "/context slash command",
+    fs.existsSync(path.join(root, SLASH_COMMAND_PATH)) ? SLASH_COMMAND_PATH : `missing \u2014 run \`ctx init --force\``
+  );
+  const inGit = isGitRepo(root);
+  check(inGit, "git repository", inGit ? "yes \u2014 store travels with the repo" : "no \u2014 the store will not sync anywhere");
+  let storeIgnored = false;
+  if (inGit) {
+    try {
+      execFileSync("git", ["-C", root, "check-ignore", "-q", ".contextsync/config.json"], { stdio: "ignore" });
+      storeIgnored = true;
+    } catch {
+      storeIgnored = false;
+    }
+  }
+  check(!storeIgnored, "store is committable", storeIgnored ? "IGNORED by git \u2014 it will never reach another machine" : "not gitignored");
+  const ctx = templateContext(root);
+  const memEntry = manifest?.entries.find((e) => e.storePath.startsWith("memory/"));
+  if (memEntry) {
+    const dest = resolveTemplate(memEntry.restoreTemplate, ctx);
+    const expectedDir = path.join(userClaudeDir(), "projects", cwdKey(root), "memory");
+    check(dest.startsWith(expectedDir), "memory restore path", dest.startsWith(expectedDir) ? expectedDir : `WRONG \u2192 ${dest}`);
+  } else {
+    check(false, "memory captured", "none found \u2014 is ~/.claude/projects/<key>/memory populated?");
+  }
+  const raw = store.readHandoff();
+  if (!raw) {
+    check(false, "handoff", "absent \u2014 `/context push` writes it; resume will have nothing to say");
+  } else {
+    const v = validateHandoff(raw);
+    check(v.ok, "handoff", v.ok ? `valid, ${handoffAge(v.handoff)}` : v.errors[0]);
+    if (v.ok && manifest && isStale(v.handoff, Date.parse(manifest.updatedAt))) {
+      lines.push("    ! handoff is much older than the last push \u2014 re-run `/context push`");
+    }
+  }
+  const header = problems === 0 ? "Setup check \u2014 all good" : `Setup check \u2014 ${problems} problem${problems === 1 ? "" : "s"}`;
+  return { code: problems === 0 ? 0 : 1, lines: [header, "", ...lines] };
+}
 function cmdStatus() {
   const found = requireProject();
   if ("code" in found) return found;
@@ -180,11 +307,16 @@ function cmdStatus() {
   const store = new LocalStore(root);
   const manifest = store.readManifest();
   const { tiers } = effectiveTiers(cfg);
-  const { files, skippedTracked } = collect(root, cfg, tiers);
+  const { files, skippedTracked, assistants } = collect(root, cfg, tiers);
+  const rawHandoff = store.readHandoff();
+  const hv = rawHandoff ? validateHandoff(rawHandoff) : null;
+  const handoffLabel = !rawHandoff ? "none \u2014 run `/context push` to record where you left off" : hv?.ok ? `${handoffAge(hv.handoff)}` : "malformed (will be ignored)";
   const lines = [
     `Project  ${cfg.name}`,
     `Store    ${path.relative(root, storeDir(root))}/`,
     `Tiers    ${cfg.tiers.join(", ")}`,
+    `Handoff  ${handoffLabel}`,
+    `Tools    ${assistants.length > 0 ? assistants.map((a) => a.name).join(", ") : "none detected"}`,
     `Remotes  ${Object.keys(cfg.remotes).length > 0 ? Object.keys(cfg.remotes).join(", ") : "none (local only)"}`,
     ""
   ];
@@ -226,13 +358,16 @@ function cmdStatus() {
 }
 
 // src/cli.ts
+var VERSION = "0.3.0";
 var USAGE = `tricknowtech context-sync \u2014 carry a project's LLM context between machines
 
 Usage
   ctx init [--artifacts] [--force]   Create the store and install /context
   ctx push [--dry-run]               Collect context into the store
-  ctx pull [--force]                 Restore context from the store
-  ctx status                         Show what has changed since the last push
+  ctx pull [--force]                 Restore context, and show where you left off
+  ctx status                         What has changed since the last push
+  ctx handoff [--set '<json>']       Show or write the session handoff
+  ctx doctor                         Check the setup is actually wired correctly
 
 Options
   --artifacts       Include derived indexes (graphify-out/, etc.)
@@ -243,20 +378,38 @@ Options
   -v, --version     Show version
 
 The store lives in .contextsync/ and is meant to be committed, so context
-travels with the code. Session transcripts are excluded from local mode.`;
+travels with the code. Session transcripts are excluded from local mode.
+
+Prefer \`/context push\` inside Claude Code over bare \`ctx push\`: only the
+model can write the handoff that lets the next machine resume the work.`;
 function parseArgs(argv) {
   const flags = /* @__PURE__ */ new Set();
+  const values = /* @__PURE__ */ new Map();
   let command = "";
-  for (const arg of argv) {
-    if (arg.startsWith("-")) flags.add(arg.replace(/^-+/, ""));
-    else if (!command) command = arg;
+  for (let i = 0; i < argv.length; i++) {
+    const arg = argv[i];
+    if (arg.startsWith("-")) {
+      const name = arg.replace(/^-+/, "");
+      const eq = name.indexOf("=");
+      if (eq !== -1) {
+        values.set(name.slice(0, eq), name.slice(eq + 1));
+        continue;
+      }
+      if (name === "set" && i + 1 < argv.length && !argv[i + 1].startsWith("-")) {
+        values.set(name, argv[++i]);
+        continue;
+      }
+      flags.add(name);
+    } else if (!command) {
+      command = arg;
+    }
   }
-  return { command, flags };
+  return { command, flags, values };
 }
 function run(argv) {
-  const { command, flags } = parseArgs(argv);
+  const { command, flags, values } = parseArgs(argv);
   if (flags.has("h") || flags.has("help")) return { code: 0, lines: [USAGE] };
-  if (flags.has("v") || flags.has("version")) return { code: 0, lines: ["0.1.1"] };
+  if (flags.has("v") || flags.has("version")) return { code: 0, lines: [VERSION] };
   switch (command) {
     case "init":
       return cmdInit({ artifacts: flags.has("artifacts"), force: flags.has("force") });
@@ -264,6 +417,10 @@ function run(argv) {
       return cmdPush({ allowSecrets: flags.has("allow-secrets"), dryRun: flags.has("dry-run") });
     case "pull":
       return cmdPull({ force: flags.has("force") });
+    case "handoff":
+      return cmdHandoff({ set: values.get("set") });
+    case "doctor":
+      return cmdDoctor();
     case "status":
     case "":
       return cmdStatus();