gsd-pi 2.67.0-dev.2142d3e → 2.67.0-dev.2367d7e

package/src/resources/extensions/gsd/mcp-project-config.ts

@@ -0,0 +1,128 @@
+import { existsSync, readFileSync, writeFileSync } from "node:fs";
+import { resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+
+import { assertSafeDirectory } from "./validate-directory.js";
+import { detectWorkflowMcpLaunchConfig } from "./workflow-mcp.js";
+
+export const GSD_WORKFLOW_MCP_SERVER_NAME = "gsd-workflow";
+
+export interface ProjectMcpServerConfig {
+  command?: string;
+  args?: string[];
+  cwd?: string;
+  env?: Record<string, string>;
+  url?: string;
+}
+
+export interface EnsureProjectWorkflowMcpConfigResult {
+  configPath: string;
+  serverName: string;
+  status: "created" | "updated" | "unchanged";
+}
+
+interface McpConfigFile {
+  mcpServers?: Record<string, ProjectMcpServerConfig>;
+  servers?: Record<string, ProjectMcpServerConfig>;
+  [key: string]: unknown;
+}
+
+export function resolveBundledGsdCliPath(env: NodeJS.ProcessEnv = process.env): string | null {
+  const explicit = env.GSD_CLI_PATH?.trim() || env.GSD_BIN_PATH?.trim();
+  if (explicit) return explicit;
+
+  const candidates = [
+    resolve(fileURLToPath(new URL("../../../../scripts/dev-cli.js", import.meta.url))),
+    resolve(fileURLToPath(new URL("../../../../dist/loader.js", import.meta.url))),
+    resolve(fileURLToPath(new URL("../../../loader.js", import.meta.url))),
+  ];
+
+  for (const candidate of candidates) {
+    if (existsSync(candidate)) return candidate;
+  }
+
+  return null;
+}
+
+export function buildProjectWorkflowMcpServerConfig(
+  projectRoot: string,
+  env: NodeJS.ProcessEnv = process.env,
+): ProjectMcpServerConfig {
+  const resolvedProjectRoot = resolve(projectRoot);
+  const gsdCliPath = resolveBundledGsdCliPath(env);
+  const launch = detectWorkflowMcpLaunchConfig(resolvedProjectRoot, {
+    ...env,
+    ...(gsdCliPath ? { GSD_CLI_PATH: gsdCliPath, GSD_BIN_PATH: gsdCliPath } : {}),
+  });
+
+  if (!launch) {
+    throw new Error(
+      "Unable to resolve the GSD workflow MCP server. Build this checkout or install gsd-mcp-server on PATH.",
+    );
+  }
+
+  return {
+    command: launch.command,
+    ...(launch.args && launch.args.length > 0 ? { args: launch.args } : {}),
+    ...(launch.cwd ? { cwd: launch.cwd } : {}),
+    ...(launch.env ? { env: launch.env } : {}),
+  };
+}
+
+function readExistingConfig(configPath: string): McpConfigFile {
+  if (!existsSync(configPath)) return {};
+
+  const raw = readFileSync(configPath, "utf-8");
+  try {
+    const parsed = JSON.parse(raw) as McpConfigFile;
+    return parsed && typeof parsed === "object" ? parsed : {};
+  } catch (err) {
+    throw new Error(
+      `Failed to parse ${configPath}: ${err instanceof Error ? err.message : String(err)}`,
+    );
+  }
+}
+
+export function ensureProjectWorkflowMcpConfig(
+  projectRoot: string,
+  env: NodeJS.ProcessEnv = process.env,
+): EnsureProjectWorkflowMcpConfigResult {
+  const resolvedProjectRoot = resolve(projectRoot);
+  assertSafeDirectory(resolvedProjectRoot);
+
+  const configPath = resolve(resolvedProjectRoot, ".mcp.json");
+  const existing = readExistingConfig(configPath);
+  const desiredServer = buildProjectWorkflowMcpServerConfig(resolvedProjectRoot, env);
+  const previousServers = existing.mcpServers ?? {};
+  const nextServers = {
+    ...previousServers,
+    [GSD_WORKFLOW_MCP_SERVER_NAME]: desiredServer,
+  };
+
+  const alreadyPresent = existsSync(configPath);
+  const unchanged =
+    JSON.stringify(previousServers[GSD_WORKFLOW_MCP_SERVER_NAME] ?? null)
+      === JSON.stringify(desiredServer)
+    && existing.mcpServers !== undefined;
+
+  if (unchanged) {
+    return {
+      configPath,
+      serverName: GSD_WORKFLOW_MCP_SERVER_NAME,
+      status: "unchanged",
+    };
+  }
+
+  const nextConfig: McpConfigFile = {
+    ...existing,
+    mcpServers: nextServers,
+  };
+
+  writeFileSync(configPath, `${JSON.stringify(nextConfig, null, 2)}\n`, "utf-8");
+
+  return {
+    configPath,
+    serverName: GSD_WORKFLOW_MCP_SERVER_NAME,
+    status: alreadyPresent ? "updated" : "created",
+  };
+}

package/src/resources/extensions/gsd/state.ts

@@ -47,6 +47,7 @@ import { extractVerdict } from './verdict-parser.js';
 
 import {
   isDbAvailable,
+  wasDbOpenAttempted,
   getAllMilestones,
   getMilestone,
   getMilestoneSlices,
@@ -271,7 +272,12 @@ export async function deriveState(basePath: string): Promise<GSDState> {
       _telemetry.markdownDeriveCount++;
     }
   } else {
-    logWarning("state", "DB unavailable — using filesystem state derivation (degraded mode)");
+    // Only warn when DB initialization was attempted and failed — not when
+    // the DB simply hasn't been opened yet (e.g. during before_agent_start
+    // context injection which runs before any tool invocation opens the DB).
+    if (wasDbOpenAttempted()) {
+      logWarning("state", "DB unavailable — using filesystem state derivation (degraded mode)");
+    }
     result = await _deriveStateImpl(basePath);
     _telemetry.markdownDeriveCount++;
   }

package/src/resources/extensions/gsd/tests/auto-project-root-env.test.ts

@@ -0,0 +1,29 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+import { readFileSync } from "node:fs";
+import { join } from "node:path";
+
+const sourcePath = join(import.meta.dirname, "..", "auto.ts");
+const source = readFileSync(sourcePath, "utf-8");
+
+test("auto-mode captures GSD_PROJECT_ROOT before entering the dispatch loop", () => {
+  const captureDeclIdx = source.indexOf("function captureProjectRootEnv(projectRoot: string): void {");
+  assert.ok(captureDeclIdx > -1, "auto.ts should define captureProjectRootEnv()");
+
+  const resumeCallIdx = source.indexOf("captureProjectRootEnv(s.originalBasePath || s.basePath);");
+  assert.ok(resumeCallIdx > -1, "auto.ts should capture GSD_PROJECT_ROOT before resume autoLoop");
+
+  const firstAutoLoopIdx = source.indexOf("await autoLoop(ctx, pi, s, buildLoopDeps());");
+  assert.ok(firstAutoLoopIdx > -1, "auto.ts should invoke autoLoop()");
+  assert.ok(
+    resumeCallIdx < firstAutoLoopIdx,
+    "auto.ts must set GSD_PROJECT_ROOT before the first autoLoop() call",
+  );
+});
+
+test("auto-mode restores GSD_PROJECT_ROOT when execution stops or pauses", () => {
+  assert.match(source, /function restoreProjectRootEnv\(\): void \{/);
+  assert.match(source, /cleanupAfterLoopExit\(ctx: ExtensionContext\): void \{[\s\S]*restoreProjectRootEnv\(\);/);
+  assert.match(source, /export async function pauseAuto\([\s\S]*restoreProjectRootEnv\(\);/);
+  assert.match(source, /\} finally \{[\s\S]*restoreProjectRootEnv\(\);[\s\S]*s\.reset\(\);/);
+});