gsd-pi 2.74.0-dev.2b524c3 → 2.74.0-dev.658744a

package/dist/resources/extensions/gsd/ecosystem/loader.js

@@ -0,0 +1,145 @@
+// GSD2 — Ecosystem extension loader for ./.gsd/extensions/
+// Discovers and registers single-file extensions that consume GSDExtensionAPI.
+// Trust-gated (mirrors pi's `.pi/extensions/` model) and isolated from pi's
+// own loader chain — handlers run in GSD's own dispatch step, not pi's.
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { pathToFileURL } from "node:url";
+import { getAgentDir } from "@gsd/pi-coding-agent";
+import { logWarning } from "../workflow-logger.js";
+import { createGSDExtensionAPI, } from "./gsd-extension-api.js";
+// ─── Trust check (inlined; pi does not export isProjectTrusted from its
+// package root, and constraint forbids modifying packages/pi-coding-agent/) ─
+const TRUSTED_PROJECTS_FILE = "trusted-projects.json";
+function isProjectTrusted(projectPath, agentDir) {
+    const canonical = path.resolve(projectPath);
+    const trustedPath = path.join(agentDir, TRUSTED_PROJECTS_FILE);
+    try {
+        const content = fs.readFileSync(trustedPath, "utf-8");
+        const parsed = JSON.parse(content);
+        if (Array.isArray(parsed)) {
+            return parsed.includes(canonical);
+        }
+    }
+    catch {
+        // missing or malformed — treat as untrusted
+    }
+    return false;
+}
+// ─── Ready-promise singleton ────────────────────────────────────────────
+let _readyPromise = null;
+let _untrustedWarned = false;
+/**
+ * Discover and register ecosystem extensions from `./.gsd/extensions/`.
+ * Idempotent: subsequent calls with the same arguments return the same
+ * pending promise (no double-load).
+ */
+export function loadEcosystemExtensions(pi, sharedHandlers, cwd = process.cwd()) {
+    if (_readyPromise)
+        return _readyPromise;
+    _readyPromise = _loadEcosystemExtensionsImpl(pi, sharedHandlers, cwd);
+    return _readyPromise;
+}
+/**
+ * Returns a promise that resolves when ecosystem loading has completed.
+ * If loading was never kicked off this returns a resolved promise so the
+ * `before_agent_start` handler can `await` unconditionally.
+ */
+export function getEcosystemReadyPromise() {
+    return _readyPromise ?? Promise.resolve();
+}
+/** Test-only: clear the singleton so tests can re-run loading. */
+export function _resetEcosystemLoader() {
+    _readyPromise = null;
+    _untrustedWarned = false;
+}
+// ─── Implementation ─────────────────────────────────────────────────────
+async function _loadEcosystemExtensionsImpl(pi, sharedHandlers, cwd) {
+    const extDir = path.join(cwd, ".gsd", "extensions");
+    if (!fs.existsSync(extDir))
+        return;
+    // Trust gate: refuse to load arbitrary code from untrusted project dirs.
+    if (!isProjectTrusted(cwd, getAgentDir())) {
+        if (!_untrustedWarned) {
+            _untrustedWarned = true;
+            logWarning("ecosystem", ".gsd/extensions present but project is not trusted — skipping ecosystem extensions. Run `pi trust` to opt in.");
+        }
+        return;
+    }
+    // Resolve realpath ONCE so symlink-escape detection has a stable anchor.
+    let realExtDir;
+    try {
+        realExtDir = fs.realpathSync(extDir);
+    }
+    catch (err) {
+        logWarning("ecosystem", `failed to resolve extensions dir: ${err instanceof Error ? err.message : String(err)}`);
+        return;
+    }
+    let entries;
+    try {
+        entries = fs
+            .readdirSync(extDir)
+            .filter((f) => f.endsWith(".js") || f.endsWith(".ts"))
+            .sort(); // deterministic load order
+    }
+    catch (err) {
+        logWarning("ecosystem", `failed to read extensions dir: ${err instanceof Error ? err.message : String(err)}`);
+        return;
+    }
+    // The wrapper api is built once per loader run and shared by all extensions
+    // so they all read from the same module-level snapshot.
+    const api = createGSDExtensionAPI(pi, sharedHandlers);
+    for (const entry of entries) {
+        await _loadOne(extDir, realExtDir, entry, api);
+    }
+}
+async function _loadOne(extDir, realExtDir, entry, api) {
+    const fullPath = path.join(extDir, entry);
+    // Symlink-escape guard: reject entries whose realpath is not under realExtDir.
+    let realFullPath;
+    try {
+        realFullPath = fs.realpathSync(fullPath);
+    }
+    catch (err) {
+        logWarning("ecosystem", `failed to resolve ${entry}: ${err instanceof Error ? err.message : String(err)}`);
+        return;
+    }
+    const realExtDirWithSep = realExtDir.endsWith(path.sep) ? realExtDir : realExtDir + path.sep;
+    if (realFullPath !== realExtDir &&
+        !realFullPath.startsWith(realExtDirWithSep)) {
+        logWarning("ecosystem", `rejecting ${entry}: realpath escapes extensions dir`);
+        return;
+    }
+    // For .ts files, require a sibling compiled .js — we do not run a TS loader
+    // in production. Drop mtime heuristics: if .js exists, prefer it; otherwise warn.
+    let importPath = realFullPath;
+    if (entry.endsWith(".ts")) {
+        const jsSibling = realFullPath.slice(0, -3) + ".js";
+        if (fs.existsSync(jsSibling)) {
+            importPath = jsSibling;
+        }
+        else {
+            logWarning("ecosystem", `${entry}: TypeScript source has no compiled .js sibling — compile it first`);
+            return;
+        }
+    }
+    let mod;
+    try {
+        mod = await import(pathToFileURL(importPath).href);
+    }
+    catch (err) {
+        logWarning("ecosystem", `failed to import ${entry}: ${err instanceof Error ? err.message : String(err)}`);
+        return;
+    }
+    const factory = mod?.default;
+    if (typeof factory !== "function") {
+        logWarning("ecosystem", `${entry}: default export is not a function`);
+        return;
+    }
+    try {
+        await factory(api);
+    }
+    catch (err) {
+        logWarning("ecosystem", `factory threw for ${entry}: ${err instanceof Error ? err.message : String(err)}`);
+    }
+}

