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

package/build/SubagentDrivenDevelopment/Commands/ReviewCommand.js

@@ -0,0 +1,55 @@
+import { Command } from "../../Commands/Command.js";
+import { reviewSchema } from "./groups.js";
+import { ReviewRequireCommand } from "./ReviewRequireCommand.js";
+import { ReviewService } from "../Services/ReviewService.js";
+export class ReviewCommand extends Command {
+    static register(root, createApp) {
+        reviewSchema(root).action(async (action, options) => {
+            if (action === "require") {
+                if (options.type && options.agent && options.type !== options.agent) {
+                    throw new Error("--type and --agent must identify the same review agent.");
+                }
+                const reviewType = options.type ?? options.agent;
+                if (options.scope !== "delivery") {
+                    throw new Error("Feature review requirements need --scope delivery.");
+                }
+                if (!options.spec || !reviewType || !options.details || !options.author) {
+                    throw new Error("review require needs --spec, --scope delivery, --type, --details, and --author.");
+                }
+                if (options.inventory)
+                    throw new Error("--inventory is not valid with 'review require'.");
+                const command = await (await createApp()).make(ReviewRequireCommand);
+                console.log(JSON.stringify(await command.run({
+                    ...options,
+                    spec: options.spec,
+                    type: reviewType,
+                    details: options.details,
+                    author: options.author,
+                }), null, 2));
+                return;
+            }
+            if (action !== undefined)
+                throw new Error(`Unknown review action: ${action}.`);
+            if (options.type || options.agent || options.details) {
+                throw new Error("--type, --agent, and --details are only valid with 'review require'.");
+            }
+            if (!options.spec ||
+                options.scope !== "delivery" ||
+                !options.inventory ||
+                !options.author) {
+                throw new Error("Feature review requires --spec, --scope delivery, --inventory, and --author.");
+            }
+            const command = await (await createApp()).make(ReviewCommand);
+            console.log(JSON.stringify(await command.run({
+                ...options,
+                spec: options.spec,
+                inventory: options.inventory,
+                author: options.author,
+            }), null, 2));
+        });
+    }
+    async run(options) {
+        this.assertApplicationBooted();
+        return (await this.app.make(ReviewService)).review(options);
+    }
+}

package/build/SubagentDrivenDevelopment/Commands/ReviewRequireCommand.js

@@ -0,0 +1,12 @@
+import { Command } from "../../Commands/Command.js";
+import { reviewSchema } from "./groups.js";
+import { ReviewService } from "../Services/ReviewService.js";
+export class ReviewRequireCommand extends Command {
+    static register(root, _createApp) {
+        reviewSchema(root);
+    }
+    async run(options) {
+        this.assertApplicationBooted();
+        return (await this.app.make(ReviewService)).reviewRequire(options);
+    }
+}

package/build/SubagentDrivenDevelopment/Commands/StatusCommand.js

@@ -0,0 +1,21 @@
+import { Command } from "../../Commands/Command.js";
+import { CommandOptions } from "../../Commands/CommandOptions.js";
+import { group } from "./groups.js";
+import { FeatureInspectionService } from "../Services/FeatureInspectionService.js";
+export class StatusCommand extends Command {
+    static register(root, createApp) {
+        group(root)
+            .command("status")
+            .description("Inspect state, permitted actions, assignments, and blockers.")
+            .requiredOption("--spec <path>", "Feature spec path", CommandOptions.once("--spec"))
+            .allowExcessArguments(false)
+            .action(async (options) => {
+            const command = await (await createApp()).make(StatusCommand);
+            console.log(JSON.stringify(await command.run(options), null, 2));
+        });
+    }
+    async run(options) {
+        this.assertApplicationBooted();
+        return (await this.app.make(FeatureInspectionService)).status(options);
+    }
+}

package/build/SubagentDrivenDevelopment/Commands/SubmitCommand.js

