@gr8ful/spf 0.5.1 → 0.6.0

package/dist/test/fake_asker.js

@@ -1,30 +0,0 @@
-function firstMatch(map, label) {
-    if (!map)
-        return undefined;
-    const key = Object.keys(map).find((k) => label.includes(k));
-    return key === undefined ? undefined : map[key];
-}
-export function createFakeAsker(script) {
-    return {
-        async text(label, opts) {
-            const answer = firstMatch(script.text, label);
-            return answer !== undefined ? answer : (opts?.default ?? "");
-        },
-        async select(label, _choices, dflt) {
-            const answer = firstMatch(script.select, label);
-            return (answer !== undefined ? answer : dflt);
-        },
-        async confirm(label, dflt) {
-            const answer = firstMatch(script.confirm, label);
-            if (answer !== undefined)
-                return answer;
-            return script.defaultConfirm ?? dflt;
-        },
-        async secret(label, _opts) {
-            return firstMatch(script.secret, label) ?? "";
-        },
-        note() { },
-        heading() { },
-        close() { },
-    };
-}

package/dist/test/git_helper.test.d.ts

@@ -1 +0,0 @@
-import "./hermetic_git.ts";

package/dist/test/git_helper.test.js

@@ -1,59 +0,0 @@
-import "./hermetic_git.js";
-/**
- * `findRepoRoot()`'s contract is "never throws, always returns some root."
- * `isRepoAt()` only proves `git rev-parse --git-dir` succeeds, which is also
- * true inside a bare repo and inside a `.git/` directory itself — neither
- * has a work tree, so the follow-up `--show-toplevel` call fails there even
- * though `isRepoAt()` said yes. Regression coverage for that gap: before the
- * fix, `findRepoRoot()` let that failure propagate as an uncaught throw,
- * which — because `cli/index.ts` calls `paths.resolveAnchor()` outside its
- * top-level try/catch — crashed every command (including `spf --version`)
- * when run from a bare repo or from inside `.git/`.
- */
-import { test } from "node:test";
-import assert from "node:assert/strict";
-import { execFileSync } from "node:child_process";
-import { mkdtempSync, rmSync } from "node:fs";
-import { tmpdir } from "node:os";
-import path from "node:path";
-import { findRepoRoot } from "../core/git_helper.js";
-test("findRepoRoot falls back to cwd inside a bare repo (no work tree)", () => {
-    const dir = mkdtempSync(path.join(tmpdir(), "spf-bare-"));
-    try {
-        execFileSync("git", ["init", "--bare", dir], { stdio: "ignore" });
-        const root = findRepoRoot(dir);
-        assert.equal(root, path.resolve(dir));
-    }
-    finally {
-        rmSync(dir, { recursive: true, force: true });
-    }
-});
-test("findRepoRoot falls back to cwd inside a repo's .git directory", () => {
-    const dir = mkdtempSync(path.join(tmpdir(), "spf-dotgit-"));
-    try {
-        execFileSync("git", ["init"], { cwd: dir, stdio: "ignore" });
-        const gitDir = path.join(dir, ".git");
-        const root = findRepoRoot(gitDir);
-        assert.equal(root, path.resolve(gitDir));
-    }
-    finally {
-        rmSync(dir, { recursive: true, force: true });
-    }
-});
-test("findRepoRoot resolves the toplevel of an ordinary work tree", () => {
-    const dir = mkdtempSync(path.join(tmpdir(), "spf-worktree-"));
-    try {
-        execFileSync("git", ["init"], { cwd: dir, stdio: "ignore" });
-        const sub = path.join(dir, "nested");
-        execFileSync("node", ["-e", `require("fs").mkdirSync(${JSON.stringify(sub)})`]);
-        const root = findRepoRoot(sub);
-        // git may resolve symlinked tmpdirs (e.g. macOS /tmp -> /private/tmp) —
-        // compare against what git itself reports as the raw toplevel is what
-        // resolveAnchor ultimately does too, so lean on findRepoRoot from the
-        // repo root itself for a stable assertion.
-        assert.equal(root, findRepoRoot(dir));
-    }
-    finally {
-        rmSync(dir, { recursive: true, force: true });
-    }
-});

package/dist/test/hermetic_git.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/test/hermetic_git.js

@@ -1,22 +0,0 @@
-/**
- * Import this FIRST in any test file that spawns `git`.
- *
- * When the suite runs inside a git hook (lefthook's `pre-push`), git exports
- * GIT_DIR — and sometimes GIT_WORK_TREE/GIT_INDEX_FILE — into every child
- * process, and those beat `cwd` for every git invocation. A test that does
- * `git init` / `git remote add` / `git commit` in a scratch tmpdir then
- * silently operates on the REAL repository being pushed. Observed damage
- * before this guard existed: a stray empty "init" commit landed on the
- * checked-out branch, and `git init` re-initialized the shared `.git`
- * directory as BARE (git treats a target directory named `.git` as a bare
- * repo), breaking `git status` in the main checkout until `core.bare` was
- * flipped back.
- *
- * Deleting the variables at module load — each test file is its own
- * `node --test` process — makes `cwd` authoritative again for the whole
- * file, including git calls made by the code under test.
- */
-for (const key of ["GIT_DIR", "GIT_WORK_TREE", "GIT_INDEX_FILE", "GIT_PREFIX", "GIT_COMMON_DIR", "GIT_OBJECT_DIRECTORY"]) {
-    delete process.env[key];
-}
-export {};

