sdd-cli 0.1.11 → 0.1.13

package/README.md

@@ -119,6 +119,7 @@ Project names must use letters, numbers, spaces, `-` or `_`, and cannot include
 
 The `hello` command is the entry point: it connects to AI, lists active projects, and offers to create a new one or continue.  
 Default behavior is now a guided autopilot from discovery to completion with minimal prompts.  
+When you pass direct intent text (`sdd-cli hello "..."`), hello uses auto-guided defaults and minimizes confirmations.  
 Use `--questions` when you want the manual question-by-question flow.
 
 ## The happy path (end-to-end flow)
@@ -203,6 +204,15 @@ sdd-cli hello "I want a simple booking system for appointments"
 5) Check output in:
 `<workspace>/<project>/requirements/done/<REQ-ID>/`
 
+## Recovery quick commands
+
+- Continue an existing project:
+`sdd-cli --project <project-name> hello "continue"`
+- Resume from a specific stage:
+`sdd-cli --project <project-name> --from-step test hello "resume"`
+- Script-safe full default run:
+`sdd-cli --non-interactive hello "<your intent>"`
+
 ## Where files are stored (clean repos)
 
 By default, the tool writes to a dedicated workspace, not into your repo:

package/dist/cli.js

@@ -66,6 +66,7 @@ program
     .option("--improve", "Trigger self-audit and regenerate")
     .option("--parallel", "Generate in parallel when supported")
     .option("--non-interactive", "Run with defaults and without prompt confirmations")