@@ -0,0 +1,59 @@
+import { Command } from "../../Commands/Command.js";
+import { CommandOptions } from "../../Commands/CommandOptions.js";
+import { group } from "./groups.js";
+import { SubmissionService } from "../Services/SubmissionService.js";
+export class SubmitCommand extends Command {
+    static register(root, createApp) {
+        let findingsDeclared = false;
+        let noFindingsDeclared = false;
+        const submitCommand = group(root)
+            .command("submit")
+            .description("Register an implementation or review report.")
+            .requiredOption("--spec <path>", "Feature spec path", CommandOptions.once("--spec"))
+            .option("--ticket <id>", "Ticket ID", CommandOptions.once("--ticket"))
+            .option("--scope <scope>", "Workflow scope: delivery")
+            .requiredOption("--role <role>", "Assignment role")
+            .option("--assignment <id>", "Exact review assignment ID", CommandOptions.once("--assignment"))
+            .option("--report <path>", "Implementation report path", CommandOptions.once("--report"))
+            .option("--result <result>", "Review result: passed, failed, unavailable", CommandOptions.once("--result"))
+            .option("--findings <ids...>", "Complete canonical finding ID list for this report")
+            .option("--no-findings", "Explicitly attest that the review report has no findings")
+            .option("--unavailable", "Record that the assigned report is unavailable")
+            .option("--details <details>", "Required details for failed or unavailable results", CommandOptions.once("--details"))
+            .requiredOption("--author <author>", "Controller author", CommandOptions.once("--author"))
+            .allowExcessArguments(false);
+        submitCommand.on("option:findings", () => {
+            findingsDeclared = true;
+        });
+        submitCommand.on("option:no-findings", () => {
+            noFindingsDeclared = true;
+        });
+        submitCommand.action(async (options) => {
+            const command = await (await createApp()).make(SubmitCommand);
+            if (options.scope !== undefined && options.scope !== "delivery") {
+                throw new Error("--scope must be 'delivery'.");
+            }
+            if (Boolean(options.ticket) === (options.scope === "delivery")) {
+                throw new Error("submit needs exactly one of --ticket or --scope delivery.");
+            }
+            if (findingsDeclared && noFindingsDeclared) {
+                throw new Error("--findings and --no-findings cannot be combined.");
+            }
+            const { findings, ...submission } = options;
+            console.log(JSON.stringify(await command.run({
+                ...submission,
+                ...(options.role === "review"
+                    ? findings === false
+                        ? { noFindings: true }
+                        : Array.isArray(findings)
+                            ? { findingIds: findings }
+                            : {}
+                    : {}),
+            }), null, 2));
+        });
+    }
+    async run(options) {
+        this.assertApplicationBooted();
+        return (await this.app.make(SubmissionService)).submit(options);
+    }
+}

package/build/SubagentDrivenDevelopment/Commands/TicketCommentCommand.js

@@ -0,0 +1,24 @@
+import { Command } from "../../Commands/Command.js";
+import { CommandOptions } from "../../Commands/CommandOptions.js";
+import { group } from "./groups.js";
+import { TicketService } from "../Services/TicketService.js";
+export class TicketCommentCommand extends Command {
+    static register(root, createApp) {
+        group(root, "ticket")
+            .command("comment")
+            .description("Append an attributed ticket comment.")
+            .requiredOption("--spec <path>", "Feature spec path", CommandOptions.once("--spec"))
+            .requiredOption("--ticket <id>", "Ticket ID", CommandOptions.once("--ticket"))
+            .requiredOption("--details <details>", "Comment text", CommandOptions.once("--details"))
+            .requiredOption("--author <author>", "Acting author", CommandOptions.once("--author"))
+            .allowExcessArguments(false)
+            .action(async (options) => {
+            const command = await (await createApp()).make(TicketCommentCommand);
+            console.log(JSON.stringify(await command.run(options), null, 2));
+        });
+    }
+    async run(options) {
+        this.assertApplicationBooted();
+        return (await this.app.make(TicketService)).ticketComment(options);
+    }
+}

package/build/SubagentDrivenDevelopment/Commands/TicketCreateCommand.js

@@ -0,0 +1,25 @@
+import { Command } from "../../Commands/Command.js";
+import { CommandOptions } from "../../Commands/CommandOptions.js";
+import { group } from "./groups.js";
+import { TicketService } from "../Services/TicketService.js";
+export class TicketCreateCommand extends Command {
+    static register(root, createApp) {
+        group(root, "ticket")
+            .command("create")
+            .description("Create an attributed ticket in the selected feature.")
+            .requiredOption("--spec <path>", "Feature spec path", CommandOptions.once("--spec"))
+            .requiredOption("--title <title>", "Ticket title", CommandOptions.once("--title"))
+            .requiredOption("--reporter <reporter>", "Ticket reporter", CommandOptions.once("--reporter"))
+            .requiredOption("--category <category>", "Ticket category", CommandOptions.once("--category"))
+            .requiredOption("--author <author>", "Acting author", CommandOptions.once("--author"))
+            .allowExcessArguments(false)
+            .action(async (options) => {
+            const command = await (await createApp()).make(TicketCreateCommand);
+            console.log(JSON.stringify(await command.run(options), null, 2));
+        });
+    }
+    async run(options) {
+        this.assertApplicationBooted();
+        return (await this.app.make(TicketService)).ticketCreate(options);
+    }
+}

