@specship/specship-win32-arm64 0.21.2 → 0.23.0

package/lib/dist/bin/specship.js

@@ -872,10 +872,32 @@ function main() {
             }
             const { default: SpecShip } = await loadSpecShip();
             const cg = await SpecShip.open(projectPath);
+            // JIRA auto-publish (REQ-JIRATEAM-002): print the summary the sync's
+            // auto-publish pass produced. Silent when the repo has no binding
+            // (sync omits the field entirely). Never fails or blocks output.
+            const pushJiraAutoPublish = async (result) => {
+                if (!result.jiraAutoPublish)
+                    return;
+                try {
+                    const { summarizeAutoPublishReport } = await Promise.resolve().then(() => __importStar(require('../jira/auto-publish')));
+                    const line = summarizeAutoPublishReport(result.jiraAutoPublish);
+                    if (line)
+                        console.log(line);
+                    for (const r of result.jiraAutoPublish.results) {
+                        if (r.status === 'failed') {
+                            console.log(`JIRA: ${r.specId} failed — ${r.note ?? 'unknown error'}`);
+                        }
+                    }
+                }
+                catch {
+                    /* summary is best-effort */
+                }
+            };
             if (options.quiet) {
                 const result = await cg.sync();
                 pushDriftNotices(result);
                 await pushJiraDriftComments(cg, result);
+                await pushJiraAutoPublish(result);
                 pushDriftSummary(cg);
                 cg.destroy();
                 return;
@@ -905,6 +927,7 @@ function main() {
             }
             pushDriftNotices(result);
             await pushJiraDriftComments(cg, result);
+            await pushJiraAutoPublish(result);
             pushDriftSummary(cg);
             clack.outro('Done');
             cg.destroy();
@@ -2445,14 +2468,25 @@ function main() {
         .option('--statusline', 'Wire the SpecShip status-line segment into Claude (skips the prompt; never overwrites an existing status line)')
         .option('--skip-statusline', 'Do not add the status-line segment (skips the prompt)')
         .option('--skip-index', 'Do not offer to index the current project (an explicit opt-out for automation)')
-        .option('--print-config', 'Print MCP config snippet for Claude Code and exit (no file writes)')
-        // -t/--target is vestigial — kept so existing `--target claude` / `--target auto`
-        // invocations (including our own offline-install scripts) keep working.
-        .option('-t, --target <ids>', '(vestigial) accepted: "claude" | "auto" | "all" | "none"')
+        .option('--print-config', 'Print the MCP config snippet and exit (no file writes). Claude Code by default; `--target gemini` prints the Gemini CLI settings snippet')
+        // -t/--target SELECTS the agents to wire (GEMINI-TARGET-DOC, REQ-GEMINI-002)
+        // and also picks the snippet --print-config prints. The legacy spellings
+        // ("claude" / "auto" / "all" / "none") keep their Claude-only meanings, so
+        // existing invocations — including our own offline-install scripts — behave
+        // exactly as before.
+        .option('-t, --target <ids>', 'Agents to wire, comma-separated: "claude" (default) | "gemini" | "claude,gemini". Also selects the snippet `--print-config` prints. Legacy: "auto"/"all" = claude, "none" = skip')
         .action(async (opts) => {
         if (opts.printConfig) {
-            const { claudeTarget } = await Promise.resolve().then(() => __importStar(require('../installer/targets/claude')));
             const loc = (opts.location === 'local' ? 'local' : 'global');
+            // Only `gemini` selects the non-default snippet; every other value
+            // (including the vestigial "auto" / "all" / "none") stays Claude, so
+            // existing invocations print exactly what they printed before.
+            if (opts.target === 'gemini') {
+                const { geminiTarget } = await Promise.resolve().then(() => __importStar(require('../installer/targets/gemini')));
+                process.stdout.write(geminiTarget.printConfig(loc));
+                return;
+            }
+            const { claudeTarget } = await Promise.resolve().then(() => __importStar(require('../installer/targets/claude')));
             process.stdout.write(claudeTarget.printConfig(loc));
             return;
         }
@@ -2551,9 +2585,13 @@ function main() {
                 console.log(chalk.dim('  (advisory — diagnose anytime with `specship doctor`)'));
             }
             // Restart reminder (REQ-HANDSHAKE-001): an MCP server added to the config
-            // is NOT visible to a Claude Code session that was already open.
+            // is NOT visible to an agent session that was already open. Names the
+            // agents actually wired, so a `--target gemini` install doesn't tell the
+            // user to restart Claude Code.
+            const { resolveInstallTargets } = await Promise.resolve().then(() => __importStar(require('../installer')));
+            const agents = resolveInstallTargets(opts.target).map((t) => t.displayName).join(' / ');
             console.log();
-            info('Restart Claude Code (or run `/mcp`) to load the SpecShip server — it is not visible in a session that is already open.');
+            info(`Restart ${agents} (or run \`/mcp\`) to load the SpecShip server — it is not visible in a session that is already open.`);
         }
         catch (err) {
             error(err instanceof Error ? err.message : String(err));
@@ -2781,6 +2819,54 @@ function main() {
         }
         process.exit(0);
     });
+    /**
+     * specship search-intercept (STEER-HOOK-DOC, REQ-STEER-004/005)
+     *
+     * Internal PreToolUse hook command on search-shaped tools (Grep/Glob): emit
+     * the point-of-use redirect to specship_explore, at most once per session and
+     * only when the session hasn't used specship yet. STRICTLY ADVISORY — the
+     * output is additionalContext, never a permission decision, and the command
+     * exits 0 on every path (including internal errors) so the matched call
+     * always proceeds (REQ-STEER-004.A2).
+     */
+    program
+        .command('search-intercept')
+        .description('Internal hook: point-of-use redirect from search tools to specship_explore (PreToolUse)')
+        .action(async () => {
+        try {
+            let cwd = process.cwd();
+            let sessionId = null;
+            let transcriptPath = null;
+            const chunks = [];
+            try {
+                for await (const c of process.stdin)
+                    chunks.push(c);
+            }
+            catch { /* no stdin — fall back to process.cwd(), untracked session */ }
+            const raw = Buffer.concat(chunks).toString('utf-8').trim();
+            if (raw) {
+                try {
+                    const parsed = JSON.parse(raw);
+                    if (typeof parsed?.cwd === 'string' && parsed.cwd.length > 0)
+                        cwd = parsed.cwd;
+                    if (typeof parsed?.session_id === 'string' && parsed.session_id.length > 0) {
+                        sessionId = parsed.session_id;
+                    }
+                    if (typeof parsed?.transcript_path === 'string' && parsed.transcript_path.length > 0) {
+                        transcriptPath = parsed.transcript_path;
+                    }
+                }
+                catch { /* not JSON — keep defaults */ }
+            }
+            const { buildSearchIntercept } = await Promise.resolve().then(() => __importStar(require('../activation/search-intercept')));
+            const additionalContext = buildSearchIntercept({ cwd, sessionId, transcriptPath });
+            if (additionalContext) {
+                process.stdout.write(JSON.stringify({ hookSpecificOutput: { hookEventName: 'PreToolUse', additionalContext } }) + '\n');
+            }
+        }
+        catch { /* advisory only — never block the matched call (REQ-STEER-004.A2) */ }
+        process.exit(0);
+    });
     /**
      * specship uninstall
      *
@@ -3296,6 +3382,23 @@ function main() {
                         process.exit(1);
                     }
                     executor.approve(arg, options.comment);
+                    // Milestone: plan_approved (REQ-JIRATEAM-003.A1). Only fires for a
+                    // JIRA-tracked run (metadata.jira present) — a non-JIRA run is a
+                    // silent no-op. Soft-fails internally, so a JIRA hiccup never
+                    // reverses the approval.
+                    try {
+                        const run = cg.getSpecQueries().getWorkflowRunById(arg);
+                        const jira = run?.metadata?.jira;
+                        if (jira?.issueKey) {
+                            const { resolveJiraCredentials, JiraClient } = await Promise.resolve().then(() => __importStar(require('../jira')));
+                            const { postMilestoneComment } = await Promise.resolve().then(() => __importStar(require('../jira/milestone-comment')));
+                            const creds = resolveJiraCredentials();
+                            await postMilestoneComment(new JiraClient(creds), jira.issueKey, 'plan_approved', { specId: jira.specId ?? jira.issueKey }, { projectRoot });
+                        }
+                    }
+                    catch {
+                        /* soft-fail — the approval already committed. */
+                    }
                     // eslint-disable-next-line no-console
                     console.log(`Run ${arg} approved. Call \`specship workflow resume ${arg}\` to continue.`);
                     break;
@@ -3590,6 +3693,52 @@ function main() {
             process.exit(1);
         }
     });