package/dist/test/init_command.test.d.ts

@@ -1,14 +0,0 @@
-/**
- * Regression guard for `spf init`'s non-interactive paths — `--yes`,
- * `--template <name>`, and (implicitly, since the test runner's stdin/stdout
- * are never a TTY) plain `spf init` with no flags. All three must keep
- * writing the exact same content they always have, byte for byte, and must
- * never touch stdin — a scripted `spf init` in CI must not hang.
- *
- * The interactive interview itself is covered directly against `Asker`
- * in `interview.test.ts`; `initCommand`'s interactive branch always calls
- * the real `createAsker()` (backed by `node:readline` on `process.stdin`),
- * which has nothing to read in a test process — exercising it here would
- * just hang, so it isn't.
- */
-import "./hermetic_git.js";

package/dist/test/init_command.test.js

@@ -1,136 +0,0 @@
-/**
- * Regression guard for `spf init`'s non-interactive paths — `--yes`,
- * `--template <name>`, and (implicitly, since the test runner's stdin/stdout
- * are never a TTY) plain `spf init` with no flags. All three must keep
- * writing the exact same content they always have, byte for byte, and must
- * never touch stdin — a scripted `spf init` in CI must not hang.
- *
- * The interactive interview itself is covered directly against `Asker`
- * in `interview.test.ts`; `initCommand`'s interactive branch always calls
- * the real `createAsker()` (backed by `node:readline` on `process.stdin`),
- * which has nothing to read in a test process — exercising it here would
- * just hang, so it isn't.
- */
-import "./hermetic_git.js";
-import { test, beforeEach, afterEach } from "node:test";
-import assert from "node:assert/strict";
-import { mkdtempSync, rmSync, readFileSync, existsSync } from "node:fs";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
-import { execFileSync } from "node:child_process";
-import { initCommand, EXAMPLE_CHAIN_YAML } from "../cli/commands/init.js";
-import { loadRepoChains } from "../chains/repo_chains.js";
-import { resolveAnchor } from "../core/paths.js";
-let dir;
-beforeEach(() => {
-    dir = mkdtempSync(join(tmpdir(), "spf-init-test-"));
-    execFileSync("git", ["init", "-q"], { cwd: dir });
-});
-afterEach(() => {
-    rmSync(dir, { recursive: true, force: true });
-});
-test("--yes writes the plain starter config, all commented out, with no interview", async () => {
-    const code = await initCommand(["--cwd", dir, "--yes"]);
-    assert.equal(code, 0);
-    const content = readFileSync(join(dir, ".spf", "spf.config.yaml"), "utf-8");
-    assert.match(content, /merged ON TOP of spf's packaged built-in defaults/);
-    assert.match(content, /^# quality:/m); // every real section stays commented out
-    assert.doesNotMatch(content, /^defaults:/m);
-});
-test("plain `spf init` (no TTY in a test process) falls through to the same starter config as --yes", async () => {
-    const code = await initCommand(["--cwd", dir]);
-    assert.equal(code, 0);
-    const content = readFileSync(join(dir, ".spf", "spf.config.yaml"), "utf-8");
-    assert.match(content, /merged ON TOP of spf's packaged built-in defaults/);
-});
-test("--template writes the named template as-is, skipping the interview even without --yes", async () => {
-    const code = await initCommand(["--cwd", dir, "--template", "ts-cc"]);
-    assert.equal(code, 0);
-    const content = readFileSync(join(dir, ".spf", "spf.config.yaml"), "utf-8");
-    assert.match(content, /Claude Code backend, pointed at Ollama/);
-});
-test("an existing config is left alone without --force, even for --yes", async () => {
-    await initCommand(["--cwd", dir, "--yes"]);
-    const before = readFileSync(join(dir, ".spf", "spf.config.yaml"), "utf-8");
-    const code = await initCommand(["--cwd", dir, "--template", "ts-cc"]); // no --force
-    assert.equal(code, 0);
-    assert.equal(readFileSync(join(dir, ".spf", "spf.config.yaml"), "utf-8"), before);
-});
-test("--force overwrites an existing config non-interactively", async () => {
-    await initCommand(["--cwd", dir, "--yes"]);
-    await initCommand(["--cwd", dir, "--template", "ts-cc", "--force"]);
-    const content = readFileSync(join(dir, ".spf", "spf.config.yaml"), "utf-8");
-    assert.match(content, /Claude Code backend, pointed at Ollama/);
-});
-test("never writes .env or .env.example on the non-interactive paths", async () => {
-    await initCommand(["--cwd", dir, "--yes"]);
-    assert.equal(existsSync(join(dir, ".env")), false);
-    assert.equal(existsSync(join(dir, ".env.example")), false);
-});
-test("also installs the repo-local Claude Code skill by default, on every non-interactive path", async () => {
-    const code = await initCommand(["--cwd", dir, "--yes"]);
-    assert.equal(code, 0);
-    assert.ok(existsSync(join(dir, ".claude", "skills", "spf", "SKILL.md")), "spf init should install the skill unless --no-skills is passed");
-});
-test("--no-skills skips the skill install", async () => {
-    const code = await initCommand(["--cwd", dir, "--yes", "--no-skills"]);
-    assert.equal(code, 0);
-    assert.equal(existsSync(join(dir, ".claude", "skills", "spf")), false);
-});
-test("scaffolds .spf/chains/example.yaml, fully commented out (registers nothing)", async () => {
-    const code = await initCommand(["--cwd", dir, "--yes"]);
-    assert.equal(code, 0);
-    const examplePath = join(dir, ".spf", "chains", "example.yaml");
-    assert.ok(existsSync(examplePath), "spf init should scaffold .spf/chains/example.yaml");
-    const content = readFileSync(examplePath, "utf-8");
-    for (const line of content.split("\n")) {
-        if (line.trim() === "")
-            continue;
-        assert.ok(line.startsWith("#"), `every non-blank line in the scaffolded example must be commented out: ${JSON.stringify(line)}`);
-    }
-});
-test("never adds .spf/chains to .gitignore — chain files must stay tracked for protected_files to cover them", async () => {
-    await initCommand(["--cwd", dir, "--yes"]);
-    const gitignore = readFileSync(join(dir, ".gitignore"), "utf-8");
-    assert.doesNotMatch(gitignore, /\.spf\/chains/);
-});
-test("the scaffolded example.yaml loads clean — zero chains, zero problems (it must not report a problem against spf's own scaffold)", async () => {
-    const code = await initCommand(["--cwd", dir, "--yes"]);
-    assert.equal(code, 0);
-    const anchor = resolveAnchor(dir);
-    const { chains, problems } = loadRepoChains(anchor);
-    assert.deepEqual(chains, []);
-    assert.deepEqual(problems, []);
-});
-test("EXAMPLE_CHAIN_YAML's commented-out template, uncommented verbatim, is a chain the loader accepts", async () => {
-    const lines = EXAMPLE_CHAIN_YAML.split("\n");
-    const startIdx = lines.findIndex((l) => l.startsWith("# name: example"));
-    assert.ok(startIdx !== -1, "expected a `# name: example` line to anchor the template block");
-    const uncommented = lines
-        .slice(startIdx)
-        .map((l) => l.replace(/^#\s?/, ""))
-        .join("\n");
-    const chainsDir = join(dir, ".spf", "chains");
-    execFileSync("mkdir", ["-p", chainsDir]);
-    const { writeFileSync } = await import("node:fs");
-    writeFileSync(join(chainsDir, "uncommented.yaml"), uncommented);
-    const anchor = resolveAnchor(dir);
-    const { chains, problems } = loadRepoChains(anchor);
-    assert.deepEqual(problems, [], `expected zero problems, got: ${JSON.stringify(problems)}`);
-    assert.equal(chains.length, 1);
-    assert.equal(chains[0]?.name, "example");
-});
-test("re-running spf init doesn't overwrite an already-scaffolded example.yaml", async () => {
-    await initCommand(["--cwd", dir, "--yes"]);
-    const examplePath = join(dir, ".spf", "chains", "example.yaml");
-    const before = readFileSync(examplePath, "utf-8");
-    await initCommand(["--cwd", dir, "--template", "ts-cc"]); // no --force
-    assert.equal(readFileSync(examplePath, "utf-8"), before);
-});
-test("re-running spf init doesn't re-copy an unchanged skill install (install-skill's own idempotency)", async () => {
-    await initCommand(["--cwd", dir, "--yes"]);
-    const manifestPath = join(dir, ".claude", "skills", "spf", ".spf-skill-version");
-    const before = readFileSync(manifestPath, "utf-8");
-    await initCommand(["--cwd", dir, "--template", "ts-cc"]); // no --force: config write is a no-op, skill install still runs
-    assert.equal(readFileSync(manifestPath, "utf-8"), before);
-});

package/dist/test/interview.test.d.ts

@@ -1,15 +0,0 @@
-/**
- * `spf init`'s interactive interview (`cli/interview.ts`) — driven through
- * the `Asker` seam with a scripted fake (`./fake_asker.ts`), never a real
- * TTY. Covers the three things a wrong answer would actually break:
- *   1. the pinned-roster trap (planner/reviewer/documenter overridden
- *      whenever the backend switches to claude_code — see agent_cc.ts/
- *      agents.ts's back-fill comment),
- *   2. the generated config is a genuine override — validating it requires
- *      merging with the packaged built-in roster first, exactly like
- *      `spf doctor` does, never the raw document alone,
- *   3. each `spf watch` combination collects exactly the credentials
- *      `cli/commands/watch.ts`'s resolveIssueProvider/resolveCodeHostProvider
- *      actually read — no more, no less.
- */
-import "./hermetic_git.js";