@tricknowtech/context 0.1.0

package/dist/cli.cjs

@@ -0,0 +1,880 @@
+#!/usr/bin/env node
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/cli.ts
+var cli_exports = {};
+__export(cli_exports, {
+  run: () => run
+});
+module.exports = __toCommonJS(cli_exports);
+
+// src/commands.ts
+var import_node_fs7 = __toESM(require("fs"), 1);
+var import_node_path6 = __toESM(require("path"), 1);
+
+// src/collector.ts
+var import_node_fs3 = __toESM(require("fs"), 1);
+var import_node_path3 = __toESM(require("path"), 1);
+
+// src/config.ts
+var import_node_crypto = __toESM(require("crypto"), 1);
+var import_node_fs2 = __toESM(require("fs"), 1);
+var import_node_path2 = __toESM(require("path"), 1);
+
+// src/fsutil.ts
+var import_node_child_process = require("child_process");
+var import_node_fs = __toESM(require("fs"), 1);
+var import_node_os = __toESM(require("os"), 1);
+var import_node_path = __toESM(require("path"), 1);
+function userClaudeDir() {
+  return process.env.CLAUDE_CONFIG_DIR ?? import_node_path.default.join(import_node_os.default.homedir(), ".claude");
+}
+function cwdKey(absPath) {
+  return absPath.replace(/[^a-zA-Z0-9]/g, "-");
+}
+function makeTemplate(absPath, ctx) {
+  const candidates = [
+    [ctx.userClaude, "{userClaude}"],
+    [ctx.project, "{project}"]
+  ].sort((a, b) => b[0].length - a[0].length);
+  let out2 = absPath;
+  for (const [root, token] of candidates) {
+    if (absPath === root || absPath.startsWith(root + import_node_path.default.sep)) {
+      out2 = token + "/" + toPosix(import_node_path.default.relative(root, absPath));
+      break;
+    }
+  }
+  return ctx.cwdKey ? out2.split(ctx.cwdKey).join("{cwdKey}") : out2;
+}
+function resolveTemplate(template, ctx) {
+  const expanded = template.split("{userClaude}").join(ctx.userClaude).split("{project}").join(ctx.project).split("{cwdKey}").join(ctx.cwdKey);
+  return import_node_path.default.normalize(expanded);
+}
+function toPosix(p) {
+  return p.split(import_node_path.default.sep).join("/");
+}
+function gitTrackedSet(root) {
+  try {
+    const out2 = (0, import_node_child_process.execFileSync)("git", ["-C", root, "ls-files", "-z"], {
+      encoding: "utf8",
+      maxBuffer: 64 * 1024 * 1024,
+      stdio: ["ignore", "pipe", "ignore"]
+    });
+    const set = /* @__PURE__ */ new Set();
+    for (const rel of out2.split("\0")) {
+      if (rel) set.add(import_node_path.default.resolve(root, rel));
+    }
+    return set;
+  } catch {
+    return /* @__PURE__ */ new Set();
+  }
+}
+function isGitRepo(root) {
+  try {
+    (0, import_node_child_process.execFileSync)("git", ["-C", root, "rev-parse", "--is-inside-work-tree"], {
+      stdio: "ignore"
+    });
+    return true;
+  } catch {
+    return false;
+  }
+}
+function globToRegExp(pattern) {
+  let re = "";
+  for (let i = 0; i < pattern.length; i++) {
+    const c = pattern[i];
+    if (c === "*") {
+      if (pattern[i + 1] === "*") {
+        if (pattern[i + 2] === "/") {
+          re += "(?:.*/)?";
+          i += 2;
+        } else {
+          re += ".*";
+          i += 1;
+        }
+      } else {
+        re += "[^/]*";
+      }
+    } else if (c === "?") {
+      re += "[^/]";
+    } else if ("\\^$.|+()[]{}".includes(c)) {
+      re += "\\" + c;
+    } else {
+      re += c;
+    }
+  }
+  if (pattern.endsWith("/")) re += ".*";
+  return new RegExp("^" + re + "$");
+}
+function matchesAny(relPath, patterns) {
+  const p = toPosix(relPath);
+  return patterns.some((pattern) => {
+    const re = globToRegExp(pattern);
+    if (re.test(p)) return true;
+    if (!pattern.includes("/")) {
+      return p.split("/").some((seg) => globToRegExp(pattern).test(seg));
+    }
+    return false;
+  });
+}
+function walk(root, opts = {}) {
+  const { exclude = [], maxFiles = 5e4 } = opts;
+  const out2 = [];
+  if (!import_node_fs.default.existsSync(root)) return out2;
+  const stack = [root];
+  while (stack.length > 0) {
+    const dir = stack.pop();
+    let entries;
+    try {
+      entries = import_node_fs.default.readdirSync(dir, { withFileTypes: true });
+    } catch {
+      continue;
+    }
+    for (const entry of entries) {
+      const abs = import_node_path.default.join(dir, entry.name);
+      const rel = toPosix(import_node_path.default.relative(root, abs));
+      if (matchesAny(rel, exclude)) continue;
+      if (entry.isDirectory()) {
+        stack.push(abs);
+      } else if (entry.isFile()) {
+        if (out2.length >= maxFiles) return out2;
+        out2.push(abs);
+      }
+    }
+  }
+  return out2;
+}
+function ensureDir(dir) {
+  import_node_fs.default.mkdirSync(dir, { recursive: true });
+}
+function readJson(file) {
+  try {
+    return JSON.parse(import_node_fs.default.readFileSync(file, "utf8"));
+  } catch {
+    return null;
+  }
+}
+function writeJson(file, value) {
+  ensureDir(import_node_path.default.dirname(file));
+  import_node_fs.default.writeFileSync(file, JSON.stringify(value, null, 2) + "\n", "utf8");
+}
+function copyFile(from, to) {
+  ensureDir(import_node_path.default.dirname(to));
+  import_node_fs.default.copyFileSync(from, to);
+}
+function formatBytes(n) {
+  if (n < 1024) return `${n} B`;
+  if (n < 1024 * 1024) return `${(n / 1024).toFixed(1)} KB`;
+  if (n < 1024 * 1024 * 1024) return `${(n / 1024 / 1024).toFixed(1)} MB`;
+  return `${(n / 1024 / 1024 / 1024).toFixed(2)} GB`;
+}
+
+// src/config.ts
+var STORE_DIR = ".contextsync";
+var CONFIG_FILE = "config.json";
+var HANDOFF_FILE = "handoff.json";
+var HARD_DENY = [
+  "**/.env",
+  "**/.env.*",
+  "**/.credentials.json",
+  "**/.claude.json",
+  "**/*.pem",
+  "**/*.key",
+  "**/id_rsa*",
+  "**/id_ed25519*",
+  "**/node_modules/",
+  "**/.git/",
+  "**/vendor/",
+  `**/${STORE_DIR}/`
+];
+var DEFAULT_EXCLUDE = [
+  "**/*.log",
+  "**/.DS_Store",
+  "**/dist/",
+  "**/build/",
+  "**/.next/",
+  "**/__pycache__/"
+];
+function defaultConfig(projectRoot) {
+  return {
+    projectId: import_node_crypto.default.randomUUID(),
+    name: import_node_path2.default.basename(projectRoot),
+    rootHint: projectRoot,
+    tiers: ["core", "handoff"],
+    artifactPaths: ["graphify-out"],
+    exclude: [...DEFAULT_EXCLUDE],
+    remotes: {}
+  };
+}
+function findProjectRoot(start = process.cwd()) {
+  let dir = import_node_path2.default.resolve(start);
+  for (; ; ) {
+    if (import_node_fs2.default.existsSync(import_node_path2.default.join(dir, STORE_DIR, CONFIG_FILE))) return dir;
+    if (import_node_fs2.default.existsSync(import_node_path2.default.join(dir, ".git"))) return dir;
+    const parent = import_node_path2.default.dirname(dir);
+    if (parent === dir) return null;
+    dir = parent;
+  }
+}
+function storeDir(projectRoot) {
+  return import_node_path2.default.join(projectRoot, STORE_DIR);
+}
+function configPath(projectRoot) {
+  return import_node_path2.default.join(storeDir(projectRoot), CONFIG_FILE);
+}
+function loadConfig(projectRoot) {
+  const cfg = readJson(configPath(projectRoot));
+  if (!cfg) return null;
+  return {
+    ...defaultConfig(projectRoot),
+    ...cfg,
+    remotes: cfg.remotes ?? {},
+    tiers: cfg.tiers ?? ["core", "handoff"]
+  };
+}
+function saveConfig(projectRoot, cfg) {
+  writeJson(configPath(projectRoot), cfg);
+}
+
+// src/collector.ts
+var PROJECT_CONTEXT_GLOBS = [
+  "CLAUDE.md",
+  "CLAUDE.local.md",
+  "AGENTS.md",
+  "**/CLAUDE.md",
+  "**/AGENTS.md",
+  ".cursorrules",
+  ".github/copilot-instructions.md",
+  ".claude/settings.json",
+  ".claude/memory/",
+  ".claude/plans/",
+  ".claude/commands/",
+  ".claude/agents/",
+  ".claude/skills/"
+];
+function push(out2, sourcePath, storePath, tier, sourceRoot, ctx) {
+  let size = 0;
+  try {
+    size = import_node_fs3.default.statSync(sourcePath).size;
+  } catch {
+    return;
+  }
+  out2.push({
+    storePath,
+    sourcePath,
+    sourceRoot,
+    tier,
+    size,
+    restoreTemplate: makeTemplate(sourcePath, ctx)
+  });
+}
+function collect(projectRoot, cfg, tiers) {
+  const userClaude = userClaudeDir();
+  const key = cwdKey(projectRoot);
+  const ctx = { userClaude, project: projectRoot, cwdKey: key };
+  const files = [];
+  const skippedTracked = [];
+  const exclude = [...HARD_DENY, ...cfg.exclude];
+  const tracked = gitTrackedSet(projectRoot);
+  if (tiers.includes("core")) {
+    for (const abs of walk(projectRoot, { exclude })) {
+      const rel = toPosix(import_node_path3.default.relative(projectRoot, abs));
+      if (!matchesAny(rel, PROJECT_CONTEXT_GLOBS)) continue;
+      if (tracked.has(abs)) {
+        skippedTracked.push(rel);
+        continue;
+      }
+      push(files, abs, `project/${rel}`, "core", "project", ctx);
+    }
+    const memoryDir = import_node_path3.default.join(userClaude, "projects", key, "memory");
+    for (const abs of walk(memoryDir, { exclude })) {
+      const rel = toPosix(import_node_path3.default.relative(memoryDir, abs));
+      push(files, abs, `memory/${rel}`, "core", "user", ctx);
+    }
+    const skillsDir = import_node_path3.default.join(userClaude, "skills");
+    for (const abs of walk(skillsDir, { exclude })) {
+      const rel = toPosix(import_node_path3.default.relative(skillsDir, abs));
+      push(files, abs, `skills/${rel}`, "core", "user", ctx);
+    }
+    const agentsDir = import_node_path3.default.join(userClaude, "agents");
+    for (const abs of walk(agentsDir, { exclude })) {
+      const rel = toPosix(import_node_path3.default.relative(agentsDir, abs));
+      push(files, abs, `agents/${rel}`, "core", "user", ctx);
+    }
+    for (const name of ["CLAUDE.md", "settings.json"]) {
+      const abs = import_node_path3.default.join(userClaude, name);
+      if (import_node_fs3.default.existsSync(abs)) push(files, abs, `user/${name}`, "core", "user", ctx);
+    }
+  }
+  if (tiers.includes("artifacts")) {
+    for (const relDir of cfg.artifactPaths) {
+      const absDir = import_node_path3.default.join(projectRoot, relDir);
+      for (const abs of walk(absDir, { exclude })) {
+        const rel = toPosix(import_node_path3.default.relative(absDir, abs));
+        push(files, abs, `artifacts/${relDir}/${rel}`, "artifacts", "project", ctx);
+      }
+    }
+  }
+  if (tiers.includes("transcripts")) {
+    const projDir = import_node_path3.default.join(userClaude, "projects", key);
+    for (const abs of walk(projDir, { exclude })) {
+      const rel = toPosix(import_node_path3.default.relative(projDir, abs));
+      if (rel.startsWith("memory/")) continue;
+      push(files, abs, `transcripts/${rel}`, "transcripts", "user", ctx);
+    }
+  }
+  return { files, skippedTracked, ctx };
+}
+function summarize(files) {
+  const empty = { count: 0, bytes: 0 };
+  const out2 = {
+    core: { ...empty },
+    handoff: { ...empty },
+    artifacts: { ...empty },
+    transcripts: { ...empty }
+  };
+  for (const f of files) {
+    out2[f.tier].count++;
+    out2[f.tier].bytes += f.size;
+  }
+  return out2;
+}
+
+// src/scaffold.ts
+var import_node_fs4 = __toESM(require("fs"), 1);
+var import_node_path4 = __toESM(require("path"), 1);
+var SLASH_COMMAND_PATH = ".claude/commands/context.md";
+var SLASH_COMMAND_BODY = `---
+description: Sync this project's LLM context (memory, skills, instructions, handoff)
+argument-hint: "push | pull | status"
+allowed-tools: Bash(npx @tricknowtech/context:*), Read, Write
+---
+
+Run the context-sync action requested in: $ARGUMENTS
+(If no argument was given, treat it as \`status\`.)
+
+## push
+
+1. Write a handoff summary of THIS conversation to \`.contextsync/handoff.json\`.
+   Use exactly this shape \u2014 it is read back verbatim on the other device:
+
+   \`\`\`json
+   {
+     "updatedAt": "<ISO 8601 timestamp>",
+     "goal": "<what this session set out to achieve, one or two sentences>",
+     "decisions": ["<decisions already made, so they aren't re-litigated>"],
+     "openThreads": ["<work explicitly left unfinished>"],
+     "filesTouched": ["<repo-relative paths changed this session>"],
+     "nextStep": "<the single next action someone should take>",
+     "notes": "<anything else worth carrying over; optional>"
+   }
+   \`\`\`
+
+   Be specific and factual. Write what was actually decided and actually left
+   open \u2014 a vague handoff is worse than none, because it reads as progress.
+   Never put credentials, tokens, or .env values in any field.
+
+2. Then run: \`npx @tricknowtech/context push\`
+
+3. Report what was synced. If the push was refused for possible secrets, show
+   the findings and STOP \u2014 do not re-run with \`--allow-secrets\` unless the
+   user explicitly tells you the hits are false positives.
+
+## pull
+
+1. Run: \`npx @tricknowtech/context pull\`
+2. Read \`.contextsync/handoff.json\` and summarize for the user, out loud:
+   the goal, what was decided, what is still open, and the next step.
+3. If any files were skipped as conflicting, list them and ask before forcing.
+
+## status
+
+Run: \`npx @tricknowtech/context status\` and summarize the result.
+`;
+function installSlashCommand(projectRoot) {
+  const dest = import_node_path4.default.join(projectRoot, SLASH_COMMAND_PATH);
+  if (import_node_fs4.default.existsSync(dest)) return { path: SLASH_COMMAND_PATH, written: false };
+  ensureDir(import_node_path4.default.dirname(dest));
+  import_node_fs4.default.writeFileSync(dest, SLASH_COMMAND_BODY, "utf8");
+  return { path: SLASH_COMMAND_PATH, written: true };
+}
+function ensureGitignoreEntries(projectRoot, artifactsEnabled) {
+  const gitignore = import_node_path4.default.join(projectRoot, ".gitignore");
+  const wanted = [".contextsync/transcripts/"];
+  if (!artifactsEnabled) wanted.push(".contextsync/artifacts/");
+  let existing = "";
+  try {
+    existing = import_node_fs4.default.readFileSync(gitignore, "utf8");
+  } catch {
+  }
+  const lines = new Set(existing.split("\n").map((l) => l.trim()));
+  const missing = wanted.filter((w) => !lines.has(w));
+  if (missing.length === 0) return [];
+  const prefix = existing.length > 0 && !existing.endsWith("\n") ? "\n" : "";
+  import_node_fs4.default.appendFileSync(
+    gitignore,
+    `${prefix}
+# tricknowtech context-sync \u2014 never commit these tiers
+${missing.join("\n")}
+`,
+    "utf8"
+  );
+  return missing;
+}
+
+// src/secrets.ts
+var import_node_fs5 = __toESM(require("fs"), 1);
+var BENIGN_KEY = /(?:^|[_-])(?:input|output|prompt|completion|total|max|min|num|new|cache|cached|remaining|used|count|context|window|budget|estimated?)[_-]?tokens?$|tokens?[_-]?(?:count|used|limit|remaining|in|out|usage|per|budget)$/i;
+function looksLikeCredential(value) {
+  if (/^[A-Za-z_$][\w$]*(?:\.[A-Za-z_$][\w$]*)+$/.test(value)) return false;
+  if (/^[A-Za-z][A-Za-z_]*$/.test(value) && value.length < 24) return false;
+  const classes = [/[a-z]/, /[A-Z]/, /[0-9]/, /[_\-+/=]/].filter((re) => re.test(value)).length;
+  return classes >= 2;
+}
+var RULES = [
+  { name: "private-key-block", re: /-----BEGIN (?:RSA |EC |DSA |OPENSSH |PGP )?PRIVATE KEY-----/ },
+  { name: "aws-access-key-id", re: /\b(?:AKIA|ASIA)[0-9A-Z]{16}\b/ },
+  { name: "github-token", re: /\bgh[pousr]_[A-Za-z0-9]{36,}\b/ },
+  { name: "slack-token", re: /\bxox[baprs]-[A-Za-z0-9-]{10,}\b/ },
+  { name: "stripe-live-key", re: /\b[sr]k_live_[A-Za-z0-9]{16,}\b/ },
+  { name: "razorpay-live-key", re: /\brzp_live_[A-Za-z0-9]{10,}\b/ },
+  { name: "google-api-key", re: /\bAIza[0-9A-Za-z_-]{35}\b/ },
+  { name: "jwt", re: /\beyJ[A-Za-z0-9_-]{10,}\.eyJ[A-Za-z0-9_-]{10,}\.[A-Za-z0-9_-]{10,}\b/ },
+  // Tricknowtech's own public-API key formats — esk_/wak_/fak_ are live
+  // credentials for a customer's account, and csk_ will be ours.
+  { name: "tricknowtech-api-key", re: /\b(?:esk|wak|fak|csk)_[a-f0-9]{40,}\b/ },
+  // Connection strings carrying an inline password.
+  { name: "db-url-with-password", re: /\b[a-z][a-z0-9+.-]*:\/\/[^\s:/@]+:[^\s:/@]{4,}@[^\s/]+/ },
+  // Generic `SOMETHING_SECRET=value` / `"apiKey": "value"` assignments.
+  // The value charset deliberately excludes brackets and whitespace so that
+  // `tokens: data.get(...)` truncates to a short identifier and falls out.
+  {
+    name: "assigned-secret",
+    re: /\b([A-Za-z0-9_]*(?:SECRET|PASSWORD|PASSWD|TOKEN|API[_-]?KEY|APIKEY|ACCESS[_-]?KEY|PRIVATE[_-]?KEY|CREDENTIAL|AUTH)[A-Za-z0-9_]*)["']?\s*[:=]\s*["']?([A-Za-z0-9_\-+/=.]{8,})/i,
+    accept: (m) => !BENIGN_KEY.test(m[1]) && looksLikeCredential(m[2])
+  }
+];
+var PLACEHOLDER = /^(?:x{3,}|\.{3,}|-+|_+|\$\{.*\}|<.*>|\{\{.*\}\}|change[_-]?me|your[_-].*|placeholder|example|dummy|sample|redacted|null|true|false|undefined|test|password|secret|token)$/i;
+function isPlaceholder(value) {
+  if (PLACEHOLDER.test(value)) return true;
+  return new Set(value).size <= 2;
+}
+function mask(value) {
+  const trimmed = value.trim();
+  if (trimmed.length <= 8) return "*".repeat(trimmed.length);
+  return `${trimmed.slice(0, 4)}${"*".repeat(Math.min(12, trimmed.length - 8))}${trimmed.slice(-4)}`;
+}
+function looksBinary(buf) {
+  const n = Math.min(buf.length, 1024);
+  for (let i = 0; i < n; i++) {
+    if (buf[i] === 0) return true;
+  }
+  return false;
+}
+var MAX_SCAN_BYTES = 5 * 1024 * 1024;
+function scanFiles(files) {
+  const hits = [];
+  for (const file of files) {
+    let buf;
+    try {
+      buf = import_node_fs5.default.readFileSync(file.sourcePath);
+    } catch {
+      continue;
+    }
+    if (looksBinary(buf)) continue;
+    const text = buf.subarray(0, MAX_SCAN_BYTES).toString("utf8");
+    const lines = text.split("\n");
+    for (let i = 0; i < lines.length; i++) {
+      const line = lines[i];
+      if (line.length > 4e3) continue;
+      for (const rule of RULES) {
+        const m = rule.re.exec(line);
+        if (!m) continue;
+        if (rule.accept && !rule.accept(m)) continue;
+        const captured = m[m.length - 1] ?? m[0];
+        if (isPlaceholder(captured)) continue;
+        hits.push({
+          storePath: file.storePath,
+          line: i + 1,
+          rule: rule.name,
+          preview: mask(captured)
+        });
+        break;
+      }
+    }
+  }
+  return hits;
+}
+function formatHits(hits) {
+  const shown = hits.slice(0, 20);
+  const lines = shown.map((h) => `  ${h.storePath}:${h.line}  [${h.rule}]  ${h.preview}`);
+  if (hits.length > shown.length) {
+    lines.push(`  \u2026 and ${hits.length - shown.length} more`);
+  }
+  return lines.join("\n");
+}
+
+// src/store.ts
+var import_node_fs6 = __toESM(require("fs"), 1);
+var import_node_path5 = __toESM(require("path"), 1);
+var MANIFEST_FILE = "manifest.json";
+var LocalStore = class {
+  constructor(projectRoot) {
+    this.projectRoot = projectRoot;
+  }
+  projectRoot;
+  get dir() {
+    return storeDir(this.projectRoot);
+  }
+  write(files, projectRoot) {
+    for (const name of import_node_fs6.default.existsSync(this.dir) ? import_node_fs6.default.readdirSync(this.dir) : []) {
+      if (name === "config.json" || name === HANDOFF_FILE) continue;
+      import_node_fs6.default.rmSync(import_node_path5.default.join(this.dir, name), { recursive: true, force: true });
+    }
+    const entries = [];
+    for (const file of files) {
+      const dest = import_node_path5.default.join(this.dir, file.storePath);
+      try {
+        copyFile(file.sourcePath, dest);
+      } catch {
+        continue;
+      }
+      entries.push({
+        storePath: file.storePath,
+        restoreTemplate: file.restoreTemplate,
+        tier: file.tier,
+        sourceRoot: file.sourceRoot,
+        size: file.size
+      });
+    }
+    entries.sort((a, b) => a.storePath.localeCompare(b.storePath));
+    const manifest = {
+      version: 1,
+      updatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      writtenFrom: projectRoot,
+      entries
+    };
+    writeJson(import_node_path5.default.join(this.dir, MANIFEST_FILE), manifest);
+    return manifest;
+  }
+  readManifest() {
+    return readJson(import_node_path5.default.join(this.dir, MANIFEST_FILE));
+  }
+  restore(ctx, opts = {}) {
+    const manifest = this.readManifest();
+    const restored = [];
+    const skipped = [];
+    if (!manifest) return { restored, skipped };
+    for (const entry of manifest.entries) {
+      const src = import_node_path5.default.join(this.dir, entry.storePath);
+      if (!import_node_fs6.default.existsSync(src)) continue;
+      const dest = resolveTemplate(entry.restoreTemplate, ctx);
+      if (!opts.force && import_node_fs6.default.existsSync(dest)) {
+        try {
+          if (!import_node_fs6.default.readFileSync(dest).equals(import_node_fs6.default.readFileSync(src))) {
+            skipped.push(entry.storePath);
+            continue;
+          }
+        } catch {
+          skipped.push(entry.storePath);
+          continue;
+        }
+      }
+      try {
+        ensureDir(import_node_path5.default.dirname(dest));
+        import_node_fs6.default.copyFileSync(src, dest);
+        restored.push(entry.storePath);
+      } catch {
+        skipped.push(entry.storePath);
+      }
+    }
+    return { restored, skipped };
+  }
+  readHandoff() {
+    return readJson(import_node_path5.default.join(this.dir, HANDOFF_FILE));
+  }
+  writeHandoff(handoff) {
+    writeJson(import_node_path5.default.join(this.dir, HANDOFF_FILE), handoff);
+  }
+};
+
+// src/types.ts
+var ALL_TIERS = ["core", "handoff", "artifacts", "transcripts"];
+var LOCAL_TIERS = ["core", "handoff", "artifacts"];
+
+// src/commands.ts
+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 ${import_node_path6.default.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   ${import_node_path6.default.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 ${import_node_path6.default.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 ${import_node_path6.default.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    ${import_node_path6.default.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 !import_node_fs7.default.readFileSync(import_node_path6.default.join(storeDir(root), k)).equals(import_node_fs7.default.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);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  run
+});