gsd-pi 2.74.0-dev.2b524c3 → 2.74.0-dev.703eabc

package/src/resources/extensions/gsd/ecosystem/loader.ts

@@ -0,0 +1,201 @@
+// 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 type { ExtensionAPI } from "@gsd/pi-coding-agent";
+import { getAgentDir } from "@gsd/pi-coding-agent";
+
+import { logWarning } from "../workflow-logger.js";
+import {
+  createGSDExtensionAPI,
+  type GSDEcosystemBeforeAgentStartHandler,
+  type GSDExtensionAPI,
+} 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: string, agentDir: string): boolean {
+  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: Promise<void> | null = 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: ExtensionAPI,
+  sharedHandlers: GSDEcosystemBeforeAgentStartHandler[],
+  cwd: string = process.cwd(),
+): Promise<void> {
+  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(): Promise<void> {
+  return _readyPromise ?? Promise.resolve();
+}
+
+/** Test-only: clear the singleton so tests can re-run loading. */
+export function _resetEcosystemLoader(): void {
+  _readyPromise = null;
+  _untrustedWarned = false;
+}
+
+// ─── Implementation ─────────────────────────────────────────────────────
+
+async function _loadEcosystemExtensionsImpl(
+  pi: ExtensionAPI,
+  sharedHandlers: GSDEcosystemBeforeAgentStartHandler[],
+  cwd: string,
+): Promise<void> {
+  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: string;
+  try {
+    realExtDir = fs.realpathSync(extDir);
+  } catch (err) {
+    logWarning(
+      "ecosystem",
+      `failed to resolve extensions dir: ${err instanceof Error ? err.message : String(err)}`,
+    );
+    return;
+  }
+
+  let entries: string[];
+  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: GSDExtensionAPI = createGSDExtensionAPI(pi, sharedHandlers);
+
+  for (const entry of entries) {
+    await _loadOne(extDir, realExtDir, entry, api);
+  }
+}
+
+async function _loadOne(
+  extDir: string,
+  realExtDir: string,
+  entry: string,
+  api: GSDExtensionAPI,
+): Promise<void> {
+  const fullPath = path.join(extDir, entry);
+
+  // Symlink-escape guard: reject entries whose realpath is not under realExtDir.
+  let realFullPath: string;
+  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: any;
+  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/src/resources/extensions/gsd/git-service.ts

@@ -34,6 +34,7 @@ import {
   nativeAddPaths,
   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";
@@ -93,6 +94,17 @@ export interface CommitOptions {
   allowEmpty?: boolean;
 }
 
+export type TurnGitActionMode = "commit" | "snapshot" | "status-only";
+
+export interface TurnGitActionResult {
+  action: TurnGitActionMode;
+  status: "ok" | "failed";
+  commitMessage?: string;
+  snapshotLabel?: string;
+  dirty?: boolean;
+  error?: string;
+}
+
 // ─── Meaningful Commit Message Generation ───────────────────────────────────
 
 /** Context for generating a meaningful commit message from task execution results. */
@@ -822,6 +834,62 @@ export function createGitService(basePath: string): GitServiceImpl {
   return new GitServiceImpl(basePath, gitPrefs);
 }
 
+function buildTurnSnapshotLabel(unitType: string, unitId: string): string {
+  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: {
+  basePath: string;
+  action: TurnGitActionMode;
+  unitType: string;
+  unitId: string;
+  taskContext?: TaskCommitContext;
+}): TurnGitActionResult {
+  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 ─────────────────────────────────────────────────
 
 /**

package/src/resources/extensions/gsd/graph-context.ts

@@ -0,0 +1,212 @@
+/**
+ * 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";
+
+interface GraphNode {
+  id: string;
+  label: string;
+  type: string;
+  confidence: string;
+  description?: string;
+}
+
+interface GraphEdge {
+  from: string;
+  to: string;
+  type: string;
+}
+
+interface GraphQueryResult {
+  nodes: GraphNode[];
+  edges: GraphEdge[];
+}
+
+interface GraphStatusResult {
+  exists: boolean;
+  stale: boolean;
+  ageHours?: number;
+}
+
+interface GraphApi {
+  graphQuery: (projectDir: string, term: string, budget?: number) => Promise<GraphQueryResult>;
+  graphStatus: (projectDir: string) => Promise<GraphStatusResult>;
+}
+
+interface GraphFileShape {
+  nodes: GraphNode[];
+  edges: GraphEdge[];
+  builtAt?: string;
+}
+
+let cachedGraphApi: GraphApi | null = null;
+let resolvedGraphApi = false;
+
+export interface GraphSubgraphOptions {
+  /** Budget in tokens passed to graphQuery (1 node ≈ 20 tokens, 1 edge ≈ 10 tokens) */
+  budget: number;
+}
+
+function readGraphFile(projectDir: string): GraphFileShape | null {
+  try {
+    const graphPath = join(projectDir, ".gsd", "graphs", "graph.json");
+    const raw = readFileSync(graphPath, "utf-8");
+    const parsed = JSON.parse(raw) as Partial<GraphFileShape>;
+    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: string, term: string, budget = 3000): Promise<GraphQueryResult> {
+  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] as const));
+
+  // 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: string): Promise<GraphStatusResult> {
+  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: unknown): mod is GraphApi {
+  if (!mod || typeof mod !== "object") return false;
+  const candidate = mod as Record<string, unknown>;
+  return typeof candidate.graphQuery === "function" && typeof candidate.graphStatus === "function";
+}
+
+async function resolveGraphApi(): Promise<GraphApi> {
+  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: string,
+  term: string,
+  opts: GraphSubgraphOptions,
+): Promise<string | null> {
+  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: string[] = [
+      `### 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;
+  }
+}