@use-the-fork/spindle 0.0.0-stage → 0.0.1

package/build/Assets/Templates/project/domain.md

@@ -0,0 +1,51 @@
+# Domain Docs
+
+How the engineering skills should consume this repo's domain documentation when exploring the codebase.
+
+## Before exploring, read these
+
+- **`GLOSSARY.md`** at the repo root, or
+- **`GLOSSARY-MAP.md`** at the repo root if it exists: it points at one `GLOSSARY.md` per context. Read each one relevant to the topic.
+- **`docs/adr/`**: read ADRs that touch the area you're about to work in. In multi-context repos, also check `src/<context>/docs/adr/` for context-scoped decisions.
+
+If any of these files don't exist, **proceed silently**. Don't flag their absence; don't suggest creating them upfront. The `int-domain-modeling` skill (reached via the `/grill-with-docs` skill and `/improve-codebase-architecture` skill) creates them lazily when terms or decisions actually get resolved.
+
+## File structure
+
+Single-context repo (most repos):
+
+```
+/
+├── GLOSSARY.md
+├── docs/adr/
+│   ├── 0001-event-sourced-orders.md
+│   └── 0002-postgres-for-write-model.md
+└── src/
+```
+
+Multi-context repo (presence of `GLOSSARY-MAP.md` at the root):
+
+```
+/
+├── GLOSSARY-MAP.md
+├── docs/adr/                          ← system-wide decisions
+└── src/
+    ├── ordering/
+    │   ├── GLOSSARY.md
+    │   └── docs/adr/                  ← context-specific decisions
+    └── billing/
+        ├── GLOSSARY.md
+        └── docs/adr/
+```
+
+## Use the glossary's vocabulary
+
+When your output names a domain concept (in an issue title, a refactor proposal, a hypothesis, a test name), use the term as defined in `GLOSSARY.md`. Don't drift to synonyms the glossary explicitly avoids.
+
+If the concept you need isn't in the glossary yet, that's a signal: either you're inventing language the project doesn't use (reconsider) or there's a real gap (note it for the `int-domain-modeling` skill).
+
+## Flag ADR conflicts
+
+If your output contradicts an existing ADR, surface it explicitly rather than silently overriding:
+
+> _Contradicts ADR-0007 (event-sourced orders), but worth reopening because…_

package/build/Assets/Templates/project/ticket-tracker.md

@@ -0,0 +1,33 @@
+# Ticket Tracker: Local Markdown
+
+Spindle SDD stores feature work in `.scratch/` workspaces. A workspace contains an approved `spec.md`, its `sdd.json` execution ledger, `tickets/`, and `reports/`. A design is optional; when present, complete and approve it before the spec. Derive tickets from the approved spec.
+
+## Ticket format
+
+- Each ticket is `tickets/T-0001.md`, with IDs starting at `T-0001` independently in each feature. IDs use at least four digits.
+- `sdd.json` is authoritative for ticket metadata, status, dependencies, and execution state. Ticket Markdown contains only its ID in YAML front matter; requirements, acceptance criteria, and comments are the editable body.
+- Ticket creation copies the shared template, including `[REQUIREMENTS]` and `[ACCEPTANCE CRITERIA]` placeholders. Fill both before implementation.
+- Supported status values are `open`, `in-progress`, and `closed`. Dependencies must refer to existing tickets; cycles are rejected.
+- There is no migration or compatibility support for `issues/`, `I-####`, or previous SDD ledger schemas. Create a fresh feature workspace when using this ticket format.
+
+## Create and maintain tickets
+
+Create each approved ticket in dependency order:
+
+```sh
+spindle sdd ticket create --spec <absolute-spec-path> --title "..." --reporter "..." --category enhancement --author maintainer
+```
+
+The command returns the new ticket ID and path. Complete its template, then set dependencies with `ticket update`:
+
+```sh
+spindle sdd ticket update --spec <absolute-spec-path> --ticket T-0002 --blocked-by T-0001 --author maintainer
+spindle sdd ticket comment --spec <absolute-spec-path> --ticket T-0001 --details "..." --author maintainer
+spindle sdd ready --spec <absolute-spec-path>
+```
+
+Use `--clear-blocked-by` to remove dependencies. Use `ticket update --status` to change status. Ticket Markdown remains editable; attributed comments are appended under `## Comments`. Do not add an execution field to the ticket file: execution transitions are recorded in `sdd.json`.
+
+## Delivery
+
+Use `spindle sdd status` and `spindle sdd ready` to inspect work. Claim and dispatch ready tickets with `spindle sdd claim` and `spindle sdd implement`, submit the assigned report with `spindle sdd submit`, and close completed tickets with `spindle sdd ticket update --status closed`. Follow the `int-subagent-driven-dev` skill for review, correction, and feature completion.

