@gr8ful/spf 0.1.7 → 0.3.0

package/dist/core/watch.js

@@ -92,6 +92,13 @@ export async function reconcileOrphans(deps, state) {
         }
         else {
             deps.log(`watch: ${issue.id} orphaned past ${MAX_ORPHAN_ATTEMPTS} attempts — blocked`);
+            deps.notify({
+                kind: "issue_blocked",
+                level: "error",
+                title: `issue ${issue.id} blocked`,
+                detail: `Gave up after ${MAX_ORPHAN_ATTEMPTS} orphaned attempts.`,
+                fields: [["issue", issue.id], ["title", issue.title]],
+            });
             if (!deps.dryRun) {
                 await deps.provider.transition(issue, "blocked", `Gave up after ${MAX_ORPHAN_ATTEMPTS} orphaned attempts.`);
                 cleanupWorktree(deps, marker);
@@ -109,6 +116,13 @@ export async function finishReviews(deps) {
         const status = await deps.codeHost.prStatus({ number: marker.pr, branch: marker.branch ?? "", url: "" });
         if (status.merged) {
             deps.log(`watch: ${issue.id}'s PR #${marker.pr} merged — done`);
+            deps.notify({
+                kind: "issue_done",
+                level: "info",
+                title: `issue ${issue.id} done`,
+                detail: `PR #${marker.pr} merged.`,
+                fields: [["issue", issue.id], ["title", issue.title], ["pr", `#${marker.pr}`]],
+            });
             if (!deps.dryRun) {
                 await deps.provider.transition(issue, "done");
                 cleanupWorktree(deps, marker);
@@ -116,6 +130,13 @@ export async function finishReviews(deps) {
         }
         else if (status.state === "closed") {
             deps.log(`watch: ${issue.id}'s PR #${marker.pr} closed without merging — blocked`);
+            deps.notify({
+                kind: "issue_blocked",
+                level: "error",
+                title: `issue ${issue.id} blocked`,
+                detail: `PR #${marker.pr} was closed without merging.`,
+                fields: [["issue", issue.id], ["title", issue.title], ["pr", `#${marker.pr}`]],
+            });
             if (!deps.dryRun) {
                 await deps.provider.transition(issue, "blocked", `PR #${marker.pr} was closed without merging.`);
                 cleanupWorktree(deps, marker);
@@ -147,13 +168,28 @@ async function runIssue(deps, issue) {
         const result = await deps.runChain({ prompt, cwd: worktreePath, adwId });
         if (!result.accepted) {
             deps.log(`watch: ${issue.id}: chain "${deps.chain}" did not succeed — blocked`);
-            await deps.provider.transition(issue, "blocked", result.detail || `Chain "${deps.chain}" (adw_id ${adwId}) did not complete successfully. Run \`spf phases ${adwId}\` for detail.`);
+            const detail = result.detail || `Chain "${deps.chain}" (adw_id ${adwId}) did not complete successfully. Run \`spf phases ${adwId}\` for detail.`;
+            deps.notify({
+                kind: "issue_blocked",
+                level: "error",
+                title: `issue ${issue.id} blocked`,
+                detail,
+                fields: [["issue", issue.id], ["title", issue.title], ["chain", deps.chain], ["adw_id", adwId]],
+            });
+            await deps.provider.transition(issue, "blocked", detail);
             cleanupWorktree(deps, { worktree: worktreePath, branch });
             return;
         }
         const wtGit = deps.worktreeGit(worktreePath);
         if (wtGit.diffFiles(`origin/${deps.baseBranch}`).length === 0) {
             deps.log(`watch: ${issue.id}: chain succeeded but committed nothing — blocked`);
+            deps.notify({
+                kind: "issue_blocked",
+                level: "error",
+                title: `issue ${issue.id} blocked`,
+                detail: `Chain "${deps.chain}" (adw_id ${adwId}) completed but left no committed changes.`,
+                fields: [["issue", issue.id], ["title", issue.title], ["chain", deps.chain], ["adw_id", adwId]],
+            });
             await deps.provider.transition(issue, "blocked", `Chain "${deps.chain}" (adw_id ${adwId}) completed but left no committed changes.`);
             cleanupWorktree(deps, { worktree: worktreePath, branch });
             return;
@@ -173,10 +209,24 @@ async function runIssue(deps, issue) {
         await deps.provider.writeMarker(issue, { worktree: worktreePath, branch, pr: pr.number, attempt: 0 });
         await deps.provider.transition(issue, "review");
         deps.log(`watch: ${issue.id}: opened PR #${pr.number} — review`);
+        deps.notify({
+            kind: "pr_opened",
+            level: "info",
+            title: `PR #${pr.number} opened`,
+            fields: [["issue", issue.id], ["title", issue.title], ["chain", deps.chain]],
+            url: pr.url || undefined,
+        });
     }
     catch (error) {
         const message = error.message;
         deps.log(`watch: ${issue.id}: error: ${message}`);
+        deps.notify({
+            kind: "watch_error",
+            level: "error",
+            title: `issue ${issue.id} errored`,
+            detail: message,
+            fields: [["issue", issue.id], ["title", issue.title]],
+        });
         await deps.provider.transition(issue, "blocked", `spf watch error: ${message}`).catch(() => undefined);
         cleanupWorktree(deps, { worktree: worktreePath, branch });
     }
@@ -201,13 +251,26 @@ export async function claimNewWork(deps, state) {
             continue;
         }
         deps.log(`watch: claimed ${issue.id}: ${issue.title}`);
+        deps.notify({
+            kind: "issue_claimed",
+            level: "info",
+            title: `issue ${issue.id} claimed`,
+            fields: [["issue", issue.id], ["title", issue.title], ["chain", deps.chain]],
+        });
         state.inflight.add(issue.id);
         runIssue(deps, issue).finally(() => state.inflight.delete(issue.id));
     }
 }
+function tickErrorHandler(deps, stage) {
+    return (error) => {
+        const message = error.message;
+        deps.log(`watch: ${stage} error: ${message}`);
+        deps.notify({ kind: "watch_error", level: "error", title: `watch: ${stage} error`, detail: message, fields: [] });
+    };
+}
 /** One poll tick: reconcile, finish, claim — each independently caught, so one phase's error never blocks the rest. */
 export async function tick(deps, state) {
-    await reconcileOrphans(deps, state).catch((error) => deps.log(`watch: reconcileOrphans error: ${error.message}`));
-    await finishReviews(deps).catch((error) => deps.log(`watch: finishReviews error: ${error.message}`));
-    await claimNewWork(deps, state).catch((error) => deps.log(`watch: claimNewWork error: ${error.message}`));
+    await reconcileOrphans(deps, state).catch(tickErrorHandler(deps, "reconcileOrphans"));
+    await finishReviews(deps).catch(tickErrorHandler(deps, "finishReviews"));
+    await claimNewWork(deps, state).catch(tickErrorHandler(deps, "claimNewWork"));
 }

package/dist/test/chains.test.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Regression net for the chain registry. Chains used to each be a hand-written
+ * module; now every one but `simple-sdlc` is a `steps` list whose
+ * `phases`/`requiredAgents`/`requiredSuites` are DERIVED (see
+ * `chains/steps.ts`'s `derivePhases`/`deriveRequiredAgents`/
+ * `deriveRequiredSuites`). These tests pin what that derivation produces
+ * today, so a step-factory change that silently alters a chain's shape (an
+ * agent dropped from `requiredAgents`, a suite no longer required, a phase
+ * missing from the display string) fails here instead of only showing up as
+ * a `spf list` diff nobody happened to read.
+ */
+export {};

package/dist/test/chains.test.js

@@ -0,0 +1,86 @@
+/**
+ * Regression net for the chain registry. Chains used to each be a hand-written
+ * module; now every one but `simple-sdlc` is a `steps` list whose
+ * `phases`/`requiredAgents`/`requiredSuites` are DERIVED (see
+ * `chains/steps.ts`'s `derivePhases`/`deriveRequiredAgents`/
+ * `deriveRequiredSuites`). These tests pin what that derivation produces
+ * today, so a step-factory change that silently alters a chain's shape (an
+ * agent dropped from `requiredAgents`, a suite no longer required, a phase
+ * missing from the display string) fails here instead of only showing up as
+ * a `spf list` diff nobody happened to read.
+ */
+import { test } from "node:test";
+import assert from "node:assert/strict";
+import { CHAINS, findChain, resolveRequiredAgents } from "../chains/index.js";
+// name -> [phases, requiredAgents (with no options), requiredSuites]
+const EXPECTED = {
+    prompt: { phases: "engineer(request) -> <agent>", agents: ["builder"], suites: [] },
+    scout: { phases: "engineer(request) -> scout", agents: ["scout"], suites: [] },
+    plan: { phases: "engineer(request) -> planner", agents: ["planner"], suites: [] },
+    build: { phases: "engineer(request) -> builder", agents: ["builder"], suites: [] },
+    "plan-build": { phases: "engineer(request) -> planner -> builder -> git(commit)", agents: ["planner", "builder"], suites: [] },
+    "build-test": {
+        phases: "engineer(request) -> builder -> code(test) [-> builder(fix) -> code(test) ...] bounded",
+        agents: ["builder"],
+        suites: ["test"],
+    },
+    "plan-build-test": {
+        phases: "engineer(request) -> planner -> builder -> code(test) [-> builder(fix) -> code(test) ...] bounded -> git(commit)",
+        agents: ["planner", "builder"],
+        suites: ["test"],
+    },
+    "plan-build-test-quality": {
+        phases: "engineer(request) -> planner -> builder -> code(verify) [-> builder(fix) -> code(verify) ...] bounded -> git(commit)",
+        agents: ["planner", "builder"],
+        suites: ["all"],
+    },
+    "build-review": {
+        phases: "engineer(request) -> builder -> reviewer [-> builder(revise) -> reviewer ...] bounded",
+        agents: ["builder", "reviewer"],
+        suites: [],
+    },
+    quality: { phases: "engineer(request) -> code(quality)", agents: [], suites: ["all"] },
+    document: { phases: "engineer(request) -> code(changes) -> documenter", agents: ["documenter"], suites: [] },
+    "simple-sdlc": {
+        phases: "engineer(request) -> planner -> git(commit_plan) -> builder -> code(test) [-> builder(fix) -> code(test) ...] " +
+            "-> reviewer [-> builder(revise) -> reviewer ...] -> code(retest, if revised) -> git(commit_build) " +
+            "-> code(changes) -> documenter -> git(commit_docs)",
+        agents: ["planner", "builder", "reviewer", "documenter"],
+        suites: ["test"],
+    },
+};
+test("every chain in the registry has an expectation pinned here", () => {
+    const names = CHAINS.map((c) => c.name).sort();
+    assert.deepEqual(names, Object.keys(EXPECTED).sort(), "a chain was added/removed/renamed without updating this test");
+});
+for (const chain of CHAINS) {
+    const expected = EXPECTED[chain.name];
+    test(`${chain.name}: derived phases/requiredAgents/requiredSuites match what was hand-verified against \`spf list\``, () => {
+        assert.equal(chain.phases, expected.phases);
+        assert.deepEqual(resolveRequiredAgents(chain, {}), expected.agents);
+        assert.deepEqual(chain.requiredSuites, expected.suites);
+    });
+}
+test("prompt: requiredAgents depends on --agent, not a fixed list — the one dynamic case", () => {
+    const chain = findChain("prompt");
+    assert.deepEqual(resolveRequiredAgents(chain, {}), ["builder"], "no --agent -> falls back to builder");
+    assert.deepEqual(resolveRequiredAgents(chain, { agent: "planner" }), ["planner"], "--agent overrides the default");
+});
+test("every chain but simple-sdlc is a steps list; simple-sdlc alone uses the imperative run() escape hatch", () => {
+    for (const chain of CHAINS) {
+        if (chain.name === "simple-sdlc") {
+            assert.ok(chain.run, "simple-sdlc should still be the one hand-written chain");
+            assert.equal(chain.steps, undefined);
+        }
+        else {
+            assert.ok(chain.steps && chain.steps.length > 0, `${chain.name} should be a steps list`);
+            assert.equal(chain.run, undefined, `${chain.name} should not also define run()`);
+        }
+    }
+});
+test("findChain resolves every registered name and nothing else", () => {
+    for (const chain of CHAINS) {
+        assert.equal(findChain(chain.name)?.name, chain.name);
+    }
+    assert.equal(findChain("not-a-real-chain"), undefined);
+});

package/dist/test/data_types.test.js

@@ -9,9 +9,13 @@
  */
 import { test } from "node:test";
 import assert from "node:assert/strict";
+import { mkdtempSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
 import * as v from "valibot";
 import { toJsonSchema } from "@valibot/to-json-schema";
-import { AgentConfigSchema, BuildOutput, ChangesOutput, DocumentOutput, GenericOutput, PhaseParamsSchema, PlanOutput, ReviewOutput, ScoutOutput, VerifyOutput, makePhaseParams, } from "../core/data_types.js";
+import { AgentConfigSchema, BuildOutput, ChangesOutput, DocumentOutput, GenericOutput, NotificationsConfigSchema, PhaseParamsSchema, PlanOutput, ReviewOutput, ScoutOutput, VerifyOutput, makePhaseParams, } from "../core/data_types.js";
+import { loadConfig } from "../core/agents.js";
 test("writes: three-state semantics — absent, null, and [] all mean something different", () => {
     const base = { name: "builder", prompt_engineering: { system: "s.md", user: "u.md" } };
     const unrestricted = v.parse(AgentConfigSchema, base);
@@ -47,3 +51,32 @@ test("every envelope type still converts to JSON Schema (the sf_report tool wiri
 test("PhaseParamsSchema itself (the one schema WITH a rawTransform) correctly refuses JSON Schema conversion", () => {
     assert.throws(() => toJsonSchema(PhaseParamsSchema), /raw_transform/);
 });
+test("NotificationsConfigSchema defaults to off, no channels", () => {
+    const parsed = v.parse(NotificationsConfigSchema, {});
+    assert.equal(parsed.events, "off");
+    assert.equal(parsed.timeout_ms, 5_000);
+    assert.deepEqual(parsed.channels, []);
+});
+test("a channel's own `events` overrides the top-level scope; unset inherits it", () => {
+    const parsed = v.parse(NotificationsConfigSchema, {
+        events: "errors",
+        channels: [{ kind: "slack" }, { kind: "teams", events: "all" }],
+    });
+    assert.equal(parsed.channels[0].events, undefined, "unset per-channel scope stays undefined, not defaulted to the top-level value — the caller inherits at read time");
+    assert.equal(parsed.channels[1].events, "all");
+});
+test("notifications survives loadConfig's merge — key-by-key like observability/quality, channels replaced wholesale on override", () => {
+    const dir = mkdtempSync(join(tmpdir(), "spf-notify-merge-test-"));
+    try {
+        const base = join(dir, "base.yaml");
+        const override = join(dir, "override.yaml");
+        writeFileSync(base, "notifications:\n  events: off\n  channels:\n    - {kind: webhook, webhook_url_env: BASE_HOOK}\n");
+        writeFileSync(override, "notifications:\n  events: all\n  channels:\n    - {kind: slack, webhook_url_env: SLACK_WEBHOOK_URL}\n");
+        const cfg = loadConfig([base, override]);
+        assert.equal(cfg.notifications.events, "all", "events: key-by-key, override wins");
+        assert.deepEqual(cfg.notifications.channels.map((c) => c.kind), ["slack"], "channels: a whole-array replace, not an append — same semantics as quality.checks");
+    }
+    finally {
+        rmSync(dir, { recursive: true, force: true });
+    }
+});

package/dist/test/env_file.test.d.ts

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

package/dist/test/env_file.test.js

@@ -0,0 +1,74 @@
+/**
+ * `.env` upsert (`cli/env_file.ts`) — the write-side counterpart of
+ * `process.loadEnvFile()` in `cli/index.ts`, which every command already
+ * uses to load `<repo_root>/.env`. Mirrors `ensureGitignore`'s idempotent
+ * shape: preserve everything unrelated, touch only the keys asked for.
+ */
+import { test, beforeEach, afterEach } from "node:test";
+import assert from "node:assert/strict";
+import { mkdtempSync, rmSync, readFileSync, existsSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { maskSecret, readEnvFile, upsertEnvFile, writeEnvExample } from "../cli/env_file.js";
+let dir;
+// Each test gets its own scratch directory with no .env yet — cheap, and
+// avoids one test's leftover .env leaking into the next.
+beforeEach(() => {
+    dir = mkdtempSync(join(tmpdir(), "spf-env-file-test-"));
+});
+afterEach(() => {
+    rmSync(dir, { recursive: true, force: true });
+});
+test("upsertEnvFile creates a fresh .env with the given keys", () => {
+    const result = upsertEnvFile(dir, { GITHUB_TOKEN: "ghp_abc" });
+    assert.deepEqual(result, { added: ["GITHUB_TOKEN"], updated: [], unchanged: [] });
+    assert.equal(readEnvFile(join(dir, ".env")).get("GITHUB_TOKEN"), "ghp_abc");
+});
+test("upsertEnvFile preserves unrelated lines and comments verbatim, appends new keys under its own header", () => {
+    writeFileSync(join(dir, ".env"), "# a hand-written comment\nFOO=bar\n\nBAZ=qux\n");
+    upsertEnvFile(dir, { GITHUB_TOKEN: "ghp_abc" });
+    const raw = readFileSync(join(dir, ".env"), "utf-8");
+    assert.match(raw, /# a hand-written comment/);
+    assert.match(raw, /FOO=bar/);
+    assert.match(raw, /BAZ=qux/);
+    assert.match(raw, /GITHUB_TOKEN=ghp_abc/);
+});
+test("upsertEnvFile rewrites an existing key in place — never a duplicate line", () => {
+    writeFileSync(join(dir, ".env"), "GITHUB_TOKEN=ghp_old\nOTHER=1\n");
+    const result = upsertEnvFile(dir, { GITHUB_TOKEN: "ghp_new" });
+    assert.deepEqual(result, { added: [], updated: ["GITHUB_TOKEN"], unchanged: [] });
+    const raw = readFileSync(join(dir, ".env"), "utf-8");
+    assert.equal((raw.match(/GITHUB_TOKEN=/g) || []).length, 1);
+    assert.match(raw, /GITHUB_TOKEN=ghp_new/);
+    assert.match(raw, /OTHER=1/);
+});
+test("upsertEnvFile is a no-op the second time with the same values", () => {
+    upsertEnvFile(dir, { GITHUB_TOKEN: "ghp_abc" });
+    const before = readFileSync(join(dir, ".env"), "utf-8");
+    const result = upsertEnvFile(dir, { GITHUB_TOKEN: "ghp_abc" });
+    assert.deepEqual(result, { added: [], updated: [], unchanged: ["GITHUB_TOKEN"] });
+    assert.equal(readFileSync(join(dir, ".env"), "utf-8"), before);
+});
+test("readEnvFile ignores blank lines and comments, and returns an empty map for a missing file", () => {
+    writeFileSync(join(dir, ".env"), "# comment\n\nA=1\n  # indented comment\nB=2\n");
+    const values = readEnvFile(join(dir, ".env"));
+    assert.deepEqual([...values.entries()], [["A", "1"], ["B", "2"]]);
+    assert.equal(readEnvFile(join(dir, "nope.env")).size, 0);
+});
+test("maskSecret keeps only the last 4 characters; short values are fully masked", () => {
+    const value = "ghp_1234567890abcdef"; // 20 chars, last 4 = "cdef"
+    const masked = maskSecret(value);
+    assert.equal(masked.length, value.length);
+    assert.match(masked, /^•+cdef$/);
+    assert.equal(maskSecret("abcd"), "••••");
+    assert.equal(maskSecret("ab"), "••");
+});
+test("writeEnvExample writes key names with empty values, sorted and de-duplicated", () => {
+    writeEnvExample(dir, ["GITHUB_TOKEN", "JIRA_EMAIL", "GITHUB_TOKEN"]);
+    const raw = readFileSync(join(dir, ".env.example"), "utf-8");
+    assert.equal(raw, "# spf — keys required by this repo's spf.config.yaml; fill in real values in .env (gitignored)\nGITHUB_TOKEN=\nJIRA_EMAIL=\n");
+});
+test("writeEnvExample writes nothing when there are no keys", () => {
+    writeEnvExample(dir, []);
+    assert.equal(existsSync(join(dir, ".env.example")), false);
+});

package/dist/test/fake_asker.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Shared test double for `cli/ask.ts`'s `Asker` interface — the seam
+ * `runInterview` (`cli/interview.ts`) exists to be driven through, the same
+ * way `FakeProvider`/`FakeCodeHost` (`watch.test.ts`) stand in for
+ * `IssueProvider`/`CodeHostProvider`.
+ *
+ * Answers are keyed by a SUBSTRING of the question's label, not by call
+ * order — `runInterview` asks a different number of questions depending on
+ * earlier answers (skip a quality check, skip watch entirely, ...), so a
+ * positional queue would silently misalign the moment a test changes one
+ * answer. Substring matching keeps each scenario's script self-documenting
+ * and immune to that.
+ */
+import type { Asker } from "../cli/ask.js";
+export interface AskerScript {
+    text?: Record<string, string>;
+    select?: Record<string, string>;
+    confirm?: Record<string, boolean>;
+    secret?: Record<string, string>;
+    /** Used when a confirm's label matches nothing in `confirm` above. Defaults to the caller's own default. */
+    defaultConfirm?: boolean;
+}
+export declare function createFakeAsker(script: AskerScript): Asker;

package/dist/test/fake_asker.js

@@ -0,0 +1,30 @@
+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/init_command.test.d.ts

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

package/dist/test/init_command.test.js

@@ -0,0 +1,66 @@
+/**
+ * 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 { 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 } from "../cli/commands/init.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);
+});

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

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