@tricknowtech/context 0.1.0

package/dist/chunk-DEH5MUFT.js

@@ -0,0 +1,620 @@
+// src/fsutil.ts
+import { execFileSync } from "child_process";
+import fs from "fs";
+import os from "os";
+import path from "path";
+function userClaudeDir() {
+  return process.env.CLAUDE_CONFIG_DIR ?? path.join(os.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 out = absPath;
+  for (const [root, token] of candidates) {
+    if (absPath === root || absPath.startsWith(root + path.sep)) {
+      out = token + "/" + toPosix(path.relative(root, absPath));
+      break;
+    }
+  }
+  return ctx.cwdKey ? out.split(ctx.cwdKey).join("{cwdKey}") : out;
+}
+function resolveTemplate(template, ctx) {
+  const expanded = template.split("{userClaude}").join(ctx.userClaude).split("{project}").join(ctx.project).split("{cwdKey}").join(ctx.cwdKey);
+  return path.normalize(expanded);
+}
+function toPosix(p) {
+  return p.split(path.sep).join("/");
+}
+function gitTrackedSet(root) {
+  try {
+    const out = 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 out.split("\0")) {
+      if (rel) set.add(path.resolve(root, rel));
+    }
+    return set;
+  } catch {
+    return /* @__PURE__ */ new Set();
+  }
+}
+function isGitRepo(root) {
+  try {
+    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 out = [];
+  if (!fs.existsSync(root)) return out;
+  const stack = [root];
+  while (stack.length > 0) {
+    const dir = stack.pop();
+    let entries;
+    try {
+      entries = fs.readdirSync(dir, { withFileTypes: true });
+    } catch {
+      continue;
+    }
+    for (const entry of entries) {
+      const abs = path.join(dir, entry.name);
+      const rel = toPosix(path.relative(root, abs));
+      if (matchesAny(rel, exclude)) continue;
+      if (entry.isDirectory()) {
+        stack.push(abs);
+      } else if (entry.isFile()) {
+        if (out.length >= maxFiles) return out;
+        out.push(abs);
+      }
+    }
+  }
+  return out;
+}
+function ensureDir(dir) {
+  fs.mkdirSync(dir, { recursive: true });
+}
+function readJson(file) {
+  try {
+    return JSON.parse(fs.readFileSync(file, "utf8"));
+  } catch {
+    return null;
+  }
+}
+function writeJson(file, value) {
+  ensureDir(path.dirname(file));
+  fs.writeFileSync(file, JSON.stringify(value, null, 2) + "\n", "utf8");
+}
+function copyFile(from, to) {
+  ensureDir(path.dirname(to));
+  fs.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
+import crypto from "crypto";
+import fs2 from "fs";
+import path2 from "path";
+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: crypto.randomUUID(),
+    name: path2.basename(projectRoot),
+    rootHint: projectRoot,
+    tiers: ["core", "handoff"],
+    artifactPaths: ["graphify-out"],
+    exclude: [...DEFAULT_EXCLUDE],
+    remotes: {}
+  };
+}
+function findProjectRoot(start = process.cwd()) {
+  let dir = path2.resolve(start);
+  for (; ; ) {
+    if (fs2.existsSync(path2.join(dir, STORE_DIR, CONFIG_FILE))) return dir;
+    if (fs2.existsSync(path2.join(dir, ".git"))) return dir;
+    const parent = path2.dirname(dir);
+    if (parent === dir) return null;
+    dir = parent;
+  }
+}
+function storeDir(projectRoot) {
+  return path2.join(projectRoot, STORE_DIR);
+}
+function configPath(projectRoot) {
+  return path2.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
+import fs3 from "fs";
+import path3 from "path";
+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(out, sourcePath, storePath, tier, sourceRoot, ctx) {
+  let size = 0;
+  try {
+    size = fs3.statSync(sourcePath).size;
+  } catch {
+    return;
+  }
+  out.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(path3.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 = path3.join(userClaude, "projects", key, "memory");
+    for (const abs of walk(memoryDir, { exclude })) {
+      const rel = toPosix(path3.relative(memoryDir, abs));
+      push(files, abs, `memory/${rel}`, "core", "user", ctx);
+    }
+    const skillsDir = path3.join(userClaude, "skills");
+    for (const abs of walk(skillsDir, { exclude })) {
+      const rel = toPosix(path3.relative(skillsDir, abs));
+      push(files, abs, `skills/${rel}`, "core", "user", ctx);
+    }
+    const agentsDir = path3.join(userClaude, "agents");
+    for (const abs of walk(agentsDir, { exclude })) {
+      const rel = toPosix(path3.relative(agentsDir, abs));
+      push(files, abs, `agents/${rel}`, "core", "user", ctx);
+    }
+    for (const name of ["CLAUDE.md", "settings.json"]) {
+      const abs = path3.join(userClaude, name);
+      if (fs3.existsSync(abs)) push(files, abs, `user/${name}`, "core", "user", ctx);
+    }
+  }
+  if (tiers.includes("artifacts")) {
+    for (const relDir of cfg.artifactPaths) {
+      const absDir = path3.join(projectRoot, relDir);
+      for (const abs of walk(absDir, { exclude })) {
+        const rel = toPosix(path3.relative(absDir, abs));
+        push(files, abs, `artifacts/${relDir}/${rel}`, "artifacts", "project", ctx);
+      }
+    }
+  }
+  if (tiers.includes("transcripts")) {
+    const projDir = path3.join(userClaude, "projects", key);
+    for (const abs of walk(projDir, { exclude })) {
+      const rel = toPosix(path3.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 out = {
+    core: { ...empty },
+    handoff: { ...empty },
+    artifacts: { ...empty },
+    transcripts: { ...empty }
+  };
+  for (const f of files) {
+    out[f.tier].count++;
+    out[f.tier].bytes += f.size;
+  }
+  return out;
+}
+
+// src/scaffold.ts
+import fs4 from "fs";
+import path4 from "path";
+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 = path4.join(projectRoot, SLASH_COMMAND_PATH);
+  if (fs4.existsSync(dest)) return { path: SLASH_COMMAND_PATH, written: false };
+  ensureDir(path4.dirname(dest));
+  fs4.writeFileSync(dest, SLASH_COMMAND_BODY, "utf8");
+  return { path: SLASH_COMMAND_PATH, written: true };
+}
+function ensureGitignoreEntries(projectRoot, artifactsEnabled) {
+  const gitignore = path4.join(projectRoot, ".gitignore");
+  const wanted = [".contextsync/transcripts/"];
+  if (!artifactsEnabled) wanted.push(".contextsync/artifacts/");
+  let existing = "";
+  try {
+    existing = fs4.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" : "";
+  fs4.appendFileSync(
+    gitignore,
+    `${prefix}
+# tricknowtech context-sync \u2014 never commit these tiers
+${missing.join("\n")}
+`,
+    "utf8"
+  );
+  return missing;
+}
+
+// src/secrets.ts
+import fs5 from "fs";
+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 = fs5.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
+import fs6 from "fs";
+import path5 from "path";
+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 fs6.existsSync(this.dir) ? fs6.readdirSync(this.dir) : []) {
+      if (name === "config.json" || name === HANDOFF_FILE) continue;
+      fs6.rmSync(path5.join(this.dir, name), { recursive: true, force: true });
+    }
+    const entries = [];
+    for (const file of files) {
+      const dest = path5.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(path5.join(this.dir, MANIFEST_FILE), manifest);
+    return manifest;
+  }
+  readManifest() {
+    return readJson(path5.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 = path5.join(this.dir, entry.storePath);
+      if (!fs6.existsSync(src)) continue;
+      const dest = resolveTemplate(entry.restoreTemplate, ctx);
+      if (!opts.force && fs6.existsSync(dest)) {
+        try {
+          if (!fs6.readFileSync(dest).equals(fs6.readFileSync(src))) {
+            skipped.push(entry.storePath);
+            continue;
+          }
+        } catch {
+          skipped.push(entry.storePath);
+          continue;
+        }
+      }
+      try {
+        ensureDir(path5.dirname(dest));
+        fs6.copyFileSync(src, dest);
+        restored.push(entry.storePath);
+      } catch {
+        skipped.push(entry.storePath);
+      }
+    }
+    return { restored, skipped };
+  }
+  readHandoff() {
+    return readJson(path5.join(this.dir, HANDOFF_FILE));
+  }
+  writeHandoff(handoff) {
+    writeJson(path5.join(this.dir, HANDOFF_FILE), handoff);
+  }
+};
+
+// src/types.ts
+var ALL_TIERS = ["core", "handoff", "artifacts", "transcripts"];
+var LOCAL_TIERS = ["core", "handoff", "artifacts"];
+
+export {
+  userClaudeDir,
+  cwdKey,
+  makeTemplate,
+  resolveTemplate,
+  gitTrackedSet,
+  isGitRepo,
+  matchesAny,
+  walk,
+  formatBytes,
+  STORE_DIR,
+  CONFIG_FILE,
+  HANDOFF_FILE,
+  HARD_DENY,
+  DEFAULT_EXCLUDE,
+  defaultConfig,
+  findProjectRoot,
+  storeDir,
+  configPath,
+  loadConfig,
+  saveConfig,
+  collect,
+  summarize,
+  SLASH_COMMAND_PATH,
+  SLASH_COMMAND_BODY,
+  installSlashCommand,
+  ensureGitignoreEntries,
+  scanFiles,
+  formatHits,
+  MANIFEST_FILE,
+  LocalStore,
+  ALL_TIERS,
+  LOCAL_TIERS
+};