gsd-pi 2.74.0 → 2.75.0-dev.2203010a0

package/dist/resources/extensions/gsd/uok/plan-v2.js

@@ -0,0 +1,132 @@
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { gsdRoot, resolveMilestoneFile, resolveSliceFile } from "../paths.js";
+import { isDbAvailable, getMilestoneSlices, getSliceTasks } from "../gsd-db.js";
+const PLAN_V2_CLARIFY_ROUND_LIMIT = 3;
+const EXECUTION_ENTRY_PHASES = new Set([
+    "executing",
+    "summarizing",
+    "validating-milestone",
+    "completing-milestone",
+]);
+function graphOutputPath(basePath) {
+    return join(gsdRoot(basePath), "runtime", "uok-plan-v2-graph.json");
+}
+function hasFileContent(path) {
+    if (!path || !existsSync(path))
+        return false;
+    try {
+        return readFileSync(path, "utf-8").trim().length > 0;
+    }
+    catch {
+        return false;
+    }
+}
+function countSliceResearchArtifacts(basePath, milestoneId, slices) {
+    let count = 0;
+    for (const slice of slices) {
+        if (hasFileContent(resolveSliceFile(basePath, milestoneId, slice.id, "RESEARCH"))) {
+            count += 1;
+        }
+    }
+    return count;
+}
+function isExecutionEntryPhase(phase) {
+    return EXECUTION_ENTRY_PHASES.has(phase);
+}
+export function compileUnitGraphFromState(basePath, state) {
+    const mid = state.activeMilestone?.id;
+    if (!mid)
+        return { ok: false, reason: "no active milestone" };
+    if (!isDbAvailable())
+        return { ok: false, reason: "database not available" };
+    const slices = getMilestoneSlices(mid).sort((a, b) => Number(a.sequence ?? 0) - Number(b.sequence ?? 0));
+    const nodes = [];
+    const clarifyRoundLimit = PLAN_V2_CLARIFY_ROUND_LIMIT;
+    const draftContextIncluded = hasFileContent(resolveMilestoneFile(basePath, mid, "CONTEXT-DRAFT"));
+    const finalizedContextIncluded = hasFileContent(resolveMilestoneFile(basePath, mid, "CONTEXT"));
+    const researchSynthesized = hasFileContent(resolveMilestoneFile(basePath, mid, "RESEARCH"))
+        || countSliceResearchArtifacts(basePath, mid, slices) > 0;
+    if (isExecutionEntryPhase(state.phase) && !finalizedContextIncluded) {
+        const reason = draftContextIncluded
+            ? "milestone context draft exists but finalized CONTEXT.md is missing"
+            : "missing milestone CONTEXT.md";
+        return {
+            ok: false,
+            reason,
+            clarifyRoundLimit,
+            researchSynthesized,
+            draftContextIncluded,
+            finalizedContextIncluded,
+        };
+    }
+    for (const slice of slices) {
+        const sid = slice.id;
+        const tasks = getSliceTasks(mid, sid)
+            .sort((a, b) => Number(a.sequence ?? 0) - Number(b.sequence ?? 0));
+        let previousTaskNodeId = null;
+        for (const task of tasks) {
+            const nodeId = `execute-task:${mid}:${sid}:${task.id}`;
+            const dependsOn = previousTaskNodeId ? [previousTaskNodeId] : [];
+            nodes.push({
+                id: nodeId,
+                kind: "unit",
+                dependsOn,
+                writes: task.key_files,
+                metadata: {
+                    unitType: "execute-task",
+                    unitId: `${mid}.${sid}.${task.id}`,
+                    title: task.title,
+                    status: task.status,
+                },
+            });
+            previousTaskNodeId = nodeId;
+        }
+        if (previousTaskNodeId) {
+            nodes.push({
+                id: `complete-slice:${mid}:${sid}`,
+                kind: "verification",
+                dependsOn: [previousTaskNodeId],
+                metadata: {
+                    unitType: "complete-slice",
+                    unitId: `${mid}.${sid}`,
+                    title: slice.title,
+                    status: slice.status,
+                },
+            });
+        }
+    }
+    const output = {
+        compiledAt: new Date().toISOString(),
+        milestoneId: mid,
+        pipeline: {
+            clarifyRoundLimit,
+            researchSynthesized,
+            draftContextIncluded,
+            finalizedContextIncluded,
+            sourcePhase: state.phase,
+        },
+        nodes,
+    };
+    const outPath = graphOutputPath(basePath);
+    mkdirSync(join(gsdRoot(basePath), "runtime"), { recursive: true });
+    writeFileSync(outPath, JSON.stringify(output, null, 2) + "\n", "utf-8");
+    return {
+        ok: true,
+        graphPath: outPath,
+        nodeCount: nodes.length,
+        clarifyRoundLimit,
+        researchSynthesized: output.pipeline.researchSynthesized,
+        draftContextIncluded: output.pipeline.draftContextIncluded,
+        finalizedContextIncluded: output.pipeline.finalizedContextIncluded,
+    };
+}
+export function ensurePlanV2Graph(basePath, state) {
+    const compiled = compileUnitGraphFromState(basePath, state);
+    if (!compiled.ok)
+        return compiled;
+    if ((compiled.nodeCount ?? 0) <= 0) {
+        return { ok: false, reason: "compiled graph is empty" };
+    }
+    return compiled;
+}

