@hizliemre/horse-code 0.1.0

package/dist/chunk-PGOYDOI4.js

@@ -0,0 +1,426 @@
+import {
+  stateRoot,
+  writableStateRoot
+} from "./chunk-SSDLHWSF.js";
+import {
+  writeAtomic
+} from "./chunk-B67BK5GQ.js";
+
+// src/engine/project-graph.ts
+import { readFile, stat } from "fs/promises";
+import { existsSync, readFileSync, statSync } from "fs";
+import { spawn } from "child_process";
+import { join } from "path";
+var GRAPH_DIR = "graphify-out";
+var GRAPH_FILE = "graph.json";
+var STAMP_FILE = ".graph-commit.json";
+function stampPath(cwd) {
+  return join(cwd, GRAPH_DIR, STAMP_FILE);
+}
+async function readStamp(cwd) {
+  try {
+    const raw = JSON.parse(await readFile(stampPath(cwd), "utf8"));
+    return typeof raw.commit === "string" && raw.commit ? raw : void 0;
+  } catch {
+    return void 0;
+  }
+}
+function git(cwd, args) {
+  return new Promise((resolve) => {
+    const child = spawn("git", args, { cwd, stdio: ["ignore", "pipe", "ignore"] });
+    let out = "";
+    child.stdout.on("data", (d) => {
+      if (out.length < 4e6) out += d.toString();
+    });
+    child.on("error", () => resolve(""));
+    child.on("close", (c) => resolve(c === 0 ? out : ""));
+  });
+}
+async function changedSince(cwd, commit) {
+  const known = await git(cwd, ["cat-file", "-e", `${commit}^{commit}`]);
+  if (known === void 0) return void 0;
+  const reachable = await git(cwd, ["rev-parse", "--verify", "--quiet", `${commit}^{commit}`]);
+  if (!reachable.trim()) return void 0;
+  const committed = await git(cwd, ["diff", "--name-only", `${commit}`, "HEAD"]);
+  const working = await git(cwd, ["status", "--porcelain", "--untracked-files=all"]);
+  const dirty = working.split("\n").map((l) => l.slice(3).trim()).filter(Boolean);
+  return [.../* @__PURE__ */ new Set([...committed.split("\n").filter(Boolean), ...dirty])];
+}
+var LABELS_FILE = ".graphify_labels.json";
+function graphPath(cwd) {
+  return join(cwd, GRAPH_DIR, GRAPH_FILE);
+}
+function labelsPath(cwd) {
+  return join(cwd, GRAPH_DIR, LABELS_FILE);
+}
+function areaOf(g, n) {
+  return n?.community === void 0 ? void 0 : g.areas.get(n.community);
+}
+var UNNAMED = /^community[\s_-]*\d+$/i;
+function parseAreas(raw) {
+  const out = /* @__PURE__ */ new Map();
+  if (!raw) return out;
+  try {
+    const doc = JSON.parse(raw);
+    if (typeof doc !== "object" || doc === null || Array.isArray(doc)) return out;
+    for (const [k, v] of Object.entries(doc)) {
+      const id = Number(k);
+      if (!Number.isInteger(id) || typeof v !== "string") continue;
+      const name = v.trim();
+      if (name && !UNNAMED.test(name)) out.set(id, name);
+    }
+  } catch {
+  }
+  return out;
+}
+function parseGraph(raw, labelsRaw) {
+  let doc;
+  try {
+    doc = JSON.parse(raw);
+  } catch {
+    return void 0;
+  }
+  const rawNodes = Array.isArray(doc.nodes) ? doc.nodes : [];
+  const rawEdges = Array.isArray(doc.links) ? doc.links : Array.isArray(doc.edges) ? doc.edges : [];
+  const nodes = rawNodes.filter((n) => typeof n === "object" && n !== null && typeof n.id === "string");
+  const edges = rawEdges.filter((e) => typeof e === "object" && e !== null && typeof e.source === "string" && typeof e.target === "string");
+  const byId = new Map(nodes.map((n) => [n.id, n]));
+  const incident = /* @__PURE__ */ new Map();
+  for (const e of edges) {
+    for (const end of [e.source, e.target]) {
+      const list = incident.get(end);
+      if (list) list.push(e);
+      else incident.set(end, [e]);
+    }
+  }
+  return { nodes, edges, byId, incident, areas: parseAreas(labelsRaw) };
+}
+async function pruneAreaNames(cwd) {
+  const path = labelsPath(cwd);
+  let labels;
+  try {
+    const doc = JSON.parse(await readFile(path, "utf8"));
+    if (typeof doc !== "object" || doc === null || Array.isArray(doc)) return 0;
+    labels = doc;
+  } catch {
+    return 0;
+  }
+  const graph = await loadGraph(cwd);
+  if (!graph) return 0;
+  const live = /* @__PURE__ */ new Set();
+  for (const n of graph.nodes) if (n.community !== void 0) live.add(n.community);
+  if (!live.size) return 0;
+  const kept = Object.keys(labels).filter((k) => live.has(Number(k)));
+  if (kept.length === Object.keys(labels).length) return 0;
+  const ordered = {};
+  for (const k of kept.sort((a, b) => Number(a) - Number(b))) ordered[k] = labels[k];
+  await writeAtomic(path, `${JSON.stringify(ordered, null, 2)}
+`);
+  return Object.keys(labels).length - kept.length;
+}
+async function loadGraph(cwd) {
+  try {
+    const labels = await readFile(labelsPath(cwd), "utf8").catch(() => void 0);
+    return parseGraph(await readFile(graphPath(cwd), "utf8"), labels);
+  } catch {
+    return void 0;
+  }
+}
+function graphRoot(cwd) {
+  const root = stateRoot(cwd);
+  return existsSync(join(root, GRAPH_DIR, GRAPH_FILE)) ? root : void 0;
+}
+var cache = /* @__PURE__ */ new Map();
+function stampOf(path) {
+  try {
+    const st = statSync(path);
+    return `${st.mtimeMs}:${st.size}`;
+  } catch {
+    return "";
+  }
+}
+function loadGraphSync(cwd) {
+  const root = graphRoot(cwd);
+  if (root === void 0) return void 0;
+  const path = graphPath(root);
+  const labels = labelsPath(root);
+  try {
+    const stamp = `${stampOf(path)}|${stampOf(labels)}`;
+    const hit = cache.get(path);
+    if (hit && hit.stamp === stamp) return hit.graph;
+    let labelsRaw;
+    try {
+      labelsRaw = readFileSync(labels, "utf8");
+    } catch {
+    }
+    const graph = parseGraph(readFileSync(path, "utf8"), labelsRaw);
+    cache.set(path, { stamp, graph });
+    return graph;
+  } catch {
+    return void 0;
+  }
+}
+var CODE_EXT = /\.(ts|tsx|js|jsx|mjs|cjs|py|go|rs|java|rb|c|h|cc|cpp|hpp|cs|php|swift|kt|scala)$/;
+var NOT_INDEXED = /(^|\/)(dist|build|out|node_modules|vendor|coverage|graphify-out|\.[^/]+)\//;
+var MAX_STALE_CHECK = 5e3;
+function gitFiles(cwd) {
+  return new Promise((resolve) => {
+    const child = spawn("git", ["ls-files", "--cached", "--others", "--exclude-standard"], { cwd, stdio: ["ignore", "pipe", "ignore"] });
+    let out = "";
+    child.stdout.on("data", (d) => {
+      if (out.length < 4e6) out += d.toString();
+    });
+    child.on("error", () => resolve([]));
+    child.on("close", (c) => resolve(c === 0 ? out.split("\n").filter(Boolean) : []));
+  });
+}
+async function graphStatus(cwd) {
+  const path = graphPath(cwd);
+  if (!existsSync(path)) return { built: false, nodes: 0, edges: 0, stale: false, staleBecause: [] };
+  const [g, st] = await Promise.all([loadGraph(cwd), stat(path).catch(() => void 0)]);
+  const builtAt = st?.mtimeMs;
+  const staleBecause = [];
+  const known = /* @__PURE__ */ new Set();
+  for (const n of g?.nodes ?? []) if (n.source_file) known.add(n.source_file);
+  const counts = (f) => !NOT_INDEXED.test(f) && (known.has(f) || CODE_EXT.test(f));
+  const stamp = await readStamp(cwd);
+  if (stamp) {
+    const changed = await changedSince(cwd, stamp.commit);
+    if (changed) {
+      for (const f of changed) {
+        if (staleBecause.length >= 3) break;
+        if (counts(f)) staleBecause.push(f);
+      }
+      return {
+        built: true,
+        nodes: g?.nodes.length ?? 0,
+        edges: g?.edges.length ?? 0,
+        ...builtAt !== void 0 && { builtAt },
+        stale: staleBecause.length > 0,
+        staleBecause
+      };
+    }
+  }
+  if (builtAt !== void 0) {
+    const listed = await gitFiles(cwd);
+    const candidates = listed.filter(counts).slice(0, MAX_STALE_CHECK);
+    for (const f of candidates) {
+      if (staleBecause.length >= 3) break;
+      try {
+        const s = await stat(join(cwd, f));
+        if (s.mtimeMs > builtAt) staleBecause.push(f);
+      } catch {
+      }
+    }
+  }
+  return {
+    built: true,
+    nodes: g?.nodes.length ?? 0,
+    edges: g?.edges.length ?? 0,
+    ...builtAt !== void 0 && { builtAt },
+    stale: staleBecause.length > 0,
+    staleBecause
+  };
+}
+async function graphifyPython() {
+  const shim = await which("graphify");
+  if (shim) {
+    try {
+      const first = (await readFile(shim, "utf8")).split("\n", 1)[0];
+      const m = /^#!\s*(\S+)/.exec(first);
+      if (m && existsSync(m[1])) return m[1];
+    } catch {
+    }
+  }
+  const py = await which("python3");
+  if (!py) return void 0;
+  return (await run(py, ["-c", "import graphify"])).code === 0 ? py : void 0;
+}
+function which(cmd) {
+  return new Promise((resolve) => {
+    const child = spawn("sh", ["-c", `command -v ${cmd}`], { stdio: ["ignore", "pipe", "ignore"] });
+    let out = "";
+    child.stdout.on("data", (d) => out += d.toString());
+    child.on("error", () => resolve(void 0));
+    child.on("close", (c) => resolve(c === 0 && out.trim() ? out.trim() : void 0));
+  });
+}
+var BUILD_IDLE_TIMEOUT_MS = 3e5;
+function run(cmd, args, cwd, idleMs = BUILD_IDLE_TIMEOUT_MS) {
+  return new Promise((resolve) => {
+    const child = spawn(cmd, args, { ...cwd ? { cwd } : {}, stdio: ["ignore", "pipe", "pipe"] });
+    let out = "";
+    let timedOut = false;
+    let timer;
+    const arm = () => {
+      clearTimeout(timer);
+      timer = setTimeout(() => {
+        timedOut = true;
+        child.kill("SIGKILL");
+      }, idleMs);
+    };
+    const take = (d) => {
+      arm();
+      if (out.length < 2e5) out += d.toString();
+    };
+    arm();
+    child.stdout.on("data", take);
+    child.stderr.on("data", take);
+    child.on("error", (e) => {
+      clearTimeout(timer);
+      resolve({ code: 1, out: e.message });
+    });
+    child.on("close", (c) => {
+      clearTimeout(timer);
+      resolve({ code: c ?? 1, out, timedOut });
+    });
+  });
+}
+function failureReason(out) {
+  const lines = out.split("\n").map((l) => l.trim()).filter(Boolean);
+  const diagnostic = lines.filter((l) => /(Traceback|Error|error:|Exception|No such file|Permission denied|MemoryError|Killed)/.test(l) && !/AST extraction:/.test(l));
+  const pick = diagnostic.length ? diagnostic.slice(-3) : lines.slice(-3);
+  return pick.join(" ").slice(0, 300);
+}
+function pruneTooling(doc, alsoDrop = /* @__PURE__ */ new Set()) {
+  const nodes = Array.isArray(doc.nodes) ? doc.nodes : [];
+  const keep = nodes.filter((n) => {
+    const f = typeof n.source_file === "string" ? n.source_file : "";
+    return !f || !NOT_INDEXED.test(f) && !alsoDrop.has(f);
+  });
+  const removed = nodes.length - keep.length;
+  if (!removed) return { removed: 0, kept: nodes.length };
+  const ids = new Set(keep.map((n) => String(n.id)));
+  doc.nodes = keep;
+  for (const key of ["links", "edges"]) {
+    const list = doc[key];
+    if (!Array.isArray(list)) continue;
+    doc[key] = list.filter((e) => ids.has(String(e.source)) && ids.has(String(e.target)));
+  }
+  return { removed, kept: keep.length };
+}
+async function writtenTracePaths(cwd) {
+  const out = /* @__PURE__ */ new Set();
+  try {
+    const { loadTraceIndex, traceRootRel } = await import("./trace-ZMB7LT7W.js");
+    const index = await loadTraceIndex(cwd);
+    const root = traceRootRel().replace(/\\/g, "/");
+    for (const [file, rec] of Object.entries(index.traces)) {
+      if (!rec.doc) out.add(`${root}/${file}.md`);
+    }
+  } catch {
+  }
+  return out;
+}
+var LABEL_LOSS_LIMIT = 0.25;
+function namedCount(doc) {
+  return Object.values(doc).filter((v) => !(typeof v === "string" && UNNAMED.test(v.trim()))).length;
+}
+async function restoreSharedLabels(cwd) {
+  try {
+    await git(cwd, ["checkout", "--", `${GRAPH_DIR}/${LABELS_FILE}`]);
+  } catch {
+  }
+}
+async function buildProjectGraph(cwd) {
+  const py = await graphifyPython();
+  if (!py) {
+    return {
+      ok: false,
+      message: "graphify is not installed. `uv tool install graphifyy` (or `pipx install graphifyy`) \u2014 it is MIT, pure AST parsing, and costs no tokens."
+    };
+  }
+  const shared = writableStateRoot(cwd) === void 0;
+  if (shared) await restoreSharedLabels(cwd);
+  try {
+    return await runGraphBuild(py, cwd, shared);
+  } finally {
+    if (shared) await restoreSharedLabels(cwd);
+  }
+}
+async function runGraphBuild(py, cwd, shared) {
+  const script = "from graphify.watch import _rebuild_code\nfrom pathlib import Path\nimport sys\nsys.exit(0 if _rebuild_code(Path('.')) else 1)\n";
+  const r = await run(py, ["-c", script], cwd);
+  if (r.timedOut) {
+    return {
+      ok: false,
+      message: `Graph build stopped: it produced no output for ${Math.round(BUILD_IDLE_TIMEOUT_MS / 6e4)} minutes and was killed. Last it said: ${failureReason(r.out)}`
+    };
+  }
+  if (r.code !== 0) return { ok: false, message: `Graph build failed: ${failureReason(r.out)}` };
+  let pruned = 0;
+  try {
+    const path = graphPath(cwd);
+    const doc = JSON.parse(await readFile(path, "utf8"));
+    const res = pruneTooling(doc, await writtenTracePaths(cwd));
+    if (res.removed) {
+      await writeAtomic(path, JSON.stringify(doc));
+      pruned = res.removed;
+    }
+  } catch {
+  }
+  try {
+    const head = (await git(cwd, ["rev-parse", "HEAD"])).trim();
+    if (head) await writeAtomic(stampPath(cwd), `${JSON.stringify({ commit: head })}
+`);
+  } catch {
+  }
+  let lost = 0;
+  if (!shared) {
+    try {
+      const lp = labelsPath(cwd);
+      const doc = JSON.parse(await readFile(lp, "utf8"));
+      const head = await git(cwd, ["show", `HEAD:${GRAPH_DIR}/${LABELS_FILE}`]).catch(() => "");
+      const before = head ? namedCount(JSON.parse(head)) : 0;
+      const after = namedCount(doc);
+      if (before && after < before * (1 - LABEL_LOSS_LIMIT)) {
+        await restoreSharedLabels(cwd);
+        lost = before - after;
+      } else {
+        const named = Object.fromEntries(Object.entries(doc).filter(([, v]) => !(typeof v === "string" && UNNAMED.test(v.trim()))));
+        if (Object.keys(doc).length !== Object.keys(named).length) {
+          const ordered = {};
+          for (const k of Object.keys(named).sort((a, b) => Number(a) - Number(b))) ordered[k] = named[k];
+          await writeAtomic(lp, `${JSON.stringify(ordered, null, 2)}
+`);
+        }
+      }
+    } catch {
+    }
+  }
+  const g = await loadGraph(cwd);
+  return {
+    ok: true,
+    message: `Graph built: ${g?.nodes.length ?? 0} nodes, ${g?.edges.length ?? 0} edges.` + (pruned ? ` (${pruned.toLocaleString("en-US")} tooling node(s) left out \u2014 skills and agent state are not the project.)` : "") + (lost ? ` (Community names kept as they were: this build named ${lost.toLocaleString("en-US")} fewer than the committed file, which is damage rather than progress. Re-run \`/graph build\` when the build can finish uninterrupted.)` : ""),
+    nodes: g?.nodes.length ?? 0,
+    edges: g?.edges.length ?? 0
+  };
+}
+
+export {
+  GRAPH_DIR,
+  GRAPH_FILE,
+  STAMP_FILE,
+  stampPath,
+  readStamp,
+  changedSince,
+  LABELS_FILE,
+  graphPath,
+  labelsPath,
+  areaOf,
+  parseAreas,
+  parseGraph,
+  pruneAreaNames,
+  loadGraph,
+  graphRoot,
+  loadGraphSync,
+  MAX_STALE_CHECK,
+  graphStatus,
+  graphifyPython,
+  BUILD_IDLE_TIMEOUT_MS,
+  failureReason,
+  pruneTooling,
+  LABEL_LOSS_LIMIT,
+  namedCount,
+  buildProjectGraph
+};

