z0gcode 0.2.0

package/src/user-skills.mjs

@@ -0,0 +1,111 @@
+// User skills: Claude-Code-style extensibility. Drop a markdown file with
+// frontmatter (name, description) into ~/.z0gcode/skills (global) or
+// <cwd>/.z0g/skills (project) and it is auto-discovered: the description is
+// injected into the system prompt so the model knows when to use it, and the
+// body is loaded on demand via the read_skill tool (progressive disclosure).
+// A skill can be a single <name>.md or a <name>/SKILL.md directory.
+import { readFileSync, existsSync, readdirSync, statSync } from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { loadSettings, saveSetting } from "./settings.mjs";
+
+const skillDirs = (cwd) => [
+  ["global", path.join(os.homedir(), ".z0gcode", "skills")],
+  ["project", path.join(cwd || process.cwd(), ".z0g", "skills")],
+];
+
+// Parse a leading `---\n...\n---` YAML-ish frontmatter block (name/description).
+function parseFrontmatter(text) {
+  const meta = {};
+  let body = text;
+  const m = /^?---\r?\n([\s\S]*?)\r?\n---\r?\n?/.exec(text);
+  if (m) {
+    body = text.slice(m[0].length);
+    for (const line of m[1].split("\n")) {
+      const i = line.indexOf(":");
+      if (i === -1) continue;
+      const k = line.slice(0, i).trim();
+      let v = line.slice(i + 1).trim();
+      if ((v.startsWith('"') && v.endsWith('"')) || (v.startsWith("'") && v.endsWith("'"))) v = v.slice(1, -1);
+      meta[k] = v;
+    }
+  }
+  return { meta, body };
+}
+
+function resolveSkillFile(dir, entry) {
+  const p = path.join(dir, entry);
+  try {
+    const st = statSync(p);
+    if (st.isDirectory()) {
+      const sk = path.join(p, "SKILL.md");
+      return existsSync(sk) ? { file: sk, defaultName: entry } : null;
+    }
+    if (entry.toLowerCase().endsWith(".md")) {
+      return { file: p, defaultName: entry.replace(/\.md$/i, "") };
+    }
+  } catch {}
+  return null;
+}
+
+// Discover all user skills. Project scope overrides global by name.
+// Each: { name, description, file, scope, enabled }.
+export function discoverSkills(cwd) {
+  const disabled = new Set(loadSettings(cwd).disabledSkills || []);
+  const found = new Map();
+  for (const [scope, dir] of skillDirs(cwd)) {
+    if (!existsSync(dir)) continue;
+    let entries;
+    try {
+      entries = readdirSync(dir).sort();
+    } catch {
+      continue;
+    }
+    for (const entry of entries) {
+      const r = resolveSkillFile(dir, entry);
+      if (!r) continue;
+      let text;
+      try {
+        text = readFileSync(r.file, "utf8");
+      } catch {
+        continue;
+      }
+      const { meta } = parseFrontmatter(text);
+      const name = String(meta.name || r.defaultName).trim();
+      if (!name) continue;
+      found.set(name, { name, description: String(meta.description || "").trim(), file: r.file, scope });
+    }
+  }
+  return [...found.values()].map((s) => ({ ...s, enabled: !disabled.has(s.name) }));
+}
+
+export function readUserSkill(cwd, name) {
+  const hit = discoverSkills(cwd).find((s) => s.name === name);
+  if (!hit) return null;
+  try {
+    return parseFrontmatter(readFileSync(hit.file, "utf8")).body.trim();
+  } catch {
+    return null;
+  }
+}
+
+// System-prompt block listing the ENABLED user skills so the model can decide
+// to load them. Empty string when there are none.
+export function skillsPromptBlock(cwd) {
+  const enabled = discoverSkills(cwd).filter((s) => s.enabled);
+  if (!enabled.length) return "";
+  const lines = enabled.map((s) => `- ${s.name}: ${s.description || "(no description)"}`);
+  return [
+    "",
+    "User skills available (call read_skill with the exact name to load the full instructions before you act on it):",
+    ...lines,
+  ].join("\n");
+}
+
+// Enable/disable a skill by name (persisted in global settings.disabledSkills).
+export function setSkillEnabled(cwd, name, enabled) {
+  const cur = new Set(loadSettings(cwd).disabledSkills || []);
+  if (enabled) cur.delete(name);
+  else cur.add(name);
+  saveSetting("disabledSkills", [...cur]);
+}