package/build/Assets/Templates/sdd/design.md

@@ -0,0 +1,25 @@
+# {{ variables.title | default("[FEATURE TITLE]") }}
+
+## Intent
+
+{{ variables.intent | default("[INTENT]") }}
+
+## Success Criteria
+
+{{ variables.success_criteria | default("[SUCCESS CRITERIA]") }}
+
+## Scope and Constraints
+
+{{ variables.scope_and_constraints | default("[SCOPE AND CONSTRAINTS]") }}
+
+## Approaches Considered
+
+{{ variables.approaches_and_trade_offs | default("[APPROACHES AND TRADE-OFFS]") }}
+
+## Selected Direction
+
+{{ variables.selected_direction | default("[SELECTED DIRECTION]") }}
+
+## Assumptions and Open Decisions
+
+{{ variables.assumptions_and_open_decisions | default("[ASSUMPTIONS AND OPEN DECISIONS]") }}

package/build/Assets/Templates/sdd/spec.md

@@ -0,0 +1,29 @@
+# {{ variables.title | default("[FEATURE TITLE]") }}
+
+## Problem Statement
+
+{{ variables.problem_statement | default("[PROBLEM STATEMENT]") }}
+
+## Solution
+
+{{ variables.solution | default("[SOLUTION]") }}
+
+## User Stories
+
+{{ variables.user_stories | default("[USER STORIES]") }}
+
+## Implementation Decisions
+
+{{ variables.implementation_decisions | default("[IMPLEMENTATION DECISIONS]") }}
+
+## Testing Decisions
+
+{{ variables.testing_decisions | default("[TESTING DECISIONS]") }}
+
+## Out of Scope
+
+{{ variables.out_of_scope | default("[OUT OF SCOPE]") }}
+
+## Further Notes
+
+{{ variables.further_notes | default("[FURTHER NOTES]") }}

package/build/Assets/Templates/sdd/ticket.md

@@ -0,0 +1,15 @@
+# {{ variables.title | default("[TICKET TITLE]") }}
+
+- **Reporter:** {{ variables.reporter | default("[REPORTER]") }}
+- **Category:** {{ variables.category | default("[CATEGORY]") }}
+- **Author:** {{ variables.author | default("[AUTHOR]") }}
+
+## Requirements
+
+{{ variables.requirements | default("[REQUIREMENTS]") }}
+
+## Acceptance Criteria
+
+{{ variables.acceptance_criteria | default("[ACCEPTANCE CRITERIA]") }}
+
+## Comments

package/build/BlueprintManagement/BlueprintManagementServiceProvider.js

@@ -0,0 +1,15 @@
+import { InitCommand } from "./Commands/InitCommand.js";
+import { UpdateCommand } from "./Commands/UpdateCommand.js";
+import { BlueprintReconciliationService } from "./Services/BlueprintReconciliationService.js";
+import { InstallationService } from "./Services/InstallationService.js";
+import { ServiceProvider } from "../Foundation/ServiceProvider.js";
+export class BlueprintManagementServiceProvider extends ServiceProvider {
+    static commands() {
+        return [InitCommand, UpdateCommand];
+    }
+    register() {
+        this.app.singleton(BlueprintReconciliationService);
+        this.app.singleton(InstallationService);
+    }
+    async boot() { }
+}

