@tricknowtech/context 0.1.0

package/dist/cli.d.cts

@@ -0,0 +1,9 @@
+#!/usr/bin/env node
+interface CommandResult {
+    code: number;
+    lines: string[];
+}
+
+declare function run(argv: string[]): CommandResult;
+
+export { run };

package/dist/cli.d.ts

@@ -0,0 +1,9 @@
+#!/usr/bin/env node
+interface CommandResult {
+    code: number;
+    lines: string[];
+}
+
+declare function run(argv: string[]): CommandResult;
+
+export { run };

package/dist/cli.js

@@ -0,0 +1,273 @@
+#!/usr/bin/env node
+import {
+  ALL_TIERS,
+  LOCAL_TIERS,
+  LocalStore,
+  collect,
+  configPath,
+  cwdKey,
+  defaultConfig,
+  ensureGitignoreEntries,
+  findProjectRoot,
+  formatBytes,
+  formatHits,
+  installSlashCommand,
+  isGitRepo,
+  loadConfig,
+  saveConfig,
+  scanFiles,
+  storeDir,
+  summarize,
+  userClaudeDir
+} from "./chunk-DEH5MUFT.js";
+
+// src/commands.ts
+import fs from "fs";
+import path from "path";
+function ok(lines) {
+  return { code: 0, lines };
+}
+function fail(lines) {
+  return { code: 1, lines };
+}
+function requireProject() {
+  const root = findProjectRoot();
+  if (!root) {
+    return fail([
+      "Not inside a project.",
+      "Run this from a git repository, or run `ctx init` to create a store here."
+    ]);
+  }
+  const cfg = loadConfig(root);
+  if (!cfg) {
+    return fail([`No context store found at ${path.join(root, ".contextsync")}.`, "Run `ctx init` first."]);
+  }
+  return { root, cfg };
+}
+function templateContext(root) {
+  return { userClaude: userClaudeDir(), project: root, cwdKey: cwdKey(root) };
+}
+function effectiveTiers(cfg) {
+  const tiers = cfg.tiers.filter((t) => LOCAL_TIERS.includes(t));
+  const refused = cfg.tiers.filter((t) => !LOCAL_TIERS.includes(t));
+  return { tiers, refused };
+}
+function cmdInit(opts = {}) {
+  const root = findProjectRoot() ?? process.cwd();
+  const existing = loadConfig(root);
+  if (existing && !opts.force) {
+    return fail([`Already initialised at ${configPath(root)}.`, "Pass --force to overwrite the config."]);
+  }
+  const cfg = defaultConfig(root);
+  if (opts.artifacts) cfg.tiers = [...cfg.tiers, "artifacts"];
+  saveConfig(root, cfg);
+  const lines = [
+    `Initialised context store for "${cfg.name}"`,
+    `  store   ${path.relative(root, storeDir(root))}/`,
+    `  tiers   ${cfg.tiers.join(", ")}`
+  ];
+  const slash = installSlashCommand(root);
+  lines.push(`  command ${slash.path}${slash.written ? "" : " (already present, left alone)"}`);
+  const added = ensureGitignoreEntries(root, Boolean(opts.artifacts));
+  if (added.length > 0) lines.push(`  ignored ${added.join(", ")}`);
+  if (!isGitRepo(root)) {
+    lines.push("", "Note: this is not a git repository, so the store will not travel with the code.");
+  }
+  lines.push("", "Next: run `/context push` in Claude Code, or `ctx push` directly.");
+  return ok(lines);
+}
+function cmdPush(opts = {}) {
+  const found = requireProject();
+  if ("code" in found) return found;
+  const { root, cfg } = found;
+  const { tiers, refused } = effectiveTiers(cfg);
+  const { files, skippedTracked } = collect(root, cfg, tiers);
+  const lines = [];
+  if (refused.length > 0) {
+    lines.push(
+      `Skipping ${refused.join(", ")} \u2014 not supported by a local store.`,
+      "  Transcripts run to hundreds of MB and would permanently bloat the repo.",
+      "  Add a cloud remote to sync them.",
+      ""
+    );
+  }
+  if (files.length === 0) {
+    lines.push("Nothing to sync.");
+    if (skippedTracked.length > 0) {
+      lines.push(`(${skippedTracked.length} project files skipped \u2014 git already tracks them.)`);
+    }
+    return ok(lines);
+  }
+  const hits = scanFiles(files);
+  if (hits.length > 0 && !opts.allowSecrets) {
+    return fail([
+      ...lines,
+      `Refusing to push \u2014 ${hits.length} possible secret${hits.length === 1 ? "" : "s"} found:`,
+      "",
+      formatHits(hits),
+      "",
+      "These would be committed to the repository and be very hard to remove.",
+      "Fix the source, add an exclude pattern, or re-run with --allow-secrets if these are false positives."
+    ]);
+  }
+  if (hits.length > 0) {
+    lines.push(`Warning: pushing ${hits.length} possible secret(s) because --allow-secrets was set.`, "");
+  }
+  const totals = summarize(files);
+  const totalBytes = files.reduce((n, f) => n + f.size, 0);
+  if (opts.dryRun) {
+    lines.push(`Would sync ${files.length} files (${formatBytes(totalBytes)}):`);
+  } else {
+    const store = new LocalStore(root);
+    store.write(files, root);
+    lines.push(`Synced ${files.length} files (${formatBytes(totalBytes)}) to ${path.relative(root, storeDir(root))}/`);
+  }
+  for (const tier of ALL_TIERS) {
+    const t = totals[tier];
+    if (t.count > 0) lines.push(`  ${tier.padEnd(11)} ${String(t.count).padStart(4)} files  ${formatBytes(t.bytes)}`);
+  }
+  if (skippedTracked.length > 0) {
+    lines.push("", `${skippedTracked.length} project files skipped \u2014 git already tracks them.`);
+  }
+  if (!opts.dryRun) {
+    lines.push("", "Commit .contextsync/ to carry this context with the repo.");
+  }
+  return ok(lines);
+}
+function cmdPull(opts = {}) {
+  const found = requireProject();
+  if ("code" in found) return found;
+  const { root } = found;
+  const store = new LocalStore(root);
+  const manifest = store.readManifest();
+  if (!manifest) {
+    return fail([`No manifest in ${path.relative(root, storeDir(root))}/.`, "Run `ctx push` on the source machine first."]);
+  }
+  const ctx = templateContext(root);
+  const { restored, skipped } = store.restore(ctx, { force: opts.force });
+  const lines = [`Restored ${restored.length} of ${manifest.entries.length} files.`];
+  if (manifest.writtenFrom && manifest.writtenFrom !== root) {
+    lines.push(`  Rewrote paths from ${manifest.writtenFrom} \u2192 ${root}`);
+  }
+  if (skipped.length > 0) {
+    lines.push(
+      "",
+      `${skipped.length} file(s) left alone because the local copy differs:`,
+      ...skipped.slice(0, 15).map((s) => `  ${s}`),
+      ...skipped.length > 15 ? [`  \u2026 and ${skipped.length - 15} more`] : [],
+      "",
+      "Re-run with --force to overwrite them."
+    );
+  }
+  const handoff = store.readHandoff();
+  if (handoff) {
+    lines.push("", `Handoff (${handoff.updatedAt}):`, `  goal: ${handoff.goal}`, `  next: ${handoff.nextStep}`);
+  }
+  return ok(lines);
+}
+function cmdStatus() {
+  const found = requireProject();
+  if ("code" in found) return found;
+  const { root, cfg } = found;
+  const store = new LocalStore(root);
+  const manifest = store.readManifest();
+  const { tiers } = effectiveTiers(cfg);
+  const { files, skippedTracked } = collect(root, cfg, tiers);
+  const lines = [
+    `Project  ${cfg.name}`,
+    `Store    ${path.relative(root, storeDir(root))}/`,
+    `Tiers    ${cfg.tiers.join(", ")}`,
+    `Remotes  ${Object.keys(cfg.remotes).length > 0 ? Object.keys(cfg.remotes).join(", ") : "none (local only)"}`,
+    ""
+  ];
+  if (!manifest) {
+    lines.push(`Never pushed. ${files.length} files ready to sync.`);
+    return ok(lines);
+  }
+  const stored = new Map(manifest.entries.map((e) => [e.storePath, e]));
+  const current = new Map(files.map((f) => [f.storePath, f]));
+  const added = [...current.keys()].filter((k) => !stored.has(k));
+  const removed = [...stored.keys()].filter((k) => !current.has(k));
+  const changed = [...current.entries()].filter(([k, f]) => {
+    const e = stored.get(k);
+    if (!e) return false;
+    if (e.size !== f.size) return true;
+    try {
+      return !fs.readFileSync(path.join(storeDir(root), k)).equals(fs.readFileSync(f.sourcePath));
+    } catch {
+      return true;
+    }
+  }).map(([k]) => k);
+  lines.push(`Last push  ${manifest.updatedAt}`);
+  if (added.length + removed.length + changed.length === 0) {
+    lines.push("", "Up to date.");
+  } else {
+    lines.push("");
+    for (const k of changed.slice(0, 20)) lines.push(`  modified  ${k}`);
+    for (const k of added.slice(0, 20)) lines.push(`  new       ${k}`);
+    for (const k of removed.slice(0, 20)) lines.push(`  removed   ${k}`);
+    const shown = Math.min(changed.length, 20) + Math.min(added.length, 20) + Math.min(removed.length, 20);
+    const total = changed.length + added.length + removed.length;
+    if (total > shown) lines.push(`  \u2026 and ${total - shown} more`);
+    lines.push("", "Run `ctx push` to sync.");
+  }
+  if (skippedTracked.length > 0) {
+    lines.push("", `${skippedTracked.length} project files carried by git directly.`);
+  }
+  return ok(lines);
+}
+
+// src/cli.ts
+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
+
+Options
+  --artifacts       Include derived indexes (graphify-out/, etc.)
+  --allow-secrets   Push even if the secret scan finds hits (think first)
+  --dry-run         Show what would be synced without writing
+  --force           init: overwrite config \xB7 pull: overwrite differing files
+  -h, --help        Show this help
+  -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.`;
+function parseArgs(argv) {
+  const flags = /* @__PURE__ */ new Set();
+  let command = "";
+  for (const arg of argv) {
+    if (arg.startsWith("-")) flags.add(arg.replace(/^-+/, ""));
+    else if (!command) command = arg;
+  }
+  return { command, flags };
+}
+function run(argv) {
+  const { command, flags } = 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.0"] };
+  switch (command) {
+    case "init":
+      return cmdInit({ artifacts: flags.has("artifacts"), force: flags.has("force") });
+    case "push":
+      return cmdPush({ allowSecrets: flags.has("allow-secrets"), dryRun: flags.has("dry-run") });
+    case "pull":
+      return cmdPull({ force: flags.has("force") });
+    case "status":
+    case "":
+      return cmdStatus();
+    default:
+      return { code: 1, lines: [`Unknown command: ${command}`, "", USAGE] };
+  }
+}
+var result = run(process.argv.slice(2));
+var out = result.lines.join("\n");
+if (result.code === 0) console.log(out);
+else console.error(out);
+process.exit(result.code);
+export {
+  run
+};