package/dist/chunk-QF4MP6BS.js

@@ -0,0 +1,69 @@
+import {
+  patchConfig
+} from "./chunk-H2FDGPVW.js";
+
+// src/engine/main-branch.ts
+import { readFile } from "fs/promises";
+import { join } from "path";
+var COMMON_MAIN_BRANCHES = ["main", "master", "development", "develop", "trunk"];
+async function recordedMainBranch(cwd) {
+  try {
+    const raw = await readFile(join(cwd, ".horsecode", "config.json"), "utf8");
+    const parsed = JSON.parse(raw);
+    if (!parsed || typeof parsed !== "object") return void 0;
+    const v = parsed.mainBranch;
+    return typeof v === "string" && v.trim() ? v.trim() : void 0;
+  } catch {
+    return void 0;
+  }
+}
+async function saveMainBranch(cwd, branch) {
+  return patchConfig(cwd, (current) => ({ ...current, mainBranch: branch }));
+}
+async function detectMainBranch(cwd, git) {
+  const r = await git(["symbolic-ref", "--short", "refs/remotes/origin/HEAD"], cwd);
+  if (r.code !== 0) return void 0;
+  const name = r.stdout.trim().replace(/^origin\//, "");
+  return name || void 0;
+}
+async function remoteBranches(cwd, git) {
+  const r = await git(["for-each-ref", "--format=%(refname:short)", "refs/remotes/origin"], cwd);
+  if (r.code !== 0) return [];
+  return r.stdout.split("\n").map((s) => s.trim().replace(/^origin\//, "")).filter((s) => s && s !== "HEAD");
+}
+function mainBranchChoices(remote, current) {
+  const have = remote.filter((b) => b !== current && !b.startsWith("hc/"));
+  const common = COMMON_MAIN_BRANCHES.filter((b) => have.includes(b));
+  const rest = have.filter((b) => !common.includes(b));
+  return [...common, ...rest].slice(0, 8);
+}
+var MAIN_BRANCH_QUESTION = "Which branch is this project's main one? I sync it into the session branch before continuing, so the work carries on against current code. I'll remember the answer and won't ask again.";
+async function resolveMainBranch(deps) {
+  const recorded = await recordedMainBranch(deps.cwd);
+  if (recorded) return recorded;
+  const detected = await detectMainBranch(deps.cwd, deps.git);
+  if (detected) {
+    await saveMainBranch(deps.cwd, detected);
+    deps.note?.(`\u{1F33F} Main branch: \`${detected}\` (from \`origin/HEAD\`) \u2014 remembered for this project.`);
+    return detected;
+  }
+  const choices = mainBranchChoices(await remoteBranches(deps.cwd, deps.git));
+  const answer = (await deps.askUser(
+    await (deps.phrase ?? ((t) => Promise.resolve(t)))(MAIN_BRANCH_QUESTION),
+    choices.length ? { options: choices } : void 0
+  )).trim();
+  if (!answer) return void 0;
+  await saveMainBranch(deps.cwd, answer);
+  deps.note?.(`\u{1F33F} Main branch: \`${answer}\` \u2014 remembered for this project.`);
+  return answer;
+}
+
+export {
+  COMMON_MAIN_BRANCHES,
+  recordedMainBranch,
+  saveMainBranch,
+  detectMainBranch,
+  mainBranchChoices,
+  MAIN_BRANCH_QUESTION,
+  resolveMainBranch
+};

package/dist/chunk-SSDLHWSF.js

@@ -0,0 +1,35 @@
+// src/engine/session-scope.ts
+import { dirname, join, resolve, sep } from "path";
+var HC_DIR = ".horsecode";
+var WORKTREES = join(HC_DIR, "worktrees");
+var BASE = "base";
+function sessionBase(cwd) {
+  const abs = resolve(cwd);
+  const marker = `${sep}${WORKTREES}${sep}`;
+  const at = abs.indexOf(marker);
+  if (at < 0) return void 0;
+  const after = abs.slice(at + marker.length);
+  const job = after.split(sep)[0];
+  if (!job) return void 0;
+  return join(abs.slice(0, at), WORKTREES, job, BASE);
+}
+function stateRoot(cwd) {
+  return sessionBase(cwd) ?? resolve(cwd);
+}
+function writableStateRoot(cwd) {
+  return sessionBase(cwd);
+}
+function inLinkedWorktree(cwd, run) {
+  if (sessionBase(cwd) !== void 0) return true;
+  const dir = run(["rev-parse", "--absolute-git-dir"])?.trim();
+  const common = run(["rev-parse", "--path-format=absolute", "--git-common-dir"])?.trim();
+  if (!dir || !common) return false;
+  return resolve(dir) !== resolve(common);
+}
+
+export {
+  sessionBase,
+  stateRoot,
+  writableStateRoot,
+  inLinkedWorktree
+};