gsd-pi 2.33.1 → 2.34.0-dev.0150ae9

package/dist/resources/extensions/gsd/commands-extensions.js

@@ -0,0 +1,259 @@
+/**
+ * GSD Extensions Command — /gsd extensions
+ *
+ * Manage the extension registry: list, enable, disable, info.
+ * Self-contained — no imports outside the extensions tree (extensions are loaded
+ * via jiti at runtime from ~/.gsd/agent/, not compiled by tsc).
+ */
+import { existsSync, mkdirSync, readFileSync, readdirSync, renameSync, writeFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { homedir } from "node:os";
+// ─── Registry I/O ───────────────────────────────────────────────────────────
+function getRegistryPath() {
+    return join(homedir(), ".gsd", "extensions", "registry.json");
+}
+function getAgentExtensionsDir() {
+    return join(homedir(), ".gsd", "agent", "extensions");
+}
+function loadRegistry() {
+    const filePath = getRegistryPath();
+    try {
+        if (!existsSync(filePath))
+            return { version: 1, entries: {} };
+        const raw = readFileSync(filePath, "utf-8");
+        const parsed = JSON.parse(raw);
+        if (typeof parsed === "object" && parsed !== null && parsed.version === 1 && typeof parsed.entries === "object") {
+            return parsed;
+        }
+        return { version: 1, entries: {} };
+    }
+    catch {
+        return { version: 1, entries: {} };
+    }
+}
+function saveRegistry(registry) {
+    const filePath = getRegistryPath();
+    try {
+        mkdirSync(dirname(filePath), { recursive: true });
+        const tmp = filePath + ".tmp";
+        writeFileSync(tmp, JSON.stringify(registry, null, 2), "utf-8");
+        renameSync(tmp, filePath);
+    }
+    catch { /* non-fatal */ }
+}
+function isEnabled(registry, id) {
+    const entry = registry.entries[id];
+    if (!entry)
+        return true;
+    return entry.enabled;
+}
+function readManifest(dir) {
+    const mPath = join(dir, "extension-manifest.json");
+    if (!existsSync(mPath))
+        return null;
+    try {
+        const raw = JSON.parse(readFileSync(mPath, "utf-8"));
+        if (typeof raw?.id === "string" && typeof raw?.name === "string")
+            return raw;
+        return null;
+    }
+    catch {
+        return null;
+    }
+}
+function discoverManifests() {
+    const extDir = getAgentExtensionsDir();
+    const manifests = new Map();
+    if (!existsSync(extDir))
+        return manifests;
+    for (const entry of readdirSync(extDir, { withFileTypes: true })) {
+        if (!entry.isDirectory())
+            continue;
+        const m = readManifest(join(extDir, entry.name));
+        if (m)
+            manifests.set(m.id, m);
+    }
+    return manifests;
+}
+// ─── Command Handler ────────────────────────────────────────────────────────
+export async function handleExtensions(args, ctx) {
+    const parts = args.split(/\s+/).filter(Boolean);
+    const subCmd = parts[0] ?? "list";
+    if (subCmd === "list") {
+        handleList(ctx);
+        return;
+    }
+    if (subCmd === "enable") {
+        handleEnable(parts[1], ctx);
+        return;
+    }
+    if (subCmd === "disable") {
+        handleDisable(parts[1], parts.slice(2).join(" "), ctx);
+        return;
+    }
+    if (subCmd === "info") {
+        handleInfo(parts[1], ctx);
+        return;
+    }
+    ctx.ui.notify(`Unknown: /gsd extensions ${subCmd}. Usage: /gsd extensions [list|enable|disable|info]`, "warning");
+}
+function handleList(ctx) {
+    const manifests = discoverManifests();
+    const registry = loadRegistry();
+    if (manifests.size === 0) {
+        ctx.ui.notify("No extension manifests found.", "warning");
+        return;
+    }
+    // Sort: core first, then alphabetical
+    const sorted = [...manifests.values()].sort((a, b) => {
+        if (a.tier === "core" && b.tier !== "core")
+            return -1;
+        if (b.tier === "core" && a.tier !== "core")
+            return 1;
+        return a.id.localeCompare(b.id);
+    });
+    const lines = [];
+    const hdr = padRight("Extensions", 38) + padRight("Status", 10) + padRight("Tier", 10) + padRight("Tools", 7) + "Commands";
+    lines.push(hdr);
+    lines.push("─".repeat(hdr.length));
+    for (const m of sorted) {
+        const enabled = isEnabled(registry, m.id);
+        const status = enabled ? "enabled" : "disabled";
+        const toolCount = m.provides?.tools?.length ?? 0;
+        const cmdCount = m.provides?.commands?.length ?? 0;
+        const label = `${m.id} (${m.name})`;
+        lines.push(padRight(label, 38) +
+            padRight(status, 10) +
+            padRight(m.tier, 10) +
+            padRight(String(toolCount), 7) +
+            String(cmdCount));
+        if (!enabled) {
+            lines.push(`  ↳ gsd extensions enable ${m.id}`);
+        }
+    }
+    ctx.ui.notify(lines.join("\n"), "info");
+}
+function handleEnable(id, ctx) {
+    if (!id) {
+        ctx.ui.notify("Usage: /gsd extensions enable <id>", "warning");
+        return;
+    }
+    const manifests = discoverManifests();
+    if (!manifests.has(id)) {
+        ctx.ui.notify(`Extension "${id}" not found. Run /gsd extensions list to see available extensions.`, "warning");
+        return;
+    }
+    const registry = loadRegistry();
+    if (isEnabled(registry, id)) {
+        ctx.ui.notify(`Extension "${id}" is already enabled.`, "info");
+        return;
+    }
+    const entry = registry.entries[id];
+    if (entry) {
+        entry.enabled = true;
+        delete entry.disabledAt;
+        delete entry.disabledReason;
+    }
+    else {
+        registry.entries[id] = { id, enabled: true, source: "bundled" };
+    }
+    saveRegistry(registry);
+    ctx.ui.notify(`Enabled "${id}". Restart GSD to activate.`, "info");
+}
+function handleDisable(id, reason, ctx) {
+    if (!id) {
+        ctx.ui.notify("Usage: /gsd extensions disable <id>", "warning");
+        return;
+    }
+    const manifests = discoverManifests();
+    const manifest = manifests.get(id) ?? null;
+    if (!manifests.has(id)) {
+        ctx.ui.notify(`Extension "${id}" not found. Run /gsd extensions list to see available extensions.`, "warning");
+        return;
+    }
+    if (manifest?.tier === "core") {
+        ctx.ui.notify(`Cannot disable "${id}" — it is a core extension.`, "warning");
+        return;
+    }
+    const registry = loadRegistry();
+    if (!isEnabled(registry, id)) {
+        ctx.ui.notify(`Extension "${id}" is already disabled.`, "info");
+        return;
+    }
+    const entry = registry.entries[id];
+    if (entry) {
+        entry.enabled = false;
+        entry.disabledAt = new Date().toISOString();
+        entry.disabledReason = reason || undefined;
+    }
+    else {
+        registry.entries[id] = {
+            id,
+            enabled: false,
+            source: "bundled",
+            disabledAt: new Date().toISOString(),
+            disabledReason: reason || undefined,
+        };
+    }
+    saveRegistry(registry);
+    ctx.ui.notify(`Disabled "${id}". Restart GSD to deactivate.`, "info");
+}
+function handleInfo(id, ctx) {
+    if (!id) {
+        ctx.ui.notify("Usage: /gsd extensions info <id>", "warning");
+        return;
+    }
+    const manifests = discoverManifests();
+    const manifest = manifests.get(id);
+    if (!manifest) {
+        ctx.ui.notify(`Extension "${id}" not found.`, "warning");
+        return;
+    }
+    const registry = loadRegistry();
+    const enabled = isEnabled(registry, id);
+    const entry = registry.entries[id];
+    const lines = [
+        `${manifest.name} (${manifest.id})`,
+        "",
+        `  Version:     ${manifest.version}`,
+        `  Description: ${manifest.description}`,
+        `  Tier:        ${manifest.tier}`,
+        `  Status:      ${enabled ? "enabled" : "disabled"}`,
+    ];
+    if (entry?.disabledAt) {
+        lines.push(`  Disabled at: ${entry.disabledAt}`);
+    }
+    if (entry?.disabledReason) {
+        lines.push(`  Reason:      ${entry.disabledReason}`);
+    }
+    if (manifest.provides) {
+        lines.push("");
+        lines.push("  Provides:");
+        if (manifest.provides.tools?.length) {
+            lines.push(`    Tools:     ${manifest.provides.tools.join(", ")}`);
+        }
+        if (manifest.provides.commands?.length) {
+            lines.push(`    Commands:  ${manifest.provides.commands.join(", ")}`);
+        }
+        if (manifest.provides.hooks?.length) {
+            lines.push(`    Hooks:     ${manifest.provides.hooks.join(", ")}`);
+        }
+        if (manifest.provides.shortcuts?.length) {
+            lines.push(`    Shortcuts: ${manifest.provides.shortcuts.join(", ")}`);
+        }
+    }
+    if (manifest.dependencies) {
+        lines.push("");
+        lines.push("  Dependencies:");
+        if (manifest.dependencies.extensions?.length) {
+            lines.push(`    Extensions: ${manifest.dependencies.extensions.join(", ")}`);
+        }
+        if (manifest.dependencies.runtime?.length) {
+            lines.push(`    Runtime:    ${manifest.dependencies.runtime.join(", ")}`);
+        }
+    }
+    ctx.ui.notify(lines.join("\n"), "info");
+}
+function padRight(str, len) {
+    return str.length >= len ? str + " " : str + " ".repeat(len - str.length);
+}

package/dist/resources/extensions/gsd/commands-handlers.js

@@ -0,0 +1,310 @@
+/**
+ * GSD Command Handlers — fire-and-forget handlers that delegate to other modules.
+ *
+ * Contains: handleDoctor, handleSteer, handleCapture, handleTriage, handleKnowledge,
+ * handleRunHook, handleUpdate, handleSkillHealth
+ */
+import { existsSync, readFileSync, mkdirSync } from "node:fs";
+import { join } from "node:path";
+import { deriveState } from "./state.js";
+import { gsdRoot } from "./paths.js";
+import { appendCapture, hasPendingCaptures, loadPendingCaptures } from "./captures.js";
+import { appendOverride, appendKnowledge } from "./files.js";
+import { formatDoctorIssuesForPrompt, formatDoctorReport, runGSDDoctor, selectDoctorScope, filterDoctorIssues, } from "./doctor.js";
+import { isAutoActive } from "./auto.js";
+import { projectRoot } from "./commands.js";
+import { loadPrompt } from "./prompt-loader.js";
+export function dispatchDoctorHeal(pi, scope, reportText, structuredIssues) {
+    const workflowPath = process.env.GSD_WORKFLOW_PATH ?? join(process.env.HOME ?? "~", ".pi", "GSD-WORKFLOW.md");
+    const workflow = readFileSync(workflowPath, "utf-8");
+    const prompt = loadPrompt("doctor-heal", {
+        doctorSummary: reportText,
+        structuredIssues,
+        scopeLabel: scope ?? "active milestone / blocking scope",
+        doctorCommandSuffix: scope ? ` ${scope}` : "",
+    });
+    const content = `Read the following GSD workflow protocol and execute exactly.\n\n${workflow}\n\n## Your Task\n\n${prompt}`;
+    pi.sendMessage({ customType: "gsd-doctor-heal", content, display: false }, { triggerTurn: true });
+}
+export async function handleDoctor(args, ctx, pi) {
+    const trimmed = args.trim();
+    const parts = trimmed ? trimmed.split(/\s+/) : [];
+    const mode = parts[0] === "fix" || parts[0] === "heal" || parts[0] === "audit" ? parts[0] : "doctor";
+    const requestedScope = mode === "doctor" ? parts[0] : parts[1];
+    const scope = await selectDoctorScope(projectRoot(), requestedScope);
+    const effectiveScope = mode === "audit" ? requestedScope : scope;
+    const report = await runGSDDoctor(projectRoot(), {
+        fix: mode === "fix" || mode === "heal",
+        scope: effectiveScope,
+    });
+    const reportText = formatDoctorReport(report, {
+        scope: effectiveScope,
+        includeWarnings: mode === "audit",
+        maxIssues: mode === "audit" ? 50 : 12,
+        title: mode === "audit" ? "GSD doctor audit." : mode === "heal" ? "GSD doctor heal prep." : undefined,
+    });
+    ctx.ui.notify(reportText, report.ok ? "info" : "warning");
+    if (mode === "heal") {
+        const unresolved = filterDoctorIssues(report.issues, {
+            scope: effectiveScope,
+            includeWarnings: true,
+        });
+        const actionable = unresolved.filter(issue => issue.severity === "error" || issue.code === "all_tasks_done_missing_slice_uat" || issue.code === "slice_checked_missing_uat");
+        if (actionable.length === 0) {
+            ctx.ui.notify("Doctor heal found nothing actionable to hand off to the LLM.", "info");
+            return;
+        }
+        const structuredIssues = formatDoctorIssuesForPrompt(actionable);
+        dispatchDoctorHeal(pi, effectiveScope, reportText, structuredIssues);
+        ctx.ui.notify(`Doctor heal dispatched ${actionable.length} issue(s) to the LLM.`, "info");
+    }
+}
+export async function handleSkillHealth(args, ctx) {
+    const { generateSkillHealthReport, formatSkillHealthReport, formatSkillDetail, } = await import("./skill-health.js");
+    const basePath = projectRoot();
+    // /gsd skill-health <skill-name> — detail view
+    if (args && !args.startsWith("--")) {
+        const detail = formatSkillDetail(basePath, args);
+        ctx.ui.notify(detail, "info");
+        return;
+    }
+    // Parse flags
+    const staleMatch = args.match(/--stale\s+(\d+)/);
+    const staleDays = staleMatch ? parseInt(staleMatch[1], 10) : undefined;
+    const decliningOnly = args.includes("--declining");
+    const report = generateSkillHealthReport(basePath, staleDays);
+    if (decliningOnly) {
+        if (report.decliningSkills.length === 0) {
+            ctx.ui.notify("No skills flagged for declining performance.", "info");
+            return;
+        }
+        const filtered = {
+            ...report,
+            skills: report.skills.filter(s => s.flagged),
+        };
+        ctx.ui.notify(formatSkillHealthReport(filtered), "info");
+        return;
+    }
+    ctx.ui.notify(formatSkillHealthReport(report), "info");
+}
+export async function handleCapture(args, ctx) {
+    // Strip surrounding quotes from the argument
+    let text = args.trim();
+    if (!text) {
+        ctx.ui.notify('Usage: /gsd capture "your thought here"', "warning");
+        return;
+    }
+    // Remove wrapping quotes (single or double)
+    if ((text.startsWith('"') && text.endsWith('"')) || (text.startsWith("'") && text.endsWith("'"))) {
+        text = text.slice(1, -1);
+    }
+    if (!text) {
+        ctx.ui.notify('Usage: /gsd capture "your thought here"', "warning");
+        return;
+    }
+    const basePath = process.cwd();
+    // Ensure .gsd/ exists — capture should work even without a milestone
+    const gsdDir = gsdRoot(basePath);
+    if (!existsSync(gsdDir)) {
+        mkdirSync(gsdDir, { recursive: true });
+    }
+    const id = appendCapture(basePath, text);
+    ctx.ui.notify(`Captured: ${id} — "${text.length > 60 ? text.slice(0, 57) + "..." : text}"`, "info");
+}
+export async function handleTriage(ctx, pi, basePath) {
+    if (!hasPendingCaptures(basePath)) {
+        ctx.ui.notify("No pending captures to triage.", "info");
+        return;
+    }
+    const pending = loadPendingCaptures(basePath);
+    ctx.ui.notify(`Triaging ${pending.length} pending capture${pending.length === 1 ? "" : "s"}...`, "info");
+    // Build context for the triage prompt
+    const state = await deriveState(basePath);
+    let currentPlan = "";
+    let roadmapContext = "";
+    if (state.activeMilestone && state.activeSlice) {
+        const { resolveSliceFile, resolveMilestoneFile } = await import("./paths.js");
+        const planFile = resolveSliceFile(basePath, state.activeMilestone.id, state.activeSlice.id, "PLAN");
+        if (planFile) {
+            const { loadFile: load } = await import("./files.js");
+            currentPlan = (await load(planFile)) ?? "";
+        }
+        const roadmapFile = resolveMilestoneFile(basePath, state.activeMilestone.id, "ROADMAP");
+        if (roadmapFile) {
+            const { loadFile: load } = await import("./files.js");
+            roadmapContext = (await load(roadmapFile)) ?? "";
+        }
+    }
+    // Format pending captures for the prompt
+    const capturesList = pending.map(c => `- **${c.id}**: "${c.text}" (captured: ${c.timestamp})`).join("\n");
+    // Dispatch triage prompt
+    const { loadPrompt: loadTriagePrompt } = await import("./prompt-loader.js");
+    const prompt = loadTriagePrompt("triage-captures", {
+        pendingCaptures: capturesList,
+        currentPlan: currentPlan || "(no active slice plan)",
+        roadmapContext: roadmapContext || "(no active roadmap)",
+    });
+    const workflowPath = process.env.GSD_WORKFLOW_PATH ?? join(process.env.HOME ?? "~", ".pi", "GSD-WORKFLOW.md");
+    const workflow = readFileSync(workflowPath, "utf-8");
+    pi.sendMessage({
+        customType: "gsd-triage",
+        content: `Read the following GSD workflow protocol and execute exactly.\n\n${workflow}\n\n## Your Task\n\n${prompt}`,
+        display: false,
+    }, { triggerTurn: true });
+}
+export async function handleSteer(change, ctx, pi) {
+    const basePath = process.cwd();
+    const state = await deriveState(basePath);
+    const mid = state.activeMilestone?.id ?? "none";
+    const sid = state.activeSlice?.id ?? "none";
+    const tid = state.activeTask?.id ?? "none";
+    const appliedAt = `${mid}/${sid}/${tid}`;
+    await appendOverride(basePath, change, appliedAt);
+    if (isAutoActive()) {
+        pi.sendMessage({
+            customType: "gsd-hard-steer",
+            content: [
+                "HARD STEER — User override registered.",
+                "",
+                `**Override:** ${change}`,
+                "",
+                "This override has been saved to `.gsd/OVERRIDES.md` and will be injected into all future task prompts.",
+                "A document rewrite unit will run before the next task to propagate this change across all active plan documents.",
+                "",
+                "If you are mid-task, finish your current work respecting this override. The next dispatched unit will be a document rewrite.",
+            ].join("\n"),
+            display: false,
+        }, { triggerTurn: true });
+        ctx.ui.notify(`Override registered: "${change}". Will be applied before next task dispatch.`, "info");
+    }
+    else {
+        pi.sendMessage({
+            customType: "gsd-hard-steer",
+            content: [
+                "HARD STEER — User override registered.",
+                "",
+                `**Override:** ${change}`,
+                "",
+                "This override has been saved to `.gsd/OVERRIDES.md`.",
+                "Before continuing, read `.gsd/OVERRIDES.md` and update the current plan documents to reflect this change.",
+                "Focus on: active slice plan, incomplete task plans, and DECISIONS.md.",
+            ].join("\n"),
+            display: false,
+        }, { triggerTurn: true });
+        ctx.ui.notify(`Override registered: "${change}". Update plan documents to reflect this change.`, "info");
+    }
+}
+export async function handleKnowledge(args, ctx) {
+    const parts = args.split(/\s+/);
+    const typeArg = parts[0]?.toLowerCase();
+    if (!typeArg || !["rule", "pattern", "lesson"].includes(typeArg)) {
+        ctx.ui.notify("Usage: /gsd knowledge <rule|pattern|lesson> <description>\nExample: /gsd knowledge rule Use real DB for integration tests", "warning");
+        return;
+    }
+    const entryText = parts.slice(1).join(" ").trim();
+    if (!entryText) {
+        ctx.ui.notify(`Usage: /gsd knowledge ${typeArg} <description>`, "warning");
+        return;
+    }
+    const type = typeArg;
+    const basePath = process.cwd();
+    const state = await deriveState(basePath);
+    const scope = state.activeMilestone?.id
+        ? `${state.activeMilestone.id}${state.activeSlice ? `/${state.activeSlice.id}` : ""}`
+        : "global";
+    await appendKnowledge(basePath, type, entryText, scope);
+    ctx.ui.notify(`Added ${type} to KNOWLEDGE.md: "${entryText}"`, "success");
+}
+export async function handleRunHook(args, ctx, pi) {
+    const parts = args.trim().split(/\s+/);
+    if (parts.length < 3) {
+        ctx.ui.notify(`Usage: /gsd run-hook <hook-name> <unit-type> <unit-id>
+
+Unit types:
+  execute-task   - Task execution (unit-id: M001/S01/T01)
+  plan-slice     - Slice planning (unit-id: M001/S01)
+  research-milestone - Milestone research (unit-id: M001)
+  complete-slice - Slice completion (unit-id: M001/S01)
+  complete-milestone - Milestone completion (unit-id: M001)
+
+Examples:
+  /gsd run-hook code-review execute-task M001/S01/T01
+  /gsd run-hook lint-check plan-slice M001/S01`, "warning");
+        return;
+    }
+    const [hookName, unitType, unitId] = parts;
+    const basePath = projectRoot();
+    // Import the hook trigger function
+    const { triggerHookManually, formatHookStatus, getHookStatus } = await import("./post-unit-hooks.js");
+    const { dispatchHookUnit } = await import("./auto.js");
+    // Check if the hook exists
+    const hooks = getHookStatus();
+    const hookExists = hooks.some(h => h.name === hookName);
+    if (!hookExists) {
+        ctx.ui.notify(`Hook "${hookName}" not found. Configured hooks:\n${formatHookStatus()}`, "error");
+        return;
+    }
+    // Validate unit ID format
+    const unitIdPattern = /^M\d{3}\/S\d{2,3}\/T\d{2,3}$/;
+    if (!unitIdPattern.test(unitId)) {
+        ctx.ui.notify(`Invalid unit ID format: "${unitId}". Expected format: M004/S04/T03`, "warning");
+        return;
+    }
+    // Trigger the hook manually
+    const hookUnit = triggerHookManually(hookName, unitType, unitId, basePath);
+    if (!hookUnit) {
+        ctx.ui.notify(`Failed to trigger hook "${hookName}". The hook may be disabled or not configured for unit type "${unitType}".`, "error");
+        return;
+    }
+    ctx.ui.notify(`Manually triggering hook: ${hookName} for ${unitType} ${unitId}`, "info");
+    // Dispatch the hook unit directly, bypassing normal pre-dispatch hooks
+    const success = await dispatchHookUnit(ctx, pi, hookName, unitType, unitId, hookUnit.prompt, hookUnit.model, basePath);
+    if (!success) {
+        ctx.ui.notify("Failed to dispatch hook. Auto-mode may have been cancelled.", "error");
+    }
+}
+// ─── Self-update handler ────────────────────────────────────────────────────
+function compareSemverLocal(a, b) {
+    const pa = a.split('.').map(Number);
+    const pb = b.split('.').map(Number);
+    for (let i = 0; i < Math.max(pa.length, pb.length); i++) {
+        const va = pa[i] || 0;
+        const vb = pb[i] || 0;
+        if (va > vb)
+            return 1;
+        if (va < vb)
+            return -1;
+    }
+    return 0;
+}
+export async function handleUpdate(ctx) {
+    const { execSync } = await import("node:child_process");
+    const NPM_PACKAGE = "gsd-pi";
+    const current = process.env.GSD_VERSION || "0.0.0";
+    ctx.ui.notify(`Current version: v${current}\nChecking npm registry...`, "info");
+    let latest;
+    try {
+        latest = execSync(`npm view ${NPM_PACKAGE} version`, {
+            encoding: "utf-8",
+            stdio: ["ignore", "pipe", "ignore"],
+        }).trim();
+    }
+    catch {
+        ctx.ui.notify("Failed to reach npm registry. Check your network connection.", "error");
+        return;
+    }
+    if (compareSemverLocal(latest, current) <= 0) {
+        ctx.ui.notify(`Already up to date (v${current}).`, "info");
+        return;
+    }
+    ctx.ui.notify(`Updating: v${current} → v${latest}...`, "info");
+    try {
+        execSync(`npm install -g ${NPM_PACKAGE}@latest`, {
+            stdio: ["ignore", "pipe", "ignore"],
+        });
+        ctx.ui.notify(`Updated to v${latest}. Restart your GSD session to use the new version.`, "info");
+    }
+    catch {
+        ctx.ui.notify(`Update failed. Try manually: npm install -g ${NPM_PACKAGE}@latest`, "error");
+    }
+}

package/dist/resources/extensions/gsd/commands-inspect.js

@@ -0,0 +1,70 @@
+/**
+ * GSD Inspect — SQLite DB diagnostics.
+ *
+ * Contains: InspectData type, formatInspectOutput, handleInspect
+ */
+import { getErrorMessage } from "./error-utils.js";
+export function formatInspectOutput(data) {
+    const lines = [];
+    lines.push("=== GSD Database Inspect ===");
+    lines.push(`Schema version: ${data.schemaVersion ?? "unknown"}`);
+    lines.push("");
+    lines.push(`Decisions:    ${data.counts.decisions}`);
+    lines.push(`Requirements: ${data.counts.requirements}`);
+    lines.push(`Artifacts:    ${data.counts.artifacts}`);
+    if (data.recentDecisions.length > 0) {
+        lines.push("");
+        lines.push("Recent decisions:");
+        for (const d of data.recentDecisions) {
+            lines.push(`  ${d.id}: ${d.decision} → ${d.choice}`);
+        }
+    }
+    if (data.recentRequirements.length > 0) {
+        lines.push("");
+        lines.push("Recent requirements:");
+        for (const r of data.recentRequirements) {
+            lines.push(`  ${r.id} [${r.status}]: ${r.description}`);
+        }
+    }
+    return lines.join("\n");
+}
+export async function handleInspect(ctx) {
+    try {
+        const { isDbAvailable, _getAdapter } = await import("./gsd-db.js");
+        if (!isDbAvailable()) {
+            ctx.ui.notify("No GSD database available. Run /gsd auto to create one.", "info");
+            return;
+        }
+        const adapter = _getAdapter();
+        if (!adapter) {
+            ctx.ui.notify("No GSD database available. Run /gsd auto to create one.", "info");
+            return;
+        }
+        const versionRow = adapter.prepare("SELECT MAX(version) as v FROM schema_version").get();
+        const schemaVersion = versionRow ? versionRow["v"] : null;
+        const dCount = adapter.prepare("SELECT count(*) as cnt FROM decisions").get();
+        const rCount = adapter.prepare("SELECT count(*) as cnt FROM requirements").get();
+        const aCount = adapter.prepare("SELECT count(*) as cnt FROM artifacts").get();
+        const recentDecisions = adapter
+            .prepare("SELECT id, decision, choice FROM decisions ORDER BY seq DESC LIMIT 5")
+            .all();
+        const recentRequirements = adapter
+            .prepare("SELECT id, status, description FROM requirements ORDER BY id DESC LIMIT 5")
+            .all();
+        const data = {
+            schemaVersion,
+            counts: {
+                decisions: dCount?.["cnt"] ?? 0,
+                requirements: rCount?.["cnt"] ?? 0,
+                artifacts: aCount?.["cnt"] ?? 0,
+            },
+            recentDecisions,
+            recentRequirements,
+        };
+        ctx.ui.notify(formatInspectOutput(data), "info");
+    }
+    catch (err) {
+        process.stderr.write(`gsd-db: /gsd inspect failed: ${getErrorMessage(err)}\n`);
+        ctx.ui.notify("Failed to inspect GSD database. Check stderr for details.", "error");
+    }
+}