package/dist/resources/extensions/gsd/git-service.js

@@ -15,7 +15,7 @@ import { GIT_NO_PROMPT_ENV } from "./git-constants.js";
 import { loadEffectiveGSDPreferences } from "./preferences.js";
 import { detectWorktreeName, } from "./worktree.js";
 import { SLICE_BRANCH_RE, QUICK_BRANCH_RE, WORKFLOW_BRANCH_RE } from "./branch-patterns.js";
-import { nativeGetCurrentBranch, nativeDetectMainBranch, nativeBranchExists, nativeHasChanges, nativeAddAllWithExclusions, nativeHasStagedChanges, nativeCommit, nativeRmCached, nativeUpdateRef, nativeResetSoft, nativeCommitSubject, } from "./native-git-bridge.js";
+import { nativeGetCurrentBranch, nativeDetectMainBranch, nativeBranchExists, nativeHasChanges, nativeAddAllWithExclusions, nativeHasStagedChanges, nativeCommit, nativeRmCached, nativeUpdateRef, nativeResetSoft, nativeCommitSubject, _resetHasChangesCache, } from "./native-git-bridge.js";
 import { GSDError, GSD_MERGE_CONFLICT, GSD_GIT_ERROR } from "./errors.js";
 import { getErrorMessage } from "./error-utils.js";
 export const VALID_BRANCH_NAME = /^[a-zA-Z0-9_\-\/.]+$/;
@@ -641,6 +641,54 @@ export function createGitService(basePath) {
     const gitPrefs = loadEffectiveGSDPreferences()?.preferences?.git ?? {};
     return new GitServiceImpl(basePath, gitPrefs);
 }