package/build/BlueprintManagement/Catalog/BlueprintCatalog.js

@@ -0,0 +1,238 @@
+import { lstat, readdir } from "node:fs/promises";
+import { isAbsolute, join, relative, sep, win32 } from "node:path";
+import { blueprintCatalog as assetCatalog } from "../../Assets/Blueprints/Catalog.js";
+import { Stacks } from "../../Support/Stacks.js";
+const catalogKinds = ["agents", "instructions", "skills"];
+const allowedEntryFields = new Set(["path", "status", "stacks", "canReview"]);
+const requiredEntryFields = ["path", "status", "stacks"];
+const globCharacters = /[*?[\]{}]/;
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function validateCatalogPath(value, kind, key) {
+    if (typeof value !== "string" || value.length === 0) {
+        throw new Error(`Blueprint Catalog ${kind}.${key}.path must be a non-empty relative path.`);
+    }
+    const directory = value.endsWith("/");
+    const path = directory ? value.slice(0, -1) : value;
+    const segments = path.split("/");
+    if (path.length === 0 ||
+        path.includes("\\") ||
+        isAbsolute(path) ||
+        win32.isAbsolute(path) ||
+        segments.some((segment) => segment === "" || segment === "." || segment === "..") ||
+        globCharacters.test(path)) {
+        throw new Error(`Blueprint Catalog ${kind}.${key}.path '${value}' is unsafe; use a relative path without traversal or glob syntax.`);
+    }
+    return { path: segments.join("/"), directory };
+}
+export function validateBlueprintCatalog(data) {
+    if (!isRecord(data))
+        throw new Error("Blueprint Catalog must be an object.");
+    for (const key of Object.keys(data)) {
+        if (!catalogKinds.includes(key)) {
+            throw new Error(`Unknown Blueprint Catalog kind '${key}'.`);
+        }
+    }
+    for (const kind of catalogKinds) {
+        if (!Object.hasOwn(data, kind)) {
+            throw new Error(`Blueprint Catalog is missing required '${kind}' mapping.`);
+        }
+    }
+    const catalog = {};
+    for (const kind of catalogKinds) {
+        const section = data[kind];
+        if (!isRecord(section)) {
+            throw new Error(`Blueprint Catalog '${kind}' must be a mapping of logical keys to entries.`);
+        }
+        const entries = [];
+        for (const [key, rawEntry] of Object.entries(section)) {
+            if (key.length === 0 || !isRecord(rawEntry)) {
+                throw new Error(`Blueprint Catalog '${kind}.${key}' must be an entry mapping.`);
+            }
+            for (const field of Object.keys(rawEntry)) {
+                if (field === "canReview" && kind !== "agents") {
+                    throw new Error(`Field 'canReview' is only valid for Blueprint Catalog agents, not '${kind}'.`);
+                }
+                if (!allowedEntryFields.has(field)) {
+                    throw new Error(`Unknown field '${field}' in Blueprint Catalog entry '${kind}.${key}'.`);
+                }
+            }
+            for (const field of requiredEntryFields) {
+                if (!Object.hasOwn(rawEntry, field)) {
+                    throw new Error(`Blueprint Catalog '${kind}.${key}' is missing required '${field}'.`);
+                }
+            }
+            const { path, directory } = validateCatalogPath(rawEntry.path, kind, key);
+            if (rawEntry.status !== "active" && rawEntry.status !== "removed") {
+                throw new Error(`Invalid status in Blueprint Catalog '${kind}.${key}': expected 'active' or 'removed'.`);
+            }
+            if (!Array.isArray(rawEntry.stacks) ||
+                !rawEntry.stacks.every((stack) => typeof stack === "string")) {
+                throw new Error(`Blueprint Catalog '${kind}.${key}.stacks' must be a list of Stack names.`);
+            }
+            if (kind === "agents" &&
+                Object.hasOwn(rawEntry, "canReview") &&
+                typeof rawEntry.canReview !== "boolean") {
+                throw new Error(`Blueprint Catalog '${kind}.${key}.canReview' must be a boolean when supplied.`);
+            }
+            for (const stack of rawEntry.stacks) {
+                if (!Stacks.supported.includes(stack)) {
+                    throw new Error(`Invalid Stack '${stack}' in Blueprint Catalog '${kind}.${key}'. Supported Stacks: ${Stacks.supported.join(", ")}.`);
+                }
+            }
+            if (kind === "skills" && !directory) {
+                throw new Error(`Blueprint Catalog Skill path '${kind}.${key}' must select a directory.`);
+            }
+            entries.push({
+                key,
+                path,
+                directory,
+                status: rawEntry.status,
+                stacks: rawEntry.stacks,
+                ...(kind === "agents" && Object.hasOwn(rawEntry, "canReview")
+                    ? { canReview: rawEntry.canReview }
+                    : {}),
+            });
+        }
+        catalog[kind] = entries;
+    }
+    for (const kind of catalogKinds) {
+        const entries = catalog[kind];
+        for (let first = 0; first < entries.length; first += 1) {
+            for (let second = first + 1; second < entries.length; second += 1) {
+                const left = entries[first].path;
+                const right = entries[second].path;
+                if (left === right || left.startsWith(`${right}/`) || right.startsWith(`${left}/`)) {
+                    throw new Error(`Overlapping Blueprint Catalog paths in '${kind}': '${left}' and '${right}'.`);
+                }
+            }
+        }
+    }
+    return catalog;
+}
+async function assertNoSymlinkPath(root, path) {
+    let current = root;
+    for (const segment of path.split("/")) {
+        current = join(current, segment);
+        try {
+            if ((await lstat(current)).isSymbolicLink()) {
+                throw new Error(`Blueprint Catalog path '${path}' traverses symbolic link '${current}'.`);
+            }
+        }
+        catch (error) {
+            if (error.code === "ENOENT")
+                return;
+            throw error;
+        }
+    }
+}
+async function collectDirectoryFiles(source, root, result) {
+    for (const entry of await readdir(source, { withFileTypes: true })) {
+        const path = join(source, entry.name);
+        const stat = await lstat(path);
+        if (stat.isSymbolicLink()) {
+            throw new Error(`Blueprint directory '${relative(root, path)}' contains a symbolic link.`);
+        }
+        if (stat.isDirectory()) {
+            await collectDirectoryFiles(path, root, result);
+        }
+        else if (stat.isFile()) {
+            result.push(path);
+        }
+        else {
+            throw new Error(`Blueprint path '${relative(root, path)}' is not a regular file or directory.`);
+        }
+    }
+}
+export async function planBlueprintCatalog(catalog, kind, sourceRoot, selectedStacks) {
+    const selections = [];
+    const deletions = [];
+    const directories = [];
+    for (const entry of catalog[kind]) {
+        if (entry.status === "removed") {
+            deletions.push({ entry, path: entry.path, reason: "removed" });
+            continue;
+        }
+        await assertNoSymlinkPath(sourceRoot, entry.path);
+        const sourcePath = join(sourceRoot, ...entry.path.split("/"));
+        let stat;
+        try {
+            stat = await lstat(sourcePath);
+        }
+        catch (error) {
+            if (error.code === "ENOENT") {
+                throw new Error(`Active Blueprint Catalog entry '${kind}.${entry.key}' is missing source '${entry.path}'.`, { cause: error });
+            }
+            throw error;
+        }
+        if (entry.directory !== stat.isDirectory() || (!entry.directory && !stat.isFile())) {
+            throw new Error(`Blueprint Catalog source '${kind}.${entry.key}' has an incompatible type for '${entry.path}'.`);
+        }
+        let directoryFiles;
+        if (entry.directory) {
+            directoryFiles = [];
+            await collectDirectoryFiles(sourcePath, sourceRoot, directoryFiles);
+        }
+        if (kind === "skills") {
+            const entryFile = join(sourcePath, "SKILL.md");
+            try {
+                const entryStat = await lstat(entryFile);
+                if (!entryStat.isFile() || entryStat.isSymbolicLink()) {
+                    throw new Error(`Skill Blueprint '${entry.path}' must contain a regular SKILL.md file.`);
+                }
+            }
+            catch (error) {
+                if (error.code === "ENOENT") {
+                    throw new Error(`Skill Blueprint '${entry.path}' must contain a SKILL.md file.`, {
+                        cause: error,
+                    });
+                }
+                throw error;
+            }
+        }
+        if (entry.stacks.length > 0 && !entry.stacks.some((stack) => selectedStacks.includes(stack))) {
+            deletions.push({ entry, path: entry.path, reason: "stack-inapplicable" });
+            continue;
+        }
+        const files = [];
+        if (entry.directory) {
+            directories.push({
+                entry,
+                path: entry.path,
+                sourceFiles: directoryFiles.map((file) => relative(sourcePath, file).split(sep).join("/")),
+            });
+            for (const file of directoryFiles) {
+                files.push({
+                    sourcePath: file,
+                    outputPath: relative(sourcePath, file).split(sep).join("/"),
+                });
+            }
+        }
+        else {
+            files.push({ sourcePath, outputPath: entry.path.split("/").at(-1) });
+        }
+        if (kind === "agents" || kind === "instructions") {
+            for (const file of files) {
+                const outputPath = entry.directory
+                    ? relative(sourceRoot, file.sourcePath).split(sep).join("/")
+                    : entry.path;
+                selections.push({
+                    entry,
+                    name: outputPath,
+                    files: [{ ...file, outputPath }],
+                });
+            }
+        }
+        else {
+            selections.push({
+                entry,
+                name: entry.path,
+                files,
+            });
+        }
+    }
+    return { selections, deletions, directories };
+}
+validateBlueprintCatalog(assetCatalog);
+export const blueprintCatalog = assetCatalog;