package/src/worktree.mjs

@@ -0,0 +1,61 @@
+// Git worktree isolation for parallel WRITE subagents. Each write subagent gets
+// its own worktree branched from HEAD, edits there, and its diff is applied back
+// to the main working tree. Non-overlapping edits merge cleanly; overlapping
+// files are reported and skipped (never half-applied).
+import { exec } from "node:child_process";
+import { promises as fs } from "node:fs";
+import path from "node:path";
+import os from "node:os";
+
+const run = (cmd, cwd) => new Promise((resolve) => {
+  exec(cmd, { cwd, timeout: 180000, maxBuffer: 1 << 26 }, (err, stdout, stderr) =>
+    resolve({ code: err?.code ?? 0, out: stdout || "", err: stderr || "" }));
+});
+const q = (s) => JSON.stringify(s); // shell-quote a path
+
+export async function isGitRepo(cwd) {
+  const r = await run("git rev-parse --is-inside-work-tree", cwd);
+  return r.code === 0 && /true/.test(r.out);
+}
+
+// Create a worktree (outside the repo, in a temp dir) on a fresh branch at HEAD.
+export async function addWorktree(cwd, name) {
+  const wtPath = path.join(os.tmpdir(), "z0g-wt", name);
+  const branch = "z0g/" + name;
+  await fs.mkdir(path.dirname(wtPath), { recursive: true });
+  await run(`git worktree remove --force ${q(wtPath)}`, cwd);
+  await run(`git branch -D ${q(branch)}`, cwd);
+  const r = await run(`git worktree add --quiet -b ${q(branch)} ${q(wtPath)} HEAD`, cwd);
+  if (r.code !== 0) throw new Error("git worktree add failed: " + (r.err || r.out).trim());
+  return { wtPath, branch };
+}
+
+// Stage everything in the worktree and return its diff vs HEAD (may be empty).
+export async function collectPatch(wtPath) {
+  await run("git add -A", wtPath);
+  const patch = (await run("git diff --cached --binary HEAD", wtPath)).out;
+  const files = (await run("git diff --cached --name-only HEAD", wtPath)).out.split("\n").filter(Boolean);
+  return { patch, files };
+}
+
+export async function removeWorktree(cwd, wtPath, branch) {
+  await run(`git worktree remove --force ${q(wtPath)}`, cwd);
+  if (branch) await run(`git branch -D ${q(branch)}`, cwd);
+}
+
+// Apply a patch to the main tree, all-or-nothing (no conflict markers left).
+// Returns { ok, reason }. ok:false with reason when it would conflict.
+export async function applyPatch(cwd, patch) {
+  if (!patch || !patch.trim()) return { ok: true, reason: "no changes" };
+  const tmp = path.join(os.tmpdir(), "z0g-wt", "apply-" + Math.floor(Math.random() * 1e9) + ".patch");
+  await fs.mkdir(path.dirname(tmp), { recursive: true });
+  await fs.writeFile(tmp, patch, "utf8");
+  try {
+    const check = await run(`git apply --binary --check ${q(tmp)}`, cwd);
+    if (check.code !== 0) return { ok: false, reason: "conflicts with current tree, skipped" };
+    const r = await run(`git apply --binary --whitespace=nowarn ${q(tmp)}`, cwd);
+    return r.code === 0 ? { ok: true, reason: "applied" } : { ok: false, reason: (r.err || r.out).trim() };
+  } finally {
+    await fs.rm(tmp, { force: true });
+  }
+}