+    /**
+     * specship jira bind — persist the repo's JIRA binding into
+     * specship.config.json (REQ-JIRATEAM-008.A2). The committed binding is what
+     * board-first flows read — the same file `updateRepoJiraBinding` writes.
+     * Credentials never live here; `assertNoCredentialsInRepoConfig` enforces it.
+     */
+    jira
+        .command('bind')
+        .description('Write the repo JIRA binding into specship.config.json (project, epic).')
+        .option('--project <key>', 'JIRA project key to bind (e.g., "PROJ")')
+        .option('--epic <key>', 'Default epic key to anchor new work (e.g., "PROJ-42")')
+        .option('--path <projectRoot>', 'Project root (default: cwd)')
+        .action(async (options) => {
+        const projectRoot = path.resolve(options.path ?? process.cwd());
+        if (!options.project && !options.epic) {
+            error('Nothing to bind. Pass --project <KEY> and/or --epic <KEY>.');
+            process.exit(1);
+        }
+        try {
+            const { updateRepoJiraBinding, loadRepoJiraBinding } = await Promise.resolve().then(() => __importStar(require('../jira/repo-config')));
+            const patch = {};
+            if (options.project)
+                patch.projectKey = options.project.trim().toUpperCase();
+            if (options.epic)
+                patch.epicKey = options.epic.trim().toUpperCase();
+            // --epic alone requires an existing bound project (updateRepoJiraBinding
+            // insists on projectKey being present in the merged result).
+            if (!patch.projectKey) {
+                const { binding } = loadRepoJiraBinding(projectRoot);
+                if (!binding) {
+                    error('No existing JIRA project binding. Pass --project <KEY> on the first bind.');
+                    process.exit(1);
+                }
+            }
+            const { path: file, binding } = updateRepoJiraBinding(projectRoot, patch);
+            success(`Wrote JIRA binding to ${file}.`);
+            info(`  projectKey: ${binding.projectKey}`);
+            if (binding.epicKey)
+                info(`  epicKey: ${binding.epicKey}`);
+        }
+        catch (err) {
+            const msg = err instanceof Error ? err.message : String(err);
+            error(`Failed to write binding: ${msg}`);
+            process.exit(1);
+        }
+    });
     /**
      * specship jira transition — move a tracked issue to a target state, or list
      * the transitions it currently offers (REQ-JIRATRANS-001). Reuses the client's
@@ -3656,6 +3805,103 @@ function main() {
             cg.close();
         }
     });
+    /**
+     * specship jira coverage — sprint coverage report (REQ-JIRATEAM-004). Joins
+     * the bound project's active (or named) sprint to spec truth. Read-only by
+     * default; `--post <issueKey>` upserts a single watermarked JIRA comment.
+     */
+    jira
+        .command('coverage')
+        .description('Sprint coverage report joining JIRA sprint issues to spec truth (read-only unless --post).')
+        .option('--project <key>', 'JIRA project key (default: configured publish project)')
+        .option('--sprint <name>', 'named sprint (default: the project\'s open sprint)')
+        .option('--post <issueKey>', 'upsert the report as a watermarked comment on this issue (edit-in-place)')
+        .option('--path <projectRoot>', 'project root (default: cwd)')
+        .action(async (options) => {
+        const projectRoot = path.resolve(options.path ?? process.cwd());
+        if (!(0, directory_1.isInitialized)(projectRoot)) {
+            error(`SpecShip not initialized in ${projectRoot}. Run \`specship init -i\` first.`);
+            process.exit(1);
+        }
+        const { SpecShip } = await loadSpecShip();
+        const { handleSpecshipJiraCoverage } = await Promise.resolve().then(() => __importStar(require('../mcp/jira-tools')));
+        const cg = await SpecShip.open(projectRoot);
+        try {
+            const args = {};
+            if (options.project)
+                args.project = options.project;
+            if (options.sprint)
+                args.sprint = options.sprint;
+            if (options.post) {
+                args.post = true;
+                args.issue_key = options.post;
+            }
+            const result = await handleSpecshipJiraCoverage(args, {
+                specQueries: cg.getSpecQueries(),
+                projectRoot,
+            });
+            const out = result.content.map((c) => c.text).join('\n');
+            // eslint-disable-next-line no-console
+            console.log(out);
+            if (result.isError)
+                process.exit(1);
+        }
+        finally {
+            cg.close();
+        }
+    });
+    /**
+     * specship jira reconcile — detect JIRA-side edits and (with --apply) fold
+     * them back into the spec (REQ-JIRATEAM-005). Preview is read-only and the
+     * default; --apply must be paired with --issue plus the confirmed accept
+     * flags AND the fingerprint from the preview so an unreviewed apply is
+     * rejected by the handler's fingerprint gate.
+     */
+    jira
+        .command('reconcile')
+        .description('Detect JIRA-side edits to published specs; --apply folds a confirmed diff back into the spec.')
+        .option('--issue <key>', 'narrow to one issue (required for --apply)')
+        .option('--apply', 'apply the confirmed diff — preview first and confirm the diff before using this')
+        .option('--accept-content', 'apply: accept the edited summary/description')
+        .option('--accept-subtask <key...>', 'apply: accept the proposed criterion for this JIRA Sub-task key (repeatable)')
+        .option('--expected-fingerprint <fp>', 'apply: the live fingerprint from the preview the user just approved')
+        .option('--path <projectRoot>', 'project root (default: cwd)')
+        .action(async (options) => {
+        const projectRoot = path.resolve(options.path ?? process.cwd());
+        if (!(0, directory_1.isInitialized)(projectRoot)) {
+            error(`SpecShip not initialized in ${projectRoot}. Run \`specship init -i\` first.`);
+            process.exit(1);
+        }
+        const { SpecShip } = await loadSpecShip();
+        const { handleSpecshipJiraReconcile } = await Promise.resolve().then(() => __importStar(require('../mcp/jira-tools')));
+        const cg = await SpecShip.open(projectRoot);
+        try {
+            const args = {};
+            args.mode = options.apply ? 'apply' : 'preview';
+            if (options.issue)
+                args.issue_key = options.issue;
+            if (options.acceptContent)
+                args.accept_content = true;
+            if (options.acceptSubtask && options.acceptSubtask.length > 0) {
+                args.accept_subtasks = options.acceptSubtask;
+            }
+            if (options.expectedFingerprint) {
+                args.expected_live_fingerprint = options.expectedFingerprint;
+            }
+            const result = await handleSpecshipJiraReconcile(args, {
+                specQueries: cg.getSpecQueries(),
+                projectRoot,
+            });
+            const out = result.content.map((c) => c.text).join('\n');
+            // eslint-disable-next-line no-console
+            console.log(out);
+            if (result.isError)
+                process.exit(1);
+        }
+        finally {
+            cg.close();
+        }
+    });
     /**
      * specship jira release — stamp a released version onto issues
      * (REQ-JIRAPUB-007): ensure the project version exists, add it as fixVersion
@@ -3683,6 +3929,9 @@ function main() {
                 .split(',')
                 .map((k) => k.trim())
                 .filter(Boolean);
+            // Map issue key → spec id for the release_stamped milestone (so the
+            // marker keys on both the spec and the version — REQ-JIRATEAM-003).
+            const issueKeyToSpecId = new Map();
             if (keys.length === 0) {
                 // Default: every spec under <root>/specs with a jira_issue key.
                 const projectRoot = path.resolve(options.path ?? process.cwd());
@@ -3691,9 +3940,14 @@ function main() {
                     for (const name of fs.readdirSync(specsDir)) {
                         if (!name.toLowerCase().endsWith('.md'))
                             continue;
-                        const key = readSpecJiraKey(path.join(specsDir, name));
-                        if (key)
-                            keys.push(key);
+                        const abs = path.join(specsDir, name);
+                        const key = readSpecJiraKey(abs);
+                        if (!key)
+                            continue;
+                        keys.push(key);
+                        const idLine = /^id:\s*([^\r\n]+)$/m.exec(fs.readFileSync(abs, 'utf8'))?.[1]?.trim();
+                        if (idLine)
+                            issueKeyToSpecId.set(key, idLine);
                     }
                 }
                 catch {
@@ -3706,7 +3960,9 @@ function main() {
                 process.exit(1);
             }
             const client = new JiraClient(creds);
-            const result = await releaseIssues(client, projectKey, version, keys);
+            const result = await releaseIssues(client, projectKey, version, keys, {
+                specIdForIssue: (k) => issueKeyToSpecId.get(k),
+            });
             const stamped = result.issues.filter((i) => i.fixVersionAdded).length;
             const commented = result.issues.filter((i) => i.commented).length;
             success(`Version ${version}${result.versionCreated ? ' created' : ' already existed'} in ${projectKey}; ` +
@@ -3717,6 +3973,111 @@ function main() {
             process.exit(1);
         }
     });
+    /**
+     * specship jira regression-pack — generate or refresh the SpecShip Regression
+     * Pack in the bound JIRA project (REQ-JIRAREG-001). Idempotent; --dry-run
+     * prints the plan without any JIRA write.
+     */
+    jira
+        .command('regression-pack')
+        .description('Generate / refresh the SpecShip Regression Pack in the bound JIRA project.')
+        .option('--project <key>', 'JIRA project key (default: configured publish project)')
+        .option('--dry-run', 'plan the pack and print counts without any JIRA write')
+        .option('--path <projectRoot>', 'project root (default: cwd)')
+        .action(async (options) => {
+        const projectRoot = path.resolve(options.path ?? process.cwd());
+        if (!(0, directory_1.isInitialized)(projectRoot)) {
+            error(`SpecShip not initialized in ${projectRoot}. Run \`specship init -i\` first.`);
+            process.exit(1);
+        }
+        const { SpecShip } = await loadSpecShip();
+        const { handleSpecshipJiraRegressionPack } = await Promise.resolve().then(() => __importStar(require('../mcp/jira-tools')));
+        const cg = await SpecShip.open(projectRoot);
+        try {
+            const args = {};
+            if (options.project)
+                args.project = options.project;
+            if (options.dryRun)
+                args.dry_run = true;
+            const result = await handleSpecshipJiraRegressionPack(args, {
+                specQueries: cg.getSpecQueries(),
+                projectRoot,
+                getLinkedNodesForReq: (reqId) => cg.getLinkedNodesForReq(reqId),
+                getNeighbourNodes: (nodeIds) => cg.getNeighbourNodes(nodeIds),
+            });
+            const out = result.content.map((c) => c.text).join('\n');
+            // eslint-disable-next-line no-console
+            console.log(out);
+            if (result.isError)
+                process.exit(1);
+        }
+        finally {
+            cg.close();
+        }
+    });
+    /**
+     * specship jira regression-record — record a single pack case result
+     * (REQ-JIRAREG-005). Comment + transition + validates-link feedback on the
+     * source criterion. `--run <id>` keys idempotency per (case, run).
+     */
+    jira
+        .command('regression-record')
+        .description('Record a regression pack case result (REQ-JIRAREG-005).')
+        .requiredOption('--case <key>', 'JIRA case issue key (e.g., "PROJ-42")')
+        .requiredOption('--criterion <id>', 'source criterion id (e.g., "REQ-FOO-001.A2")')
+        .requiredOption('--result <status>', 'pass | fail | unexecuted', 'pass')
+        .option('--executor <who>', 'human | agent', 'human')
+        .option('--harness <id>', 'behaviour harness id (e.g., "behaviour-e2e")')
+        .option('--run <id>', 'stable run id — one comment per (case, run)')
+        .option('--log-ref <ref>', 'evidence log pointer')
+        .option('--error <text>', 'error text (fail path)')
+        .option('--path <projectRoot>', 'project root (default: cwd)')
+        .action(async (options) => {
+        const projectRoot = path.resolve(options.path ?? process.cwd());
+        if (!(0, directory_1.isInitialized)(projectRoot)) {
+            error(`SpecShip not initialized in ${projectRoot}. Run \`specship init -i\` first.`);
+            process.exit(1);
+        }
+        const { SpecShip } = await loadSpecShip();
+        const { handleSpecshipJiraRegressionRecord } = await Promise.resolve().then(() => __importStar(require('../mcp/jira-tools')));
+        const cg = await SpecShip.open(projectRoot);
+        try {
+            // Accept the friendlier `pass`/`fail` short forms alongside the
+            // canonical `passed`/`failed` names.
+            const canonicalStatus = options.result === 'pass'
+                ? 'passed'
+                : options.result === 'fail'
+                    ? 'failed'
+                    : options.result;
+            const args = {
+                case: options.case,
+                criterion: options.criterion,
+                result: canonicalStatus,
+            };
+            if (options.executor)
+                args.executor = options.executor;
+            if (options.harness)
+                args.harness = options.harness;
+            if (options.run)
+                args.run = options.run;
+            if (options.logRef)
+                args.log_ref = options.logRef;
+            if (options.error)
+                args.error = options.error;
+            const result = await handleSpecshipJiraRegressionRecord(args, {
+                specQueries: cg.getSpecQueries(),
+                projectRoot,
+            });
+            const out = result.content.map((c) => c.text).join('\n');
+            // eslint-disable-next-line no-console
+            console.log(out);
+            if (result.isError)
+                process.exit(1);
+        }
+        finally {
+            cg.close();
+        }
+    });
     // Parse and run
     program.parse();
 } // end main()