+    .option("--from-step <step>", "Resume or start autopilot from step: create|plan|start|test|finish")
     .option("--project <name>", "Select or name the project")
     .option("--output <path>", "Override workspace output root");
 program.hook("preAction", (thisCommand, actionCommand) => {
@@ -75,6 +76,7 @@ program.hook("preAction", (thisCommand, actionCommand) => {
         improve: Boolean(opts.improve),
         parallel: Boolean(opts.parallel),
         nonInteractive: Boolean(opts.nonInteractive),
+        fromStep: typeof opts.fromStep === "string" ? opts.fromStep : undefined,
         project: typeof opts.project === "string" ? opts.project : undefined,
         output: typeof opts.output === "string" ? opts.output : undefined
     });

package/dist/commands/autopilot-checkpoint.d.ts

@@ -0,0 +1,16 @@
+export declare const AUTOPILOT_STEPS: readonly ["create", "plan", "start", "test", "finish"];
+export type AutopilotStep = (typeof AUTOPILOT_STEPS)[number];
+export type AutopilotCheckpoint = {
+    project: string;
+    reqId: string;
+    seedText: string;
+    flow: string;
+    domain: string;
+    lastCompleted: AutopilotStep;
+    updatedAt: string;
+};
+export declare function normalizeStep(step?: string): AutopilotStep | null;
+export declare function loadCheckpoint(projectName: string): AutopilotCheckpoint | null;
+export declare function saveCheckpoint(projectName: string, checkpoint: AutopilotCheckpoint): void;
+export declare function clearCheckpoint(projectName: string): void;
+export declare function nextStep(step: AutopilotStep): AutopilotStep | null;

package/dist/commands/autopilot-checkpoint.js

@@ -0,0 +1,64 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AUTOPILOT_STEPS = void 0;
+exports.normalizeStep = normalizeStep;
+exports.loadCheckpoint = loadCheckpoint;
+exports.saveCheckpoint = saveCheckpoint;
+exports.clearCheckpoint = clearCheckpoint;
+exports.nextStep = nextStep;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const index_1 = require("../workspace/index");
+exports.AUTOPILOT_STEPS = ["create", "plan", "start", "test", "finish"];
+function checkpointPath(projectName) {
+    const workspace = (0, index_1.getWorkspaceInfo)();
+    const project = (0, index_1.getProjectInfo)(workspace, projectName);
+    return path_1.default.join(project.root, ".autopilot-checkpoint.json");
+}
+function normalizeStep(step) {
+    if (!step)
+        return null;
+    const raw = step.trim().toLowerCase();
+    const map = {
+        create: "create",
+        plan: "plan",
+        start: "start",
+        test: "test",
+        "test-plan": "test",
+        finish: "finish"
+    };
+    return map[raw] ?? null;
+}
+function loadCheckpoint(projectName) {
+    const file = checkpointPath(projectName);
+    if (!fs_1.default.existsSync(file)) {
+        return null;
+    }
+    try {
+        return JSON.parse(fs_1.default.readFileSync(file, "utf-8"));
+    }
+    catch {
+        return null;
+    }
+}
+function saveCheckpoint(projectName, checkpoint) {
+    const file = checkpointPath(projectName);
+    fs_1.default.mkdirSync(path_1.default.dirname(file), { recursive: true });
+    fs_1.default.writeFileSync(file, JSON.stringify(checkpoint, null, 2), "utf-8");
+}
+function clearCheckpoint(projectName) {
+    const file = checkpointPath(projectName);
+    if (fs_1.default.existsSync(file)) {
+        fs_1.default.rmSync(file, { force: true });
+    }
+}
+function nextStep(step) {
+    const idx = exports.AUTOPILOT_STEPS.indexOf(step);
+    if (idx < 0 || idx + 1 >= exports.AUTOPILOT_STEPS.length) {
+        return null;
+    }
+    return exports.AUTOPILOT_STEPS[idx + 1];
+}

package/dist/commands/hello.js

@@ -13,12 +13,16 @@ const req_start_1 = require("./req-start");
 const req_finish_1 = require("./req-finish");
 const route_1 = require("./route");
 const test_plan_1 = require("./test-plan");
+const autopilot_checkpoint_1 = require("./autopilot-checkpoint");
 function printStep(step, description) {
     console.log(`${step}: ${description}`);
 }
 function printWhy(message) {
     console.log(`  -> ${message}`);
 }
+function printRecoveryNext(project, step, hint) {
+    console.log(`Next command: sdd-cli --project "${project}" --from-step ${step} hello "${hint}"`);
+}
 function deriveProjectName(input, flow) {
     const seed = input
         .trim()
@@ -98,35 +102,38 @@ async function runHello(input, runQuestions) {
         return { workspace, projects };
     }
     let { workspace, projects } = loadWorkspace();
+    const runtimeFlags = (0, flags_1.getFlags)();
+    const hasDirectIntent = input.trim().length > 0;
+    const shouldRunQuestions = runQuestions === true;
+    const autoGuidedMode = !shouldRunQuestions && (runtimeFlags.nonInteractive || hasDirectIntent);
     console.log("Hello from sdd-cli.");
     console.log(`Workspace: ${workspace.root}`);
-    const useWorkspace = await (0, prompt_1.confirm)("Use this workspace path? (y/n) ");
-    if (!useWorkspace) {
-        const nextPath = await (0, prompt_1.ask)("Workspace path to use (blank to exit): ");
-        if (!nextPath) {
-            console.log("Run again from the desired folder or pass --output <path>.");
-            return;
+    if (autoGuidedMode) {
+        printWhy("Auto-guided mode active: using current workspace defaults.");
+    }
+    else {
+        const useWorkspace = await (0, prompt_1.confirm)("Use this workspace path? (y/n) ");
+        if (!useWorkspace) {
+            const nextPath = await (0, prompt_1.ask)("Workspace path to use (blank to exit): ");
+            if (!nextPath) {
+                console.log("Run again from the desired folder or pass --output <path>.");
+                return;
+            }
+            (0, flags_1.setFlags)({ output: nextPath });
+            const reloaded = loadWorkspace();
+            workspace = reloaded.workspace;
+            projects = reloaded.projects;
+            console.log(`Workspace updated: ${workspace.root}`);
         }
-        (0, flags_1.setFlags)({ output: nextPath });
-        const reloaded = loadWorkspace();
-        workspace = reloaded.workspace;
-        projects = reloaded.projects;
-        console.log(`Workspace updated: ${workspace.root}`);
     }
-    const flags = (0, flags_1.getFlags)();
     if (projects.length > 0) {
         console.log("Active projects:");
         projects.forEach((project) => {
             console.log(`- ${project.name} (${project.status})`);
         });
-        const choice = await (0, prompt_1.ask)("Start new or continue? (new/continue) ");
-        const normalized = choice.trim().toLowerCase();
-        if (normalized === "continue") {
-            const selected = flags.project || (await (0, prompt_1.ask)("Project to continue: "));
-            if (!selected) {
-                console.log("No project selected. Continuing with new flow.");
-            }
-            else if (!projects.find((project) => project.name === selected)) {
+        if (runtimeFlags.project) {
+            const selected = runtimeFlags.project.trim();
+            if (!projects.find((project) => project.name === selected)) {
                 console.log(`Project not found: ${selected}. Continuing with new flow.`);
             }
             else {
@@ -134,14 +141,49 @@ async function runHello(input, runQuestions) {
                 console.log(`Continuing: ${selected}`);
             }
         }
+        else if (!autoGuidedMode) {
+            const choice = await (0, prompt_1.ask)("Start new or continue? (new/continue) ");
+            const normalized = choice.trim().toLowerCase();
+            if (normalized === "continue") {
+                const selected = await (0, prompt_1.ask)("Project to continue: ");
+                if (!selected) {
+                    console.log("No project selected. Continuing with new flow.");
+                }
+                else if (!projects.find((project) => project.name === selected)) {
+                    console.log(`Project not found: ${selected}. Continuing with new flow.`);
+                }
+                else {
+                    (0, flags_1.setFlags)({ project: selected });
+                    console.log(`Continuing: ${selected}`);
+                }
+            }
+            else {
+                console.log(`Selected: ${choice || "new"}`);
+            }
+        }
         else {
-            console.log(`Selected: ${choice || "new"}`);
+            console.log("Auto-selected: new flow.");
         }
     }
     else {
         console.log("No active projects found.");
     }
-    const text = input || (await (0, prompt_1.ask)("Describe what you want to do: "));
+    let text = input || (await (0, prompt_1.ask)("Describe what you want to do: "));
+    let checkpoint = null;
+    let fromStep = (0, autopilot_checkpoint_1.normalizeStep)(runtimeFlags.fromStep);
+    let activeProjectForCheckpoint = runtimeFlags.project;
+    if (!shouldRunQuestions && activeProjectForCheckpoint) {
+        checkpoint = (0, autopilot_checkpoint_1.loadCheckpoint)(activeProjectForCheckpoint);
+        if (!text && checkpoint?.seedText) {
+            text = checkpoint.seedText;
+        }
+        if (!fromStep && checkpoint?.lastCompleted) {
+            const candidate = (0, autopilot_checkpoint_1.nextStep)(checkpoint.lastCompleted);
+            if (candidate) {
+                fromStep = candidate;
+            }
+        }
+    }
     if (!text) {
         console.log("No input provided. Try again with a short description.");
         return;
@@ -157,7 +199,6 @@ async function runHello(input, runQuestions) {
     else {
         console.log("Next: run `sdd-cli route <your input>` to view details.");
     }
-    const shouldRunQuestions = runQuestions === true;
     printStep("Step 2/7", "Requirement setup");
     printWhy("I will gather enough context to generate a valid first draft.");
     if (shouldRunQuestions) {
@@ -195,8 +236,13 @@ async function runHello(input, runQuestions) {
     else {
         let activeProject = (0, flags_1.getFlags)().project;
         if (!activeProject) {
-            const quickProject = await (0, prompt_1.ask)("Project name (optional, press Enter to auto-generate): ");
-            activeProject = quickProject || deriveProjectName(text, intent.flow);
+            if (autoGuidedMode) {
+                activeProject = deriveProjectName(text, intent.flow);
+            }
+            else {
+                const quickProject = await (0, prompt_1.ask)("Project name (optional, press Enter to auto-generate): ");
+                activeProject = quickProject || deriveProjectName(text, intent.flow);
+            }
         }
         if (!activeProject) {
             console.log("Project name is required to run autopilot.");
@@ -204,64 +250,116 @@ async function runHello(input, runQuestions) {
         }
         printWhy(`Using project: ${activeProject}`);
         (0, flags_1.setFlags)({ project: activeProject });
-        const draft = buildAutopilotDraft(text, intent.flow, intent.domain);
-        draft.project_name = activeProject;
-        printStep("Step 3/7", "Creating requirement draft automatically");
-        printWhy("This creates your baseline scope, acceptance criteria, and NFRs.");
-        const created = await (0, req_create_1.runReqCreate)(draft, { autofill: true });
-        if (!created) {
-            console.log("Autopilot stopped at requirement creation.");
-            return;
+        checkpoint = (0, autopilot_checkpoint_1.loadCheckpoint)(activeProject);
+        if (checkpoint && !fromStep) {
+            const candidate = (0, autopilot_checkpoint_1.nextStep)(checkpoint.lastCompleted);
+            if (candidate) {
+                fromStep = candidate;
+            }
         }
-        printStep("Step 4/7", `Planning requirement ${created.reqId}`);
-        printWhy("I am generating functional, technical, architecture, and test artifacts.");
-        const planned = await (0, req_plan_1.runReqPlan)({
-            projectName: activeProject,
-            reqId: created.reqId,
-            autofill: true,
-            seedText: text
-        });
-        if (!planned) {
-            console.log("Autopilot stopped at planning.");
+        if (fromStep && !autopilot_checkpoint_1.AUTOPILOT_STEPS.includes(fromStep)) {
+            console.log(`Invalid --from-step value. Use one of: ${autopilot_checkpoint_1.AUTOPILOT_STEPS.join(", ")}`);
             return;
         }
-        printStep("Step 5/7", `Preparing implementation plan for ${created.reqId}`);
-        printWhy("This stage defines milestones, tasks, quality thresholds, and decisions.");
-        const started = await (0, req_start_1.runReqStart)({
-            projectName: activeProject,
-            reqId: created.reqId,
-            autofill: true,
-            seedText: text
-        });
-        if (!started) {
-            console.log("Autopilot stopped at start phase.");
+        const draft = buildAutopilotDraft(text, intent.flow, intent.domain);
+        draft.project_name = activeProject;
+        let reqId = checkpoint?.reqId ?? "";
+        const startStep = fromStep ?? "create";
+        if (startStep !== "create" && !reqId) {
+            console.log("No checkpoint found for resume. Run full autopilot first or use --from-step create.");
+            printRecoveryNext(activeProject, "create", text);
             return;
         }
-        printStep("Step 6/7", `Updating test plan for ${created.reqId}`);
-        printWhy("I am ensuring critical paths, edge cases, and regression tests are documented.");
-        const tested = await (0, test_plan_1.runTestPlan)({
-            projectName: activeProject,
-            reqId: created.reqId,
-            autofill: true,
-            seedText: text
-        });
-        if (!tested) {
-            console.log("Autopilot stopped at test planning.");
-            return;
+        if (fromStep) {
+            printWhy(`Resuming autopilot from step: ${fromStep}`);
         }
-        printStep("Step 7/7", `Finalizing requirement ${created.reqId}`);
-        printWhy("I will move artifacts to done state and generate project-level summary files.");
-        const finished = await (0, req_finish_1.runReqFinish)({
-            projectName: activeProject,
-            reqId: created.reqId,
-            autofill: true,
-            seedText: text
-        });
-        if (!finished) {
-            console.log("Autopilot stopped at finish phase.");
-            return;
+        const stepIndex = autopilot_checkpoint_1.AUTOPILOT_STEPS.indexOf(startStep);
+        for (let i = stepIndex; i < autopilot_checkpoint_1.AUTOPILOT_STEPS.length; i += 1) {
+            const step = autopilot_checkpoint_1.AUTOPILOT_STEPS[i];
+            if (step === "create") {
+                printStep("Step 3/7", "Creating requirement draft automatically");
+                printWhy("This creates your baseline scope, acceptance criteria, and NFRs.");
+                const created = await (0, req_create_1.runReqCreate)(draft, { autofill: true });
+                if (!created) {
+                    console.log("Autopilot stopped at requirement creation.");
+                    printRecoveryNext(activeProject, "create", text);
+                    return;
+                }
+                reqId = created.reqId;
+            }
+            if (step === "plan") {
+                printStep("Step 4/7", `Planning requirement ${reqId}`);
+                printWhy("I am generating functional, technical, architecture, and test artifacts.");
+                const planned = await (0, req_plan_1.runReqPlan)({
+                    projectName: activeProject,
+                    reqId,
+                    autofill: true,
+                    seedText: text
+                });
+                if (!planned) {
+                    console.log("Autopilot stopped at planning.");
+                    printRecoveryNext(activeProject, "plan", text);
+                    return;
+                }
+            }
+            if (step === "start") {
+                printStep("Step 5/7", `Preparing implementation plan for ${reqId}`);
+                printWhy("This stage defines milestones, tasks, quality thresholds, and decisions.");
+                const started = await (0, req_start_1.runReqStart)({
+                    projectName: activeProject,
+                    reqId,
+                    autofill: true,
+                    seedText: text
+                });
+                if (!started) {
+                    console.log("Autopilot stopped at start phase.");
+                    printRecoveryNext(activeProject, "start", text);
+                    return;
+                }
+            }
+            if (step === "test") {
+                printStep("Step 6/7", `Updating test plan for ${reqId}`);
+                printWhy("I am ensuring critical paths, edge cases, and regression tests are documented.");
+                const tested = await (0, test_plan_1.runTestPlan)({
+                    projectName: activeProject,
+                    reqId,
+                    autofill: true,
+                    seedText: text
+                });
+                if (!tested) {
+                    console.log("Autopilot stopped at test planning.");
+                    printRecoveryNext(activeProject, "test", text);
+                    return;
+                }
+            }
+            if (step === "finish") {
+                printStep("Step 7/7", `Finalizing requirement ${reqId}`);
+                printWhy("I will move artifacts to done state and generate project-level summary files.");
+                const finished = await (0, req_finish_1.runReqFinish)({
+                    projectName: activeProject,
+                    reqId,
+                    autofill: true,
+                    seedText: text
+                });
+                if (!finished) {
+                    console.log("Autopilot stopped at finish phase.");
+                    printRecoveryNext(activeProject, "finish", text);
+                    return;
+                }
+                (0, autopilot_checkpoint_1.clearCheckpoint)(activeProject);
+                console.log(`Autopilot completed successfully for ${reqId}.`);
+                console.log(`Artifacts finalized at: ${finished.doneDir}`);
+                return;
+            }
+            (0, autopilot_checkpoint_1.saveCheckpoint)(activeProject, {
+                project: activeProject,
+                reqId,
+                seedText: text,
+                flow: intent.flow,
+                domain: intent.domain,
+                lastCompleted: step,
+                updatedAt: new Date().toISOString()
+            });
         }
-        console.log(`Autopilot completed successfully for ${created.reqId}.`);
-        console.log(`Artifacts finalized at: ${finished.doneDir}`);
     }
 }

package/dist/context/flags.d.ts

@@ -3,6 +3,7 @@ export type RuntimeFlags = {
     improve: boolean;
     parallel: boolean;
     nonInteractive: boolean;
+    fromStep?: string;
     project?: string;
     output?: string;
 };

package/dist/context/flags.js

@@ -7,6 +7,7 @@ const flags = {
     improve: false,
     parallel: false,
     nonInteractive: false,
+    fromStep: undefined,
     project: undefined,
     output: undefined
 };
@@ -23,6 +24,9 @@ function setFlags(next) {
     if ("nonInteractive" in next) {
         flags.nonInteractive = Boolean(next.nonInteractive);
     }
+    if ("fromStep" in next) {
+        flags.fromStep = typeof next.fromStep === "string" ? next.fromStep : undefined;
+    }
     if ("project" in next) {
         flags.project = typeof next.project === "string" ? next.project : undefined;
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "sdd-cli",
-  "version": "0.1.11",
+  "version": "0.1.13",
   "description": "SDD-first, AI-native CLI for end-to-end delivery.",
   "homepage": "https://github.com/jdsalasca/sdd-tool#readme",
   "repository": {