package/dist/resources/extensions/gsd/verification-gate.js

@@ -7,6 +7,7 @@ import { existsSync, readFileSync } from "node:fs";
 import { join, basename } from "node:path";
 import { DEFAULT_COMMAND_TIMEOUT_MS } from "./constants.js";
 import { rewriteCommandWithRtk } from "../shared/rtk.js";
+import { normalizePythonCommand } from "./python-resolver.js";
 /** Maximum bytes of stdout/stderr to retain per command (10 KB). */
 const MAX_OUTPUT_BYTES = 10 * 1024;
 /** Truncate a string to maxBytes, appending a marker if truncated. */
@@ -211,7 +212,7 @@ export function runVerificationGate(options) {
     const checks = [];
     for (const command of commands) {
         const start = Date.now();
-        const rewrittenCommand = rewriteCommandWithRtk(command);
+        const rewrittenCommand = normalizePythonCommand(rewriteCommandWithRtk(command));
         // Pass the command string as an argument to the shell explicitly
         // to avoid Node.js DEP0190 (spawnSync with shell: true and no args).
         const shellBin = process.platform === "win32" ? "cmd" : "sh";

package/dist/resources/extensions/gsd/workflow-dispatch.js

@@ -0,0 +1,64 @@
+/**
+ * workflow-dispatch.ts — Shared dispatchers for workflow plugins.
+ *
+ * Called by both `/gsd start <template>` (existing markdown path) and
+ * `/gsd workflow <name>` (new direct dispatch). Keeps the prompt-build
+ * logic in one place so md template behavior stays consistent.
+ */
+import { readFileSync } from "node:fs";
+import { loadPrompt } from "./prompt-loader.js";
+// ─── Oneshot dispatch ────────────────────────────────────────────────────
+/**
+ * Strip the `<template_meta>` block from markdown content so it's not
+ * repeated in the prompt body.
+ */
+function stripTemplateMeta(content) {
+    return content.replace(/<template_meta>[\s\S]*?<\/template_meta>\s*/, "");
+}
+/**
+ * For a oneshot YAML plugin, extract the single-step prompt.
+ * For multi-step YAML defined as oneshot, concatenate step prompts.
+ */
+function extractYamlOneshotPrompt(yamlContent) {
+    // Simple: just include the raw YAML so the model can follow it.
+    // This keeps the oneshot format flexible without re-parsing.
+    return `\`\`\`yaml\n${yamlContent}\n\`\`\``;
+}
+/**
+ * Dispatch a oneshot workflow: load the prompt, inject the body, send.
+ * No STATE.json, no branch switch, no auto-loop.
+ */
+export function dispatchOneshot(plugin, pi, userArgs) {
+    const raw = readFileSync(plugin.path, "utf-8");
+    const body = plugin.format === "yaml"
+        ? extractYamlOneshotPrompt(raw)
+        : stripTemplateMeta(raw);
+    const prompt = loadPrompt("workflow-oneshot", {
+        name: plugin.name,
+        displayName: plugin.meta.displayName,
+        body,
+        userArgs: userArgs || "(none)",
+    });
+    pi.sendMessage({ customType: "gsd-workflow-oneshot", content: prompt, display: false }, { triggerTurn: true });
+}
+/**
+ * Build and dispatch the `workflow-start.md` prompt for a markdown-phase plugin.
+ * Returns the prompt that was sent (useful for tests).
+ */
+export function dispatchMarkdownPhase(opts, pi) {
+    const prompt = loadPrompt("workflow-start", {
+        templateId: opts.templateId,
+        templateName: opts.templateName,
+        templateDescription: opts.templateDescription,
+        phases: opts.phases.join(" → "),
+        complexity: opts.complexity,
+        artifactDir: opts.artifactDir || "(none)",
+        branch: opts.branch,
+        description: opts.description || "(none provided)",
+        issueRef: opts.issueRef || "(none)",
+        date: opts.date,
+        workflowContent: opts.workflowContent,
+    });
+    pi.sendMessage({ customType: "gsd-workflow-template", content: prompt, display: false }, { triggerTurn: true });
+    return prompt;
+}

package/dist/resources/extensions/gsd/workflow-install.js

@@ -0,0 +1,327 @@
+/**
+ * workflow-install.ts — Fetch, validate, and install remote workflow plugins.
+ *
+ * Accepts:
+ *   - Full URL (https://raw.githubusercontent.com/... or gist raw URL)
+ *   - gist:abc123           → https://gist.githubusercontent.com/anonymous/abc123/raw
+ *   - gh:owner/repo/path[@ref] → raw.githubusercontent.com/owner/repo/<ref>/path
+ *
+ * Installed files land in `~/.gsd/workflows/<name>.<ext>` by default, or
+ * `.gsd/workflows/<name>.<ext>` with the `--project` flag.
+ *
+ * A provenance file `~/.gsd/workflows/.installed.json` (or project equivalent)
+ * records source URL, timestamp, and sha256 so `/gsd workflow uninstall` can
+ * clean up and future `/gsd workflow update` can refresh.
+ */
+import { existsSync, mkdirSync, readFileSync, statSync, unlinkSync, writeFileSync, } from "node:fs";
+import { homedir } from "node:os";
+import { extname, join, resolve, sep as pathSep } from "node:path";
+import { createHash } from "node:crypto";
+import { parse as parseYaml } from "yaml";
+import { validateDefinition } from "./definition-loader.js";
+// ─── Constants ───────────────────────────────────────────────────────────
+const MAX_RESPONSE_BYTES = 256 * 1024;
+const FETCH_TIMEOUT_MS = 15_000;
+const PROVENANCE_FILE = ".installed.json";
+function provenancePath(dir) {
+    return join(dir, PROVENANCE_FILE);
+}
+function readProvenance(dir) {
+    const path = provenancePath(dir);
+    if (!existsSync(path))
+        return {};
+    try {
+        return JSON.parse(readFileSync(path, "utf-8"));
+    }
+    catch {
+        return {};
+    }
+}
+function writeProvenance(dir, data) {
+    mkdirSync(dir, { recursive: true });
+    writeFileSync(provenancePath(dir), JSON.stringify(data, null, 2) + "\n", "utf-8");
+}
+export function globalInstallDir() {
+    const gsdHome = process.env.GSD_HOME || join(homedir(), ".gsd");
+    return join(gsdHome, "workflows");
+}
+export function projectInstallDir(basePath) {
+    return join(basePath, ".gsd", "workflows");
+}
+/**
+ * Reject plugin names that could escape the workflows directory.
+ * Allows a-z, A-Z, 0-9, dot, underscore, hyphen — no separators, no dot-segments.
+ */
+function assertSafePluginName(name) {
+    if (!name || name === "." || name === "..") {
+        throw new Error(`Invalid plugin name: "${name}"`);
+    }
+    if (!/^[a-zA-Z0-9._-]+$/.test(name)) {
+        throw new Error(`Invalid plugin name "${name}". Allowed characters: letters, digits, dot, underscore, hyphen.`);
+    }
+}
+/**
+ * Resolve `child` inside `dir` and refuse any result that escapes `dir`.
+ */
+function safeResolveInDir(dir, child) {
+    const resolvedDir = resolve(dir);
+    const resolvedPath = resolve(resolvedDir, child);
+    if (resolvedPath !== resolvedDir &&
+        !resolvedPath.startsWith(resolvedDir + pathSep)) {
+        throw new Error(`Refusing to operate outside ${dir}: ${child}`);
+    }
+    return resolvedPath;
+}
+// ─── Source URL resolution ───────────────────────────────────────────────
+/**
+ * Turn a user-supplied source specifier into a fetchable HTTPS URL.
+ * Throws on clearly unsafe inputs (file://, unsupported schemes).
+ */
+export function resolveSourceUrl(source) {
+    const trimmed = source.trim();
+    // gist:<id>
+    if (trimmed.startsWith("gist:")) {
+        const id = trimmed.slice("gist:".length).trim();
+        if (!/^[a-f0-9]{6,}$/i.test(id)) {
+            throw new Error(`Invalid gist id: ${id}`);
+        }
+        return `https://gist.githubusercontent.com/anonymous/${id}/raw`;
+    }
+    // gh:owner/repo/path[@ref]
+    if (trimmed.startsWith("gh:")) {
+        const rest = trimmed.slice("gh:".length);
+        const atIdx = rest.lastIndexOf("@");
+        const pathPart = atIdx === -1 ? rest : rest.slice(0, atIdx);
+        const ref = atIdx === -1 ? "main" : rest.slice(atIdx + 1);
+        const parts = pathPart.split("/");
+        if (parts.length < 3) {
+            throw new Error(`Expected gh:<owner>/<repo>/<path>: ${trimmed}`);
+        }
+        const [owner, repo, ...filePath] = parts;
+        return `https://raw.githubusercontent.com/${owner}/${repo}/${ref}/${filePath.join("/")}`;
+    }
+    // file:// — reject
+    if (trimmed.startsWith("file:")) {
+        throw new Error("file:// sources are not supported for security reasons.");
+    }
+    // Must be https:// (or http://localhost for dev)
+    if (trimmed.startsWith("https://"))
+        return trimmed;
+    if (trimmed.startsWith("http://")) {
+        const url = new URL(trimmed);
+        if (url.hostname === "localhost" || url.hostname === "127.0.0.1") {
+            return trimmed;
+        }
+        throw new Error("http:// is only allowed for localhost. Use https://.");
+    }
+    throw new Error(`Unsupported source format: ${trimmed}\n` +
+        `Use one of: https://..., gist:<id>, gh:<owner>/<repo>/<path>[@ref]`);
+}
+/**
+ * Fetch the resolved URL with a timeout and a max response size.
+ * Injects a simple User-Agent so GitHub doesn't 403.
+ */
+export async function fetchWorkflowSource(url) {
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), FETCH_TIMEOUT_MS);
+    try {
+        const res = await fetch(url, {
+            signal: controller.signal,
+            headers: { "User-Agent": "gsd-workflow-install" },
+        });
+        if (!res.ok) {
+            throw new Error(`Fetch failed (${res.status} ${res.statusText}): ${url}`);
+        }
+        // Cap size: read as a stream and bail if it exceeds MAX_RESPONSE_BYTES.
+        const buf = await res.arrayBuffer();
+        if (buf.byteLength > MAX_RESPONSE_BYTES) {
+            throw new Error(`Response too large (${buf.byteLength} bytes, max ${MAX_RESPONSE_BYTES}): ${url}`);
+        }
+        const content = new TextDecoder().decode(buf);
+        // Prefer the final response URL after redirects (e.g., gist /raw → /raw/<sha>/file.ext).
+        const finalUrl = typeof res.url === "string" && res.url ? res.url : url;
+        let pathname;
+        try {
+            pathname = new URL(finalUrl).pathname;
+        }
+        catch {
+            pathname = new URL(url).pathname;
+        }
+        let basename = pathname.slice(pathname.lastIndexOf("/") + 1);
+        let rawExt = extname(basename).toLowerCase();
+        let ext;
+        if (rawExt === ".yaml" || rawExt === ".yml" || rawExt === ".md") {
+            ext = rawExt;
+        }
+        else {
+            // Fallback: sniff content. Gist /raw and similar URLs have no extension.
+            if (/<template_meta>[\s\S]*?<\/template_meta>/.test(content)) {
+                ext = ".md";
+            }
+            else {
+                let parsed;
+                try {
+                    parsed = parseYaml(content);
+                }
+                catch {
+                    parsed = undefined;
+                }
+                if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
+                    ext = ".yaml";
+                }
+                else {
+                    throw new Error(`Cannot determine workflow type from ${url}. ` +
+                        `Expected .yaml/.yml/.md URL, a markdown file with <template_meta>, ` +
+                        `or a YAML document.`);
+                }
+            }
+            // Synthesize a filename so downstream sanitizers have something to chew on.
+            if (!basename)
+                basename = "workflow";
+            basename = `${basename}${ext}`;
+        }
+        const filename = basename;
+        const sha256 = createHash("sha256").update(content).digest("hex");
+        return { url, filename, ext, content, sha256 };
+    }
+    finally {
+        clearTimeout(timer);
+    }
+}
+// ─── Validation ──────────────────────────────────────────────────────────
+/**
+ * Validate fetched content: YAML must pass validateDefinition, markdown must
+ * have a `<template_meta>` block with at least `name`.
+ */
+export function validateFetchedContent(fetched) {
+    if (fetched.ext === ".yaml" || fetched.ext === ".yml") {
+        let parsed;
+        try {
+            parsed = parseYaml(fetched.content);
+        }
+        catch (err) {
+            throw new Error(`Installed YAML failed to parse: ${err instanceof Error ? err.message : String(err)}`);
+        }
+        const result = validateDefinition(parsed);
+        if (!result.valid) {
+            throw new Error(`Installed YAML failed validation:\n  - ${result.errors.join("\n  - ")}`);
+        }
+        // Optional: validate `mode:` if present.
+        if (parsed && typeof parsed === "object") {
+            const mode = parsed.mode;
+            if (mode !== undefined && mode !== "oneshot" && mode !== "yaml-step") {
+                throw new Error(`YAML plugins must declare mode: oneshot or yaml-step (got "${String(mode)}")`);
+            }
+        }
+        return;
+    }
+    // Markdown: require a <template_meta> block with at least a name.
+    const metaMatch = fetched.content.match(/<template_meta>([\s\S]*?)<\/template_meta>/);
+    if (!metaMatch) {
+        throw new Error("Installed markdown must contain a <template_meta>…</template_meta> block.");
+    }
+    if (!/\bname\s*:/i.test(metaMatch[1])) {
+        throw new Error("Installed markdown <template_meta> must declare at least `name:`.");
+    }
+    // Optional: validate `mode:` if declared.
+    const modeLine = metaMatch[1].match(/\bmode\s*:\s*(\S+)/i);
+    if (modeLine) {
+        const mode = modeLine[1];
+        if (mode !== "oneshot" && mode !== "markdown-phase") {
+            throw new Error(`Markdown plugins must declare mode: oneshot or markdown-phase (got "${mode}")`);
+        }
+    }
+}
+// ─── Name inference ──────────────────────────────────────────────────────
+/**
+ * Infer a plugin name from fetched content. For YAML, prefer the top-level
+ * `name:` field. For markdown, prefer `<template_meta>.name`. Fall back to
+ * the filename stem.
+ */
+export function inferPluginName(fetched) {
+    if (fetched.ext === ".yaml" || fetched.ext === ".yml") {
+        try {
+            const parsed = parseYaml(fetched.content);
+            if (parsed && typeof parsed === "object") {
+                const n = parsed.name;
+                if (typeof n === "string" && n.trim())
+                    return sanitizeName(n);
+            }
+        }
+        catch {
+            // Fall through to filename.
+        }
+    }
+    else {
+        const metaMatch = fetched.content.match(/<template_meta>([\s\S]*?)<\/template_meta>/);
+        if (metaMatch) {
+            const nameMatch = metaMatch[1].match(/\bname\s*:\s*(\S+)/i);
+            if (nameMatch)
+                return sanitizeName(nameMatch[1]);
+        }
+    }
+    const stem = fetched.filename.replace(/\.[^.]+$/, "");
+    return sanitizeName(stem);
+}
+function sanitizeName(raw) {
+    return raw.trim().toLowerCase().replace(/[^a-z0-9._-]/g, "-").replace(/^-+|-+$/g, "");
+}
+/**
+ * Write the fetched plugin to disk and update the provenance file.
+ * Does NOT prompt — caller is responsible for confirming with the user first.
+ */
+export function installPlugin(target, fetched, name) {
+    assertSafePluginName(name);
+    mkdirSync(target.dir, { recursive: true });
+    const filename = `${name}${fetched.ext}`;
+    const path = safeResolveInDir(target.dir, filename);
+    writeFileSync(path, fetched.content, "utf-8");
+    const prov = readProvenance(target.dir);
+    prov[name] = {
+        source: fetched.url,
+        installedAt: new Date().toISOString(),
+        sha256: fetched.sha256,
+        filename,
+    };
+    writeProvenance(target.dir, prov);
+    return { path, name, ext: fetched.ext, source: fetched.url };
+}
+/**
+ * Remove an installed plugin and its provenance record.
+ * Checks global dir first, then project (same order as install default).
+ */
+export function uninstallPlugin(basePath, name) {
+    assertSafePluginName(name);
+    for (const dir of [globalInstallDir(), projectInstallDir(basePath)]) {
+        const prov = readProvenance(dir);
+        const entry = prov[name];
+        if (entry) {
+            // Re-validate the filename recorded in provenance: a malicious provenance
+            // file must not trick us into deleting outside `dir`.
+            assertSafePluginName(entry.filename.replace(/\.(yaml|yml|md)$/i, ""));
+            const path = safeResolveInDir(dir, entry.filename);
+            if (existsSync(path))
+                unlinkSync(path);
+            delete prov[name];
+            writeProvenance(dir, prov);
+            return { removed: true, path };
+        }
+        // No provenance, but file might still exist.
+        for (const ext of [".yaml", ".yml", ".md"]) {
+            const candidate = safeResolveInDir(dir, `${name}${ext}`);
+            if (existsSync(candidate) && statSync(candidate).isFile()) {
+                unlinkSync(candidate);
+                return { removed: true, path: candidate, warnedNotInProvenance: true };
+            }
+        }
+    }
+    return { removed: false };
+}
+// ─── Preview helpers ─────────────────────────────────────────────────────
+/**
+ * First N lines of the fetched content, for the install confirmation UI.
+ */
+export function previewContent(content, maxLines = 20) {
+    const lines = content.split(/\r?\n/).slice(0, maxLines);
+    return lines.join("\n");
+}