package/build/BlueprintManagement/Commands/BlueprintCommandOptions.js

@@ -0,0 +1,9 @@
+import { Option } from "commander";
+export class BlueprintCommandOptions {
+    static conflictPolicyOption(description) {
+        return new Option("--on-conflict <overwrite|skip>", description).choices(["overwrite", "skip"]);
+    }
+    static noInteractiveOption(description) {
+        return new Option("--no-interactive", description);
+    }
+}

package/build/BlueprintManagement/Commands/ConflictPolicy.js

@@ -0,0 +1,6 @@
+export function parseConflictPolicy(policy) {
+    if (policy !== undefined && policy !== "overwrite" && policy !== "skip") {
+        throw new Error(`Invalid --on-conflict '${policy}'. Use overwrite or skip.`);
+    }
+    return policy;
+}

package/build/BlueprintManagement/Commands/InitCommand.js

@@ -0,0 +1,117 @@
+import chalk from "chalk";
+import { BlueprintCommandOptions } from "./BlueprintCommandOptions.js";
+import { parseConflictPolicy } from "./ConflictPolicy.js";
+import { promptConflict, promptSpindlePackageManager, promptStacks, } from "./Prompts.js";
+import { blueprintHandlers } from "../Handlers/BlueprintHandlers.js";
+import { BlueprintReconciliationService } from "../Services/BlueprintReconciliationService.js";
+import { Command } from "../../Commands/Command.js";
+import { LoadProjectConfiguration, } from "../../Foundation/Bootstrap/LoadProjectConfiguration.js";
+import { ProjectService } from "../../Project/Services/ProjectService.js";
+import { Stacks } from "../../Support/Stacks.js";
+export class InitCommand extends Command {
+    handlers = [];
+    reconciliationService;
+    static normalizeSpindlePackageManager(command) {
+        const normalized = command.trim();
+        if (normalized.length === 0 || /[\r\n]/.test(normalized)) {
+            throw new Error("--spindle-package-manager must be a non-empty, single-line command.");
+        }
+        return normalized;
+    }
+    static register(program, createApp) {
+        program
+            .command("init")
+            .description("Install spindle Blueprints and initialize project guidance at the Git root.")
+            .option("--stack <id>", `Stack to install; repeat for several (${Stacks.supported.join(", ")})`, (value, previous = []) => [...previous, value], [])
+            .option("--spindle-package-manager <command>", "Package-manager command prefix used in generated tooling guidance")
+            .addOption(BlueprintCommandOptions.conflictPolicyOption("Policy for Blueprints that already exist; required when non-interactive and any exist (interactive runs prompt per Blueprint)"))
+            .addOption(BlueprintCommandOptions.noInteractiveOption("Never prompt; missing required input is an error"))
+            .addHelpText("after", `
+If Blueprint stacks are already configured, project guidance is initialized and
+\`spindle update\` is required to change the installed Blueprints.
+Prompts are also disabled when stdin or stdout is not a terminal.
+Other commands: update (see \`spindle update --help\`), tool (see \`spindle tool --help\`), sdd (see \`spindle sdd --help\`).
+Run \`spindle --version\` to print the installed version.
+`)
+            .allowExcessArguments(false)
+            .action(async (options) => {
+            const interactive = options.interactive && Boolean(process.stdin.isTTY) && Boolean(process.stdout.isTTY);
+            const policy = parseConflictPolicy(options.onConflict);
+            Stacks.validate(options.stack);
+            const spindlePackageManager = options.spindlePackageManager === undefined
+                ? undefined
+                : InitCommand.normalizeSpindlePackageManager(options.spindlePackageManager);
+            if (!interactive && options.stack.length === 0) {
+                throw new Error(`Provide at least one --stack flag <${Stacks.supported.join("|")}> (or run interactively).`);
+            }
+            await (await (await createApp()).make(InitCommand)).run(options.stack, spindlePackageManager, interactive, policy);
+        });
+    }
+    constructor(app) {
+        super(app);
+    }
+    async boot() {
+        this.handlers = blueprintHandlers;
+        this.reconciliationService = await this.app.make(BlueprintReconciliationService);
+    }
+    async run(stackArguments, packageManagerArgument, interactive, policy) {
+        this.assertApplicationBooted();
+        const existing = LoadProjectConfiguration.current(this.app);
+        if (existing.status === "invalid") {
+            throw new Error(existing.reason, { cause: existing.error });
+        }
+        if (existing.status === "valid" && existing.data.stacks.length > 0) {
+            await (await this.app.make(ProjectService)).initialize();
+            console.log(`${chalk.green("✔")} Initialized project guidance and tooling documentation.`);
+            throw new Error("This repository already has configured Blueprint stacks; run `spindle update` instead of `init`.");
+        }
+        let stacks = [...new Set(stackArguments)];
+        Stacks.validate(stacks);
+        if (stacks.length === 0) {
+            if (!interactive) {
+                throw new Error(`Provide at least one --stack flag <${Stacks.supported.join("|")}> (or run interactively).`);
+            }
+            stacks = await promptStacks(Stacks.supported);
+        }
+        let spindlePackageManager = packageManagerArgument ??
+            (existing.status === "valid" ? existing.data.spindle_package_manager : undefined);
+        if (spindlePackageManager === undefined && interactive) {
+            spindlePackageManager = await promptSpindlePackageManager();
+        }
+        if (spindlePackageManager === undefined) {
+            throw new Error("A package-manager command is required; provide --spindle-package-manager <command> or run interactively.");
+        }
+        spindlePackageManager = InitCommand.normalizeSpindlePackageManager(spindlePackageManager);
+        const config = {
+            ...(existing.status === "valid" ? existing.data : {}),
+            stacks,
+            spindle_package_manager: spindlePackageManager,
+        };
+        delete config.variables;
+        const outcomes = await this.reconciliationService.reconcile(this.handlers, {
+            mode: "init",
+            context: { stacks, variables: {} },
+            config,
+            conflictPolicy: policy,
+            chooseConflict: interactive ? promptConflict : undefined,
+        });
+        await LoadProjectConfiguration.refresh(this.app);
+        for (const outcome of outcomes.filter((item) => item.status === "removed")) {
+            console.log(`${chalk.green("✔")} Removed ${outcome.kind.toLowerCase()} '${outcome.name}'`);
+        }
+        const kinds = [...new Set(outcomes.map((outcome) => outcome.kind))];
+        const counts = (status) => kinds
+            .map((kind) => ({
+            kind,
+            count: outcomes.filter((outcome) => outcome.kind === kind && outcome.status === status)
+                .length,
+        }))
+            .filter(({ count }) => status === "installed" || count > 0)
+            .map(({ kind, count }) => `${count} ${status === "skipped" ? "existing " : ""}${kind.toLowerCase()}(s)`)
+            .join(", ");
+        const skipped = counts("skipped");
+        console.log(`${chalk.green("✔")} Installed ${counts("installed") || "0 Blueprints"} for ${chalk.cyan(stacks.join(", "))}${skipped ? `. Skipped ${skipped}` : ""}`);
+        await (await this.app.make(ProjectService)).initialize();
+        console.log(`${chalk.green("✔")} Initialized project guidance and tooling documentation.`);
+    }
+}