package/build/SubagentDrivenDevelopment/Commands/TicketUpdateCommand.js

@@ -0,0 +1,31 @@
+import { Command } from "../../Commands/Command.js";
+import { CommandOptions } from "../../Commands/CommandOptions.js";
+import { group } from "./groups.js";
+import { TicketService } from "../Services/TicketService.js";
+export class TicketUpdateCommand extends Command {
+    static register(root, createApp) {
+        group(root, "ticket")
+            .command("update")
+            .description("Update ticket fields, status, blocker, or dependencies.")
+            .requiredOption("--spec <path>", "Feature spec path", CommandOptions.once("--spec"))
+            .requiredOption("--ticket <id>", "Ticket ID", CommandOptions.once("--ticket"))
+            .option("--title <title>", "Updated ticket title", CommandOptions.once("--title"))
+            .option("--reporter <reporter>", "Updated ticket reporter", CommandOptions.once("--reporter"))
+            .option("--category <category>", "Ticket category: bug or enhancement")
+            .option("--status <status>", "Ticket status: open, in-progress, or closed")
+            .option("--blocker <reason>", "Explicit reason the ticket cannot proceed")
+            .option("--clear-blocker", "Remove the explicit ticket blocker")
+            .option("--blocked-by <tickets...>", "Authoritative dependency ticket IDs")
+            .option("--clear-blocked-by", "Remove all ticket dependencies")
+            .requiredOption("--author <author>", "Acting author", CommandOptions.once("--author"))
+            .allowExcessArguments(false)
+            .action(async (options) => {
+            const command = await (await createApp()).make(TicketUpdateCommand);
+            console.log(JSON.stringify(await command.run(options), null, 2));
+        });
+    }
+    async run(options) {
+        this.assertApplicationBooted();
+        return (await this.app.make(TicketService)).ticketUpdate(options);
+    }
+}

package/build/SubagentDrivenDevelopment/Commands/groups.js

@@ -0,0 +1,36 @@
+import { CommandOptions } from "../../Commands/CommandOptions.js";
+const descriptions = {
+    ticket: "Create and maintain feature tickets.",
+    finding: "Register canonical review findings and explicit rulings.",
+    requirements: "Record explicit requirements decisions before fresh review.",
+    checks: "Declare and record required checks.",
+};
+export function group(root, name) {
+    const program = root.commands.find((command) => command.name() === "sdd") ??
+        root
+            .command("sdd")
+            .description("Subagent-driven development workflow")
+            .allowExcessArguments(false);
+    if (!name)
+        return program;
+    return (program.commands.find((command) => command.name() === name) ??
+        program.command(name).description(descriptions[name]));
+}
+export function reviewSchema(root) {
+    const program = group(root);
+    const existing = program.commands.find((command) => command.name() === "review");
+    if (existing)
+        return existing;
+    return program
+        .command("review")
+        .description("Require a specialist or freeze the feature inventory for review.")
+        .argument("[action]", "Use 'require' to pin a justified specialist reviewer")
+        .option("--spec <path>", "Feature spec path", CommandOptions.once("--spec"))
+        .option("--scope <scope>", "Workflow scope: delivery")
+        .option("--inventory <json>", "Controller-confirmed Git-derived inventory as a JSON string array", CommandOptions.once("--inventory"))
+        .option("--author <author>", "Controller author", CommandOptions.once("--author"))
+        .option("--type <name>", "Review-eligible Blueprint agent key to require", CommandOptions.once("--type"))
+        .option("--agent <name>", "Alias for --type", CommandOptions.once("--agent"))
+        .option("--details <text>", "Justified specialist review objective", CommandOptions.once("--details"))
+        .allowExcessArguments(false);
+}