+function buildTurnSnapshotLabel(unitType, unitId) {
+    const raw = `${unitType}/${unitId}`.trim();
+    if (!raw)
+        return "turn";
+    return raw
+        .replace(/[^a-zA-Z0-9._/-]/g, "-")
+        .replace(/\/{2,}/g, "/")
+        .replace(/-{2,}/g, "-")
+        .replace(/^[-/]+|[-/]+$/g, "") || "turn";
+}
+export function runTurnGitAction(args) {
+    try {
+        // Force fresh working-tree status per turn; nativeHasChanges caches briefly.
+        _resetHasChangesCache();
+        if (args.action === "status-only") {
+            return {
+                action: args.action,
+                status: "ok",
+                dirty: nativeHasChanges(args.basePath),
+            };
+        }
+        const git = createGitService(args.basePath);
+        if (args.action === "snapshot") {
+            const label = buildTurnSnapshotLabel(args.unitType, args.unitId);
+            git.createSnapshot(label);
+            return {
+                action: args.action,
+                status: "ok",
+                snapshotLabel: label,
+                dirty: nativeHasChanges(args.basePath),
+            };
+        }
+        const commitMessage = git.autoCommit(args.unitType, args.unitId, [], args.taskContext) ?? undefined;
+        return {
+            action: args.action,
+            status: "ok",
+            commitMessage,
+            dirty: nativeHasChanges(args.basePath),
+        };
+    }
+    catch (err) {
+        return {
+            action: args.action,
+            status: "failed",
+            error: getErrorMessage(err),
+        };
+    }
+}
 // ─── Commit Type Inference ─────────────────────────────────────────────────
 /**
  * Infer a conventional commit type from a title (and optional one-liner).

package/dist/resources/extensions/gsd/graph-context.js

@@ -0,0 +1,157 @@
+/**
+ * Graph-aware context injection for dispatch prompt builders.
+ *
+ * Reads the pre-built graph.json and returns a formatted context block
+ * for injection into prompts. Gracefully returns null when no graph exists
+ * or the query yields no results — callers must handle null.
+ */
+import { logWarning } from "./workflow-logger.js";
+import { readFileSync } from "node:fs";
+import { join } from "node:path";
+let cachedGraphApi = null;
+let resolvedGraphApi = false;
+function readGraphFile(projectDir) {
+    try {
+        const graphPath = join(projectDir, ".gsd", "graphs", "graph.json");
+        const raw = readFileSync(graphPath, "utf-8");
+        const parsed = JSON.parse(raw);
+        const nodes = Array.isArray(parsed.nodes) ? parsed.nodes : [];
+        const edges = Array.isArray(parsed.edges) ? parsed.edges : [];
+        return { nodes, edges, builtAt: typeof parsed.builtAt === "string" ? parsed.builtAt : undefined };
+    }
+    catch {
+        return null;
+    }
+}
+async function fallbackGraphQuery(projectDir, term, budget = 3000) {
+    const graph = readGraphFile(projectDir);
+    if (!graph)
+        return { nodes: [], edges: [] };
+    const needle = term.trim().toLowerCase();
+    const matches = graph.nodes.filter((node) => {
+        const hay = [node.id, node.label, node.description].filter(Boolean).join(" ").toLowerCase();
+        return hay.includes(needle);
+    });
+    const maxNodes = Math.max(1, Math.floor(Math.max(1, budget) / 20));
+    const selectedIds = new Set(matches.slice(0, maxNodes).map((node) => node.id));
+    const nodeById = new Map(graph.nodes.map((node) => [node.id, node]));
+    // Pull one-hop neighbors so relation context survives even when the term
+    // matches only one side of an edge.
+    for (const edge of graph.edges) {
+        if (selectedIds.size >= maxNodes)
+            break;
+        const touchesSelection = selectedIds.has(edge.from) || selectedIds.has(edge.to);
+        if (!touchesSelection)
+            continue;
+        if (selectedIds.has(edge.from) && !selectedIds.has(edge.to) && nodeById.has(edge.to)) {
+            selectedIds.add(edge.to);
+        }
+        else if (selectedIds.has(edge.to) && !selectedIds.has(edge.from) && nodeById.has(edge.from)) {
+            selectedIds.add(edge.from);
+        }
+    }
+    const nodes = graph.nodes.filter((node) => selectedIds.has(node.id));
+    const remainingBudget = Math.max(0, budget - nodes.length * 20);
+    const maxEdges = Math.floor(remainingBudget / 10);
+    const edges = graph.edges
+        .filter((edge) => selectedIds.has(edge.from) && selectedIds.has(edge.to))
+        .slice(0, maxEdges);
+    return { nodes, edges };
+}
+async function fallbackGraphStatus(projectDir) {
+    const graph = readGraphFile(projectDir);
+    if (!graph)
+        return { exists: false, stale: false };
+    if (!graph.builtAt)
+        return { exists: true, stale: false };
+    const builtAtMs = Date.parse(graph.builtAt);
+    if (!Number.isFinite(builtAtMs))
+        return { exists: true, stale: false };
+    const ageHours = (Date.now() - builtAtMs) / (1000 * 60 * 60);
+    return { exists: true, stale: ageHours > 24, ageHours };
+}
+function isGraphApi(mod) {
+    if (!mod || typeof mod !== "object")
+        return false;
+    const candidate = mod;
+    return typeof candidate.graphQuery === "function" && typeof candidate.graphStatus === "function";
+}
+async function resolveGraphApi() {
+    if (resolvedGraphApi && cachedGraphApi)
+        return cachedGraphApi;
+    resolvedGraphApi = true;
+    try {
+        const imported = await import("@gsd-build/mcp-server");
+        if (isGraphApi(imported)) {
+            cachedGraphApi = imported;
+            return cachedGraphApi;
+        }
+        logWarning("prompt", "@gsd-build/mcp-server graph exports unavailable; using local graph fallback");
+    }
+    catch {
+        // Fall back to local reader implementation.
+    }
+    cachedGraphApi = {
+        graphQuery: fallbackGraphQuery,
+        graphStatus: fallbackGraphStatus,
+    };
+    return cachedGraphApi;
+}
+/**
+ * Query the knowledge graph for nodes related to the given term and format
+ * the result as an inlined context block.
+ *
+ * Returns null when:
+ * - @gsd-build/mcp-server fails to import
+ * - graph.json does not exist (graphQuery already handles this gracefully)
+ * - query returns zero nodes
+ *
+ * Annotates the block header when the graph is stale (> 24 hours old).
+ */
+export async function inlineGraphSubgraph(projectDir, term, opts) {
+    if (!term || !term.trim())
+        return null;
+    try {
+        const graphApi = await resolveGraphApi();
+        const result = await graphApi.graphQuery(projectDir, term, opts.budget);
+        if (result.nodes.length === 0)
+            return null;
+        // Check staleness for annotation
+        let staleAnnotation = "";
+        try {
+            const status = await graphApi.graphStatus(projectDir);
+            if (status.exists && status.stale && status.ageHours !== undefined) {
+                const hours = Math.round(status.ageHours);
+                staleAnnotation = `\n> ⚠ Graph last built ${hours}h ago — context may be outdated`;
+            }
+        }
+        catch {
+            // Non-fatal — skip annotation on error
+        }
+        // Format nodes as a compact list
+        const nodeLines = result.nodes.map((node) => {
+            const desc = node.description ? ` — ${node.description}` : "";
+            return `- **${node.label}** (\`${node.type}\`, ${node.confidence})${desc}`;
+        });
+        // Format edges as relations (only if present)
+        const edgeLines = result.edges.length > 0
+            ? result.edges.map((edge) => `- \`${edge.from}\` →[${edge.type}]→ \`${edge.to}\``)
+            : [];
+        const sections = [
+            `### Knowledge Graph Context (term: "${term}")`,
+            `Source: \`.gsd/graphs/graph.json\``,
+            staleAnnotation,
+            "",
+            `**Nodes (${result.nodes.length}):**`,
+            ...nodeLines,
+        ];
+        if (edgeLines.length > 0) {
+            sections.push("", `**Relations (${result.edges.length}):**`, ...edgeLines);
+        }
+        return sections.filter((l) => l !== undefined).join("\n");
+    }
+    catch (err) {
+        logWarning("prompt", `inlineGraphSubgraph failed (non-fatal): ${err instanceof Error ? err.message : String(err)}`);
+        return null;
+    }
+}