package/build/BlueprintManagement/Commands/Prompts.js

@@ -0,0 +1,66 @@
+import { cancel, isCancel, multiselect, select, text } from "@clack/prompts";
+function ensureAnswer(answer) {
+    // clack signals cancellation with a unique symbol
+    if (typeof answer === "symbol" && isCancel(answer)) {
+        cancel("Cancelled.");
+        throw new Error("Cancelled by user.");
+    }
+    return answer;
+}
+export async function promptStacks(supported) {
+    const answer = await multiselect({
+        message: "Which stacks does this project use?",
+        options: supported.map((value) => ({ value, label: value })),
+        required: true,
+    });
+    return ensureAnswer(answer);
+}
+export async function promptSpindlePackageManager() {
+    const answer = await select({
+        message: "Which package-manager command should Spindle use in generated guidance?",
+        options: [
+            { value: "npm run", label: "npm run" },
+            { value: "pnpm", label: "pnpm" },
+            { value: "yarn", label: "yarn" },
+            { value: "bun", label: "bun" },
+            { value: "other", label: "Other" },
+        ],
+    });
+    const selection = ensureAnswer(answer);
+    if (selection !== "other")
+        return selection;
+    const custom = await text({
+        message: "Enter the package-manager command prefix",
+        validate: (value) => (value ?? "").trim().length === 0 ? "A command prefix is required." : undefined,
+    });
+    return ensureAnswer(custom).trim();
+}
+export async function promptConflict(kind, name) {
+    const answer = await select({
+        message: `${kind} '${name}' already exists. What should happen?`,
+        options: [
+            { value: "overwrite", label: "Overwrite" },
+            { value: "skip", label: "Skip" },
+        ],
+    });
+    return ensureAnswer(answer);
+}
+export async function promptOutdated(kind, name, installed, available) {
+    const answer = await select({
+        message: `${kind} '${name}' is outdated (installed ${installed}, available ${available}). What should happen?`,
+        options: [
+            { value: "overwrite", label: "Overwrite" },
+            { value: "skip", label: "Skip" },
+        ],
+    });
+    return ensureAnswer(answer);
+}
+export async function promptNewBlueprints(kind, names) {
+    const answer = await multiselect({
+        message: `Which new ${kind}s should be installed?`,
+        options: names.map((value) => ({ value, label: value })),
+        initialValues: names,
+        required: false,
+    });
+    return ensureAnswer(answer);
+}