package/dist/resources/extensions/gsd/workflow-logger.js

@@ -18,6 +18,8 @@
 import { appendFileSync, readFileSync, existsSync, mkdirSync } from "node:fs";
 import { join } from "node:path";
 import { appendNotification } from "./notification-store.js";
+import { buildAuditEnvelope, emitUokAuditEvent } from "./uok/audit.js";
+import { isUnifiedAuditEnabled } from "./uok/audit-toggle.js";
 // ─── Buffer & Persistent Audit ──────────────────────────────────────────
 const MAX_BUFFER = 100;
 let _buffer = [];
@@ -202,6 +204,26 @@ function _push(severity, component, message, context) {
     if (_buffer.length > MAX_BUFFER) {
         _buffer.shift();
     }
+    if (_auditBasePath && isUnifiedAuditEnabled()) {
+        try {
+            emitUokAuditEvent(_auditBasePath, buildAuditEnvelope({
+                traceId: `workflow-log:${component}`,
+                turnId: context?.id,
+                causedBy: context?.fn ?? context?.tool,
+                category: "orchestration",
+                type: severity === "error" ? "workflow-log-error" : "workflow-log-warn",
+                payload: {
+                    component,
+                    message,
+                    context: context ?? {},
+                },
+            }));
+        }
+        catch (auditEmitErr) {
+            // Best-effort: unified audit projection must never block workflow logger.
+            _writeStderr(`[gsd:workflow-logger] unified-audit emit failed: ${auditEmitErr.message}\n`);
+        }
+    }
     // Persist errors to .gsd/audit-log.jsonl so they survive context resets.
     // Only error-severity entries are persisted — warnings are ephemeral (stderr + buffer)
     // to avoid log amplification from expected-control-flow catch paths.