dw-sdlc 0.0.0-stage → 0.2.0

package/dist/commands/references-setup.d.ts

@@ -0,0 +1,2 @@
+export declare const summary = "set a repository up to declare References: the Router, its table and the ignore rules";
+export declare function run(argv: string[]): number;

package/dist/commands/references-setup.js

@@ -0,0 +1,202 @@
+// `dw-sdlc references setup` sets a repository up to declare References: the five files its USAGE names,
+// each written only when it would change. Existing content stays: a list gains the entries it lacks at
+// its end, nothing is removed or reordered, and a file the step cannot read as it expects is refused.
+import { spawnSync } from "node:child_process";
+import { existsSync, lstatSync, mkdirSync, readFileSync, symlinkSync, writeFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { parseArgs } from "node:util";
+import { CONFIG, isObject, readReferences } from "../references-key.js";
+import { renderBlock, withBlock } from "../router-block.js";
+const ROUTER = "references/AGENTS.md";
+/** A symlink to the Router, so Claude Code loads it. */
+const ROUTER_LINK = "references/CLAUDE.md";
+const SETTINGS = ".claude/settings.json";
+const IGNORE = ".gitignore";
+const TEMPLATE = join(import.meta.dirname, "..", "..", "templates", "router.md");
+/** A clone's own agent files at any depth; Claude Code matches the globs against absolute paths. */
+const EXCLUDES = [
+    "**/references/*/CLAUDE.md",
+    "**/references/*/**/CLAUDE.md",
+    "**/references/*/AGENTS.md",
+    "**/references/*/**/AGENTS.md"
+];
+/** Every clone ignored, then the Router and its symlink tracked: an exception counts after its pattern. */
+const IGNORED = "references/*";
+const TRACKED = ["!references/AGENTS.md", "!references/CLAUDE.md"];
+/** Lines that ignore references/ itself: git never looks inside it, so no exception tracks the Router. */
+const WHOLE = new Set(["references", "references/", "/references", "/references/"]);
+const IGNORE_COMMENT = "# References are cloned on each machine by the references plugin; only the Router is tracked.";
+export const summary = "set a repository up to declare References: the Router, its table and the ignore rules";
+const USAGE = `Usage: dw-sdlc references setup [--root <dir>] [--dry-run | --check]
+  or:  pnpm references:setup with the same flags, in a checkout of dw-sdlc
+
+Sets the repository at --root, or the one the current directory sits in, up to declare References:
+the Router in ${ROUTER} with its CLAUDE.md symlink and, between its two markers, the table of each
+Reference's dir and when from the references key, claudeMdExcludes in ${SETTINGS} for the clones'
+own agent files, the ${IGNORE} lines that keep every clone out of git but the Router, and an empty
+references key in ${CONFIG}. Every file is written only when it would change, and the text around
+the Router's table never; --dry-run reports without writing, and --check does the same and exits 1
+when a file would change. Prints one line per file. Exit 1 when a file is refused, 2 on a bad
+argument.`;
+function messageOf(error) {
+    return error instanceof Error ? error.message : String(error);
+}
+function fail(message) {
+    console.error(`references:setup: ${message}`);
+    process.exit(2);
+}
+function render(value) {
+    return `${JSON.stringify(value, null, 2)}\n`;
+}
+/** The JSON object `text` holds, or undefined when it holds anything else. */
+function parseObject(text) {
+    let parsed;
+    try {
+        parsed = JSON.parse(text);
+    }
+    catch {
+        return undefined;
+    }
+    return isObject(parsed) ? parsed : undefined;
+}
+class Writer {
+    steps = [];
+    root;
+    dryRun;
+    constructor(root, dryRun) {
+        this.root = root;
+        this.dryRun = dryRun;
+    }
+    record(file, changed, write) {
+        if (changed && !this.dryRun) {
+            const path = join(this.root, file);
+            mkdirSync(dirname(path), { recursive: true });
+            write(path);
+        }
+        this.steps.push({ file, outcome: changed ? "wrote" : "unchanged" });
+    }
+    /** The text `change` gives `file`, from what `file` holds now; written when the two differ. */
+    put(file, change) {
+        const path = join(this.root, file);
+        const current = existsSync(path) ? readFileSync(path, "utf8") : undefined;
+        const next = change(current);
+        if ("refusal" in next) {
+            this.steps.push({ file, outcome: "refused", detail: next.refusal });
+            return;
+        }
+        this.record(file, next.text !== current, (target) => {
+            writeFileSync(target, next.text);
+        });
+    }
+    /** `file`, made by `make` when nothing sits at its path, a dangling symlink included; never replaced. */
+    create(file, make) {
+        this.record(file, lstatSync(join(this.root, file), { throwIfNoEntry: false }) === undefined, make);
+    }
+}
+/** The settings with claudeMdExcludes holding every glob of EXCLUDES, those it lacks appended. */
+function withExcludes(current) {
+    if (current === undefined) {
+        return { text: render({ claudeMdExcludes: EXCLUDES }) };
+    }
+    const settings = parseObject(current);
+    if (settings === undefined) {
+        return { refusal: "is not a JSON object; fix it by hand first" };
+    }
+    const value = settings.claudeMdExcludes ?? [];
+    if (!Array.isArray(value)) {
+        return { refusal: "claudeMdExcludes is not a list; fix it by hand first" };
+    }
+    const existing = value;
+    const missing = EXCLUDES.filter((glob) => !existing.includes(glob));
+    return { text: missing.length === 0 ? current : render({ ...settings, claudeMdExcludes: [...existing, ...missing] }) };
+}
+/**
+ * The ignore file with the lines it lacks appended. Without `references/*` all three go in, so each
+ * exception lands after the pattern it excepts; with it, only the exceptions it lacks.
+ */
+function withIgnoreLines(current) {
+    const text = current ?? "";
+    const lines = text.split(/\r?\n/).map((line) => line.trimEnd());
+    if (lines.some((line) => WHOLE.has(line))) {
+        return { refusal: `ignores references/ itself, so no exception tracks the Router; ignore ${IGNORED} instead` };
+    }
+    const ignored = lines.includes(IGNORED);
+    const missing = ignored ? TRACKED.filter((line) => !lines.includes(line)) : [IGNORE_COMMENT, IGNORED, ...TRACKED];
+    if (missing.length === 0) {
+        return { text };
+    }
+    const head = text === "" || text.endsWith("\n") ? text : `${text}\n`;
+    const gap = head !== "" && !ignored ? "\n" : "";
+    return { text: `${head}${gap}${missing.join("\n")}\n` };
+}
+/** The config with an empty `references` key when it has none, inserted so its own layout stays. */
+function withEmptyKey(current) {
+    if (current === undefined) {
+        return { text: render({ references: [] }) };
+    }
+    const config = parseObject(current);
+    if (config === undefined) {
+        return { refusal: "is not a JSON object; fix it by hand first" };
+    }
+    if (Object.hasOwn(config, "references")) {
+        return { text: current };
+    }
+    const close = current.lastIndexOf("}");
+    const body = current.slice(0, close).trimEnd();
+    const comma = body.endsWith("{") ? "" : ",";
+    return { text: `${body}${comma}\n  "references": []\n${current.slice(close)}` };
+}
+/** The repository `dir` sits in, or `dir` itself outside one. */
+function toplevel(dir) {
+    const result = spawnSync("git", ["-C", dir, "rev-parse", "--show-toplevel"], { encoding: "utf8" });
+    return result.status === 0 ? result.stdout.trim() : dir;
+}
+function setup(root, dryRun) {
+    const writer = new Writer(root, dryRun);
+    const template = readFileSync(TEMPLATE, "utf8");
+    const reading = readReferences(root);
+    writer.put(ROUTER, (current) => {
+        if ("problem" in reading) {
+            return { refusal: `${reading.problem}; the table comes from the key, so fix it first` };
+        }
+        const next = withBlock(current ?? template, renderBlock(reading.references ?? []));
+        return "problem" in next ? { refusal: next.problem } : next;
+    });
+    writer.create(ROUTER_LINK, (path) => {
+        symlinkSync("AGENTS.md", path);
+    });
+    writer.put(SETTINGS, withExcludes);
+    writer.put(IGNORE, withIgnoreLines);
+    writer.put(CONFIG, withEmptyKey);
+    return writer.steps;
+}
+export function run(argv) {
+    let values;
+    try {
+        values = parseArgs({
+            args: argv,
+            options: {
+                help: { type: "boolean", short: "h" },
+                root: { type: "string" },
+                "dry-run": { type: "boolean" },
+                check: { type: "boolean" }
+            }
+        }).values;
+    }
+    catch (error) {
+        fail(`${messageOf(error)}\n\n${USAGE}`);
+    }
+    if (values.help === true) {
+        console.log(USAGE);
+        return 0;
+    }
+    const check = values.check === true;
+    const dryRun = values["dry-run"] === true || check;
+    const steps = setup(toplevel(values.root ?? process.cwd()), dryRun);
+    for (const step of steps) {
+        const verb = step.outcome === "wrote" && dryRun ? "would write" : step.outcome;
+        console.log(`${verb.padEnd(11)} ${step.file}${step.detail === undefined ? "" : ` — ${step.detail}`}`);
+    }
+    const refused = steps.some((step) => step.outcome === "refused");
+    return refused || (check && steps.some((step) => step.outcome === "wrote")) ? 1 : 0;
+}

package/dist/commands/references-sync.d.ts

@@ -0,0 +1,2 @@
+export declare const summary = "bring every declared Reference to its ref under references/";
+export declare function run(argv: string[]): Promise<number>;

package/dist/commands/references-sync.js

@@ -0,0 +1,341 @@
+// `dw-sdlc references sync`, the Sync: every Reference the committed config declares brought to its ref
+// under references/<dir>, each clone shallow, blobless, detached and sparse where its entry says. An
+// entry that fails fails alone, and a repository that declares no References gets no output at all.
+import { spawnSync } from "node:child_process";
+import { existsSync, linkSync, mkdirSync, readdirSync, readFileSync, renameSync, rmSync, writeFileSync } from "node:fs";
+import { extname, join } from "node:path";
+import { setTimeout as sleep } from "node:timers/promises";
+import { parseArgs } from "node:util";
+import { readPins, resolveRef } from "../pins.js";
+import { CONFIG, readReferences } from "../references-key.js";
+import { renderBlock, withBlock } from "../router-block.js";
+const CLONES = "references";
+const ROUTER = "references/AGENTS.md";
+/** The setup, run through the package's bin, named in a line when the Router needs it: `cli.ts` in
+ * the source, `cli.js` in what tsc emits. */
+const SETUP = `node "${join(import.meta.dirname, "..", `cli${extname(import.meta.filename)}`)}" references setup`;
+const LOCK = ".sync.lock";
+/** Seconds a Sync waits for another one in the same checkout: inside the session hook's 60 s. */
+const WAIT_SECONDS = 30;
+const POLL_MS = 100;
+export const summary = "bring every declared Reference to its ref under references/";
+const USAGE = `Usage: dw-sdlc references sync [dir...]
+  or:  pnpm references:sync [dir...], in a checkout of dw-sdlc
+
+Brings every Reference the references key of ${CONFIG} declares to its ref under ${CLONES}/<dir>, or
+only the given dirs: a missing one cloned shallow, an existing one moved to its branch's head or its
+tag, holding the top-level files and the paths its only names when it has one, without the paths
+its skip names. Prints one line per Reference. Exit 1 when any Reference fails, 2 on a bad key,
+config or argument, in which case nothing is synced. One Sync runs in a checkout at a time; a
+second one waits for it up to ${WAIT_SECONDS} s, or REFERENCES_SYNC_WAIT seconds.`;
+function messageOf(error) {
+    return error instanceof Error ? error.message : String(error);
+}
+/** The code a failed system call throws with, as "ENOENT", or undefined. */
+function codeOf(error) {
+    return error instanceof Error && "code" in error && typeof error.code === "string" ? error.code : undefined;
+}
+function fail(message) {
+    console.error(`references:sync: ${message}`);
+    process.exit(2);
+}
+/** REFERENCES_SYNC_WAIT when it names a number of seconds, else WAIT_SECONDS. */
+function waitSeconds() {
+    const given = process.env.REFERENCES_SYNC_WAIT?.trim();
+    const seconds = given === undefined || given === "" ? Number.NaN : Number(given);
+    return Number.isFinite(seconds) && seconds >= 0 ? seconds : WAIT_SECONDS;
+}
+/** Whether `pid` is a running process of this user; a Sync's lock names one, so any other pid is left over. */
+function alive(pid) {
+    try {
+        process.kill(pid, 0);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+/** The pid of the running Sync that holds the lock at `path`; undefined for no lock, or a left-over one. */
+function holderOf(path) {
+    let content;
+    try {
+        content = readFileSync(path, "utf8");
+    }
+    catch (error) {
+        if (codeOf(error) === "ENOENT") {
+            return undefined;
+        }
+        throw error;
+    }
+    const pid = Number(content.trim());
+    return Number.isInteger(pid) && pid > 0 && alive(pid) ? pid : undefined;
+}
+/** Removes the left-over lock at `path`; one a running Sync took since the last look goes back in place. */
+function clear(path) {
+    const aside = `${path}.${process.pid}.left`;
+    try {
+        renameSync(path, aside);
+    }
+    catch (error) {
+        if (codeOf(error) === "ENOENT") {
+            return;
+        }
+        throw error;
+    }
+    if (holderOf(aside) === undefined) {
+        rmSync(aside, { force: true });
+    }
+    else {
+        renameSync(aside, path);
+    }
+}
+/** Removes the lock at `path` when this process holds it, and only then. */
+function release(path) {
+    if (holderOf(path) === process.pid) {
+        rmSync(path, { force: true });
+    }
+}
+/**
+ * Takes the lock under references/ for this process, waiting up to `seconds` on a running Sync that
+ * holds it, and clearing one left over. Past the wait, the pid still holding it.
+ */
+async function lock(root, seconds) {
+    const dir = join(root, CLONES);
+    mkdirSync(dir, { recursive: true });
+    const path = join(dir, LOCK);
+    // Written whole under this process's own name, then linked into place: no one reads it half-written.
+    const own = `${path}.${process.pid}`;
+    writeFileSync(own, `${process.pid}\n`);
+    const deadline = Date.now() + seconds * 1000;
+    try {
+        for (;;) {
+            try {
+                linkSync(own, path);
+                return { release: () => release(path) };
+            }
+            catch (error) {
+                if (codeOf(error) !== "EEXIST") {
+                    throw error;
+                }
+            }
+            const holder = holderOf(path);
+            if (holder === undefined) {
+                clear(path);
+                continue;
+            }
+            if (Date.now() >= deadline) {
+                return { heldBy: holder };
+            }
+            await sleep(POLL_MS);
+        }
+    }
+    finally {
+        rmSync(own, { force: true });
+    }
+}
+/** The variables that tie git to one repository, as git itself lists them. */
+const REPOSITORY_VARS = new Set((spawnSync("git", ["rev-parse", "--local-env-vars"], { encoding: "utf8" }).stdout ?? "").split("\n").filter(Boolean));
+function git(args, cwd) {
+    // Each call finds its repository from `cwd`: the GIT_DIR a git hook exports would aim it at the
+    // hook's repository. A missing credential fails the fetch instead of waiting on a prompt nobody sees.
+    const env = Object.fromEntries(Object.entries(process.env).filter(([name]) => !REPOSITORY_VARS.has(name)));
+    const result = spawnSync("git", args, { cwd, encoding: "utf8", env: { ...env, GIT_TERMINAL_PROMPT: "0" } });
+    // git's error on one line, so each Reference stays one line of the report.
+    const err = (result.stderr ?? "")
+        .split("\n")
+        .map((line) => line.trim())
+        .filter(Boolean)
+        .join(" ");
+    return { ok: result.status === 0, out: (result.stdout ?? "").trim(), err };
+}
+/** Runs one git step of a sync, `gitOptions` ahead of it; throws with git's error when it fails. */
+function step(args, cwd, gitOptions = []) {
+    const result = git([...gitOptions, ...args], cwd);
+    if (!result.ok) {
+        throw new Error(`git ${args.join(" ")}: ${result.err}`);
+    }
+}
+/** A GitHub repository fetches with the GitHub CLI's credentials, so a private one clones too. */
+function credentials(repository) {
+    return repository.startsWith("https://github.com/")
+        ? ["-c", "credential.helper=", "-c", "credential.helper=!gh auth git-credential"]
+        : [];
+}
+/**
+ * The sparse-checkout patterns of a Reference, none for the whole tree. Without `only`, every path;
+ * with it, the top-level files and its paths alone. The paths `skip` names are left out of both.
+ */
+function sparsePatterns({ only, skip }) {
+    if (only.length === 0 && skip.length === 0) {
+        return [];
+    }
+    const kept = only.length === 0 ? ["/*"] : ["/*", "!/*/", ...only.map((path) => `/${path}`)];
+    return [...kept, ...skip.map((path) => `!/${path}`)];
+}
+/** Whether the tree fetched into `cwd` holds `path`, a directory when it ends in `/`. Reads trees only. */
+function fetchedTreeHas(path, cwd) {
+    const listed = git(["ls-tree", "FETCH_HEAD", "--", path.replace(/\/+$/, "")], cwd);
+    if (!listed.ok) {
+        throw new Error(`git ls-tree FETCH_HEAD: ${listed.err}`);
+    }
+    // `<mode> <type> <object>\t<path>`, or nothing when the tree lacks the path.
+    const type = listed.out.split(" ")[1];
+    return path.endsWith("/") ? type === "tree" : type !== undefined;
+}
+/** Clones or updates one Reference at `ref`, already resolved; the reason it failed, or undefined. */
+function sync(root, reference, ref) {
+    const { dir, repository } = reference;
+    const patterns = sparsePatterns(reference);
+    const target = join(root, CLONES, dir);
+    // Each step that can fetch carries the credentials: a partial clone's sparse-checkout and checkout
+    // fetch the blobs they need.
+    const fetching = (args) => {
+        step(args, target, credentials(repository));
+    };
+    try {
+        if (existsSync(target)) {
+            const origin = git(["remote", "get-url", "origin"], target);
+            if (!existsSync(join(target, ".git")) || !origin.ok || origin.out !== repository) {
+                return `${CLONES}/${dir} exists and is not a clone of ${repository}; move it aside and run again`;
+            }
+        }
+        else {
+            // An empty repository, so the one fetch below brings only the ref, a branch or a tag alike.
+            step(["init", "--quiet", target]);
+            step(["remote", "add", "origin", repository], target);
+        }
+        fetching(["fetch", "--quiet", "--depth", "1", "--filter=blob:none", "origin", ref]);
+        // Before the sparse checkout moves anything, so a renamed folder leaves the clone as it was.
+        const lacking = reference.only.filter((path) => !fetchedTreeHas(path, target));
+        if (lacking.length > 0) {
+            return `only names ${lacking.join(", ")}, which the tree at ${ref} lacks`;
+        }
+        if (patterns.length > 0) {
+            fetching(["sparse-checkout", "set", "--no-cone", ...patterns]);
+        }
+        else {
+            fetching(["sparse-checkout", "disable"]);
+        }
+        // Detached at what was fetched: a local edit the update would overwrite fails the entry instead.
+        fetching(["checkout", "--quiet", "--detach", "FETCH_HEAD"]);
+    }
+    catch (error) {
+        return messageOf(error);
+    }
+    return undefined;
+}
+function parseCli(argv) {
+    try {
+        const { values, positionals } = parseArgs({
+            args: argv,
+            allowPositionals: true,
+            options: { help: { type: "boolean", short: "h" } }
+        });
+        return { help: values.help === true, dirs: positionals };
+    }
+    catch (error) {
+        fail(`${messageOf(error)}\n\n${USAGE}`);
+    }
+}
+/**
+ * One line when the Router or its table is missing or behind `references`, naming the setup to run,
+ * or when its markers are not a pair, which the setup would refuse.
+ */
+function routerLine(root, references) {
+    const path = join(root, ROUTER);
+    if (!existsSync(path)) {
+        return `${ROUTER}  missing  run ${SETUP} from the project to write the Router`;
+    }
+    const current = readFileSync(path, "utf8");
+    const next = withBlock(current, renderBlock(references));
+    if ("problem" in next) {
+        return `${ROUTER}  broken  ${next.problem}`;
+    }
+    if (next.text !== current) {
+        return `${ROUTER}  behind the key  run ${SETUP} from the project to rewrite its table`;
+    }
+    return undefined;
+}
+/** `compute`'s value on the first call, from then on the same value. */
+function once(compute) {
+    let cached;
+    return () => {
+        cached ??= { value: compute() };
+        return cached.value;
+    };
+}
+/** Syncs each of `selected` at its resolved ref and prints its line; whether any failed. */
+function syncAll(root, selected) {
+    const pins = once(() => readPins(root));
+    let failed = false;
+    for (const reference of selected) {
+        let ref = reference.ref;
+        let problem;
+        try {
+            ref = resolveRef(reference.ref, pins);
+            problem = sync(root, reference, ref);
+        }
+        catch (error) {
+            problem = messageOf(error);
+        }
+        if (problem === undefined) {
+            const head = git(["rev-parse", "--short", "HEAD"], join(root, CLONES, reference.dir)).out;
+            console.log(`${CLONES}/${reference.dir}  ${head}  ${reference.repository} ${ref}`);
+        }
+        else {
+            failed = true;
+            console.error(`${CLONES}/${reference.dir}  FAILED  ${problem}`);
+        }
+    }
+    return failed;
+}
+export async function run(argv) {
+    const cli = parseCli(argv);
+    if (cli.help) {
+        console.log(USAGE);
+        return 0;
+    }
+    const toplevel = git(["rev-parse", "--show-toplevel"]);
+    const root = toplevel.ok ? toplevel.out : process.cwd();
+    const reading = readReferences(root);
+    if ("problem" in reading) {
+        fail(`${reading.problem}; nothing synced`);
+    }
+    const references = reading.references ?? [];
+    const unknown = cli.dirs.filter((dir) => !references.some((reference) => reference.dir === dir));
+    if (unknown.length > 0) {
+        fail(`not in the references of ${CONFIG}: ${unknown.join(", ")}`);
+    }
+    if (reading.references === undefined) {
+        return 0;
+    }
+    const selected = cli.dirs.length === 0 ? references : references.filter((reference) => cli.dirs.includes(reference.dir));
+    const seconds = waitSeconds();
+    const attempt = await lock(root, seconds).catch((error) => fail(`${CLONES}/${LOCK}: ${messageOf(error)}; nothing synced`));
+    let failed = false;
+    if ("heldBy" in attempt) {
+        console.error(`references:sync: another Sync (pid ${attempt.heldBy}) still holds ${CLONES}/${LOCK} after ${seconds} s; the clones are what it leaves`);
+    }
+    else {
+        try {
+            failed = syncAll(root, selected);
+        }
+        finally {
+            attempt.release();
+        }
+    }
+    const router = routerLine(root, references);
+    if (router !== undefined) {
+        console.log(router);
+    }
+    const listed = new Set(references.map((reference) => reference.dir));
+    const stray = existsSync(join(root, CLONES))
+        ? readdirSync(join(root, CLONES), { withFileTypes: true })
+            .filter((entry) => entry.isDirectory() && !listed.has(entry.name))
+            .map((entry) => `${CLONES}/${entry.name}`)
+        : [];
+    if (stray.length > 0) {
+        console.log(`Not listed in ${CONFIG}, left alone: ${stray.join(", ")}`);
+    }
+    return failed ? 1 : 0;
+}

package/dist/commands/setup.d.ts

@@ -0,0 +1,30 @@
+import { type CommitConvention, type CommitOnProtected, type ForcePush } from "../agentic-config.ts";
+export type Outcome = "wrote" | "unchanged" | "refused";
+export type Step = {
+    file: string;
+    outcome: Outcome;
+    detail?: string;
+};
+export type SetupOptions = {
+    root: string;
+    home: string;
+    /** Claude Code's config dir, `$CLAUDE_CONFIG_DIR`; `<home>/.claude` when absent. */
+    claudeDir?: string | undefined;
+    force: boolean;
+    dryRun: boolean;
+    /** Pins `commit.convention` in the local layer; left out, a pin the layer already holds stays. */
+    convention?: CommitConvention | undefined;
+    /** Pins `guardrails.forcePush` in the local layer; refused where it loosens the committed value. */
+    forcePush?: ForcePush | undefined;
+    /** Pins `guardrails.commitOnProtected` in the local layer; refused where it loosens the committed value. */
+    commitOnProtected?: CommitOnProtected | undefined;
+};
+export declare const summary = "write this machine's local config layer, the git excludes and the permission rules";
+/**
+ * What the machine's layer points `$schema` at: the marketplace clone's schema as a `file://` URL, as an
+ * editor cannot fetch the `$id` from a private repository and the clone, unlike the install cache, keeps
+ * its path across plugin updates. Without a registered clone holding the schema, the `$id`.
+ */
+export declare function schemaReference(claudeDir: string): string;
+export declare function setup(options: SetupOptions): Step[];
+export declare function run(argv: string[]): number;