gsd-pi 2.5.0 → 2.6.0

package/README.md

@@ -224,6 +224,7 @@ On first run, GSD launches a branded setup wizard that walks you through LLM pro
 | `Ctrl+Alt+V` | Toggle voice transcription |
 | `Ctrl+Alt+B` | Show background shell processes |
 | `gsd config` | Re-run the setup wizard (LLM provider + tool keys) |
+| `gsd --continue` (`-c`) | Resume the most recent session for the current directory |
 
 ---
 

package/dist/cli.js

@@ -20,6 +20,9 @@ function parseCliArgs(argv) {
         else if (arg === '--print' || arg === '-p') {
             flags.print = true;
         }
+        else if (arg === '--continue' || arg === '-c') {
+            flags.continue = true;
+        }
         else if (arg === '--no-session') {
             flags.noSession = true;
         }
@@ -45,6 +48,7 @@ function parseCliArgs(argv) {
             process.stdout.write('Options:\n');
             process.stdout.write('  --mode <text|json|rpc>   Output mode (default: interactive)\n');
             process.stdout.write('  --print, -p              Single-shot print mode\n');
+            process.stdout.write('  --continue, -c           Resume the most recent session\n');
             process.stdout.write('  --model <id>             Override model (e.g. claude-opus-4-6)\n');
             process.stdout.write('  --no-session             Disable session persistence\n');
             process.stdout.write('  --extension <path>       Load additional extension\n');
@@ -200,7 +204,9 @@ if (existsSync(sessionsDir)) {
         // Non-fatal — don't block startup if migration fails
     }
 }
-const sessionManager = SessionManager.create(cwd, projectSessionsDir);
+const sessionManager = cliFlags.continue
+    ? SessionManager.continueRecent(cwd, projectSessionsDir)
+    : SessionManager.create(cwd, projectSessionsDir);
 initResources(agentDir);
 const resourceLoader = buildResourceLoader(agentDir);
 await resourceLoader.reload();

package/dist/loader.js

@@ -1,8 +1,9 @@
 #!/usr/bin/env node
 import { fileURLToPath } from 'url';
 import { dirname, resolve, join } from 'path';
-import { readFileSync } from 'fs';
-import { agentDir } from './app-paths.js';
+import { existsSync, readFileSync } from 'fs';
+import { agentDir, appRoot } from './app-paths.js';
+import { renderLogo } from './logo.js';
 // pkg/ is a shim directory: contains gsd's piConfig (package.json) and pi's
 // theme assets (dist/modes/interactive/theme/) without a src/ directory.
 // This allows config.js to:
@@ -14,7 +15,24 @@ const pkgDir = resolve(dirname(fileURLToPath(import.meta.url)), '..', 'pkg');
 process.env.PI_PACKAGE_DIR = pkgDir;
 process.env.PI_SKIP_VERSION_CHECK = '1'; // GSD ships its own update check — suppress pi's
 process.title = 'gsd';
-// First-launch branding is handled by the onboarding wizard (src/onboarding.ts)
+// Print branded banner on first launch (before ~/.gsd/ exists)
+if (!existsSync(appRoot)) {
+    const cyan = '\x1b[36m';
+    const green = '\x1b[32m';
+    const dim = '\x1b[2m';
+    const reset = '\x1b[0m';
+    const colorCyan = (s) => `${cyan}${s}${reset}`;
+    let version = '';
+    try {
+        const pkgJson = JSON.parse(readFileSync(resolve(dirname(fileURLToPath(import.meta.url)), '..', 'package.json'), 'utf-8'));
+        version = pkgJson.version ?? '';
+    }
+    catch { /* ignore */ }
+    process.stderr.write(renderLogo(colorCyan) +
+        '\n' +
+        `  Get Shit Done ${dim}v${version}${reset}\n` +
+        `  ${green}Welcome.${reset} Setting up your environment...\n\n`);
+}
 // GSD_CODING_AGENT_DIR — tells pi's getAgentDir() to return ~/.gsd/agent/ instead of ~/.gsd/agent/
 process.env.GSD_CODING_AGENT_DIR = agentDir;
 // NODE_PATH — make gsd's own node_modules available to extensions loaded via jiti.

package/dist/logo.d.ts

@@ -3,14 +3,14 @@
  *
  * Single source of truth — imported by:
  *   - scripts/postinstall.js (via dist/logo.js)
- *   - src/onboarding.ts (via ./logo.js)
+ *   - src/loader.ts (via ./logo.js)
  */
 /** Raw logo lines — no ANSI codes, no leading newline. */
-export declare const GSD_LOGO: string[];
+export declare const GSD_LOGO: readonly string[];
 /**
  * Render the logo block with a color function applied to each line.
  *
- * @param color — e.g. picocolors.cyan or `(s) => `\x1b[36m${s}\x1b[0m``
+ * @param color — e.g. `(s) => `\x1b[36m${s}\x1b[0m`` or picocolors.cyan
  * @returns Ready-to-write string with leading/trailing newlines.
  */
 export declare function renderLogo(color: (s: string) => string): string;

package/dist/logo.js

@@ -3,7 +3,7 @@
  *
  * Single source of truth — imported by:
  *   - scripts/postinstall.js (via dist/logo.js)
- *   - src/onboarding.ts (via ./logo.js)
+ *   - src/loader.ts (via ./logo.js)
  */
 /** Raw logo lines — no ANSI codes, no leading newline. */
 export const GSD_LOGO = [
@@ -17,7 +17,7 @@ export const GSD_LOGO = [
 /**
  * Render the logo block with a color function applied to each line.
  *
- * @param color — e.g. picocolors.cyan or `(s) => `\x1b[36m${s}\x1b[0m``
+ * @param color — e.g. `(s) => `\x1b[36m${s}\x1b[0m`` or picocolors.cyan
  * @returns Ready-to-write string with leading/trailing newlines.
  */
 export function renderLogo(color) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "gsd-pi",
-  "version": "2.5.0",
+  "version": "2.6.0",
   "description": "GSD — Get Shit Done coding agent",
   "license": "MIT",
   "repository": {

package/src/resources/extensions/get-secrets-from-user.ts

@@ -7,11 +7,16 @@
  */
 
 import { readFile, writeFile } from "node:fs/promises";
+import { existsSync, statSync } from "node:fs";
 import { resolve } from "node:path";
 
-import type { ExtensionAPI } from "@mariozechner/pi-coding-agent";
-import { CURSOR_MARKER, Editor, type EditorTheme, Key, matchesKey, Text, truncateToWidth } from "@mariozechner/pi-tui";
+import type { ExtensionAPI, Theme } from "@mariozechner/pi-coding-agent";
+import { CURSOR_MARKER, Editor, type EditorTheme, Key, matchesKey, Text, truncateToWidth, wrapTextWithAnsi } from "@mariozechner/pi-tui";
 import { Type } from "@sinclair/typebox";
+import { makeUI, type ProgressStatus } from "./shared/ui.js";
+import { parseSecretsManifest, formatSecretsManifest } from "./gsd/files.js";
+import { resolveMilestoneFile } from "./gsd/paths.js";
+import type { SecretsManifestEntry } from "./gsd/types.js";
 
 // ─── Types ────────────────────────────────────────────────────────────────────
 
@@ -25,6 +30,8 @@ interface ToolResultDetails {
 	environment?: string;
 	applied: string[];
 	skipped: string[];
+	existingSkipped?: string[];
+	detectedDestination?: string;
 }
 
 // ─── Helpers ──────────────────────────────────────────────────────────────────
@@ -91,6 +98,52 @@ async function writeEnvKey(filePath: string, key: string, value: string): Promis
 	await writeFile(filePath, content, "utf8");
 }
 
+// ─── Exported utilities ───────────────────────────────────────────────────────
+
+/**
+ * Check which keys already exist in the .env file or process.env.
+ * Returns the subset of `keys` that are already set.
+ * Handles ENOENT gracefully (still checks process.env).
+ * Empty-string values count as existing.
+ */
+export async function checkExistingEnvKeys(keys: string[], envFilePath: string): Promise<string[]> {
+	let fileContent = "";
+	try {
+		fileContent = await readFile(envFilePath, "utf8");
+	} catch {
+		// ENOENT or other read error — proceed with empty content
+	}
+
+	const existing: string[] = [];
+	for (const key of keys) {
+		const escaped = key.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+		const regex = new RegExp(`^${escaped}\\s*=`, "m");
+		if (regex.test(fileContent) || key in process.env) {
+			existing.push(key);
+		}
+	}
+	return existing;
+}
+
+/**
+ * Detect the write destination based on project files in basePath.
+ * Priority: vercel.json → convex/ dir → fallback "dotenv".
+ */
+export function detectDestination(basePath: string): "dotenv" | "vercel" | "convex" {
+	if (existsSync(resolve(basePath, "vercel.json"))) {
+		return "vercel";
+	}
+	const convexPath = resolve(basePath, "convex");
+	try {
+		if (existsSync(convexPath) && statSync(convexPath).isDirectory()) {
+			return "convex";
+		}
+	} catch {
+		// stat error — treat as not found
+	}
+	return "dotenv";
+}
+
 // ─── Paged secure input UI ────────────────────────────────────────────────────
 
 /**
@@ -103,6 +156,7 @@ async function collectOneSecret(
 	totalPages: number,
 	keyName: string,
 	hint: string | undefined,
+	guidance?: string[],
 ): Promise<string | null> {
 	if (!ctx.hasUI) return null;
 
@@ -160,6 +214,21 @@ async function collectOneSecret(
 			if (hint) {
 				add(theme.fg("muted", `  ${hint}`));
 			}
+
+			// Guidance steps (numbered, dim, wrapped for long URLs)
+			if (guidance && guidance.length > 0) {
+				lines.push("");
+				for (let g = 0; g < guidance.length; g++) {
+					const prefix = `  ${g + 1}. `;
+					const step = guidance[g] as string;
+					const wrappedLines = wrapTextWithAnsi(step, width - 4);
+					for (let w = 0; w < wrappedLines.length; w++) {
+						const indent = w === 0 ? prefix : " ".repeat(prefix.length);
+						lines.push(theme.fg("dim", `${indent}${wrappedLines[w]}`));
+					}
+				}
+			}
+
 			lines.push("");
 
 			// Masked preview
@@ -190,6 +259,248 @@ async function collectOneSecret(
 	});
 }
 
+/**
+ * Exported wrapper around collectOneSecret for testing.
+ * Exposes the same interface with guidance parameter for test verification.
+ */
+export const collectOneSecretWithGuidance = collectOneSecret;
+
+// ─── Summary Screen ───────────────────────────────────────────────────────────
+
+/**
+ * Read-only summary screen showing all manifest entries with status indicators.
+ * Follows the confirm-ui.ts pattern: render → any key → done.
+ *
+ * Status mapping:
+ * - collected → done
+ * - pending   → pending
+ * - skipped   → skipped
+ * - existing keys (in existingKeys) → done with "already set" annotation
+ */
+export async function showSecretsSummary(
+	ctx: { ui: any; hasUI: boolean },
+	entries: SecretsManifestEntry[],
+	existingKeys: string[],
+): Promise<void> {
+	if (!ctx.hasUI) return;
+
+	const existingSet = new Set(existingKeys);
+
+	await ctx.ui.custom<void>((tui: any, theme: Theme, _kb: any, done: () => void) => {
+		let cachedLines: string[] | undefined;
+
+		function handleInput(_data: string) {
+			// Any key dismisses
+			done();
+		}
+
+		function render(width: number): string[] {
+			if (cachedLines) return cachedLines;
+
+			const ui = makeUI(theme, width);
+			const lines: string[] = [];
+			const push = (...rows: string[][]) => { for (const r of rows) lines.push(...r); };
+
+			push(ui.bar());
+			push(ui.blank());
+			push(ui.header("  Secrets Summary"));
+			push(ui.blank());
+
+			for (const entry of entries) {
+				let status: ProgressStatus;
+				let detail: string | undefined;
+
+				if (existingSet.has(entry.key)) {
+					status = "done";
+					detail = "already set";
+				} else if (entry.status === "collected") {
+					status = "done";
+				} else if (entry.status === "skipped") {
+					status = "skipped";
+				} else {
+					status = "pending";
+				}
+
+				push(ui.progressItem(entry.key, status, { detail }));
+			}
+
+			push(ui.blank());
+			push(ui.hints(["any key to continue"]));
+			push(ui.bar());
+
+			cachedLines = lines;
+			return lines;
+		}
+
+		return {
+			render,
+			invalidate: () => { cachedLines = undefined; },
+			handleInput,
+		};
+	});
+}
+
+// ─── Destination Write Helper ─────────────────────────────────────────────────
+
+/**
+ * Apply collected secrets to the target destination.
+ * Dotenv writes are handled directly; vercel/convex require pi.exec.
+ */
+async function applySecrets(
+	provided: Array<{ key: string; value: string }>,
+	destination: "dotenv" | "vercel" | "convex",
+	opts: {
+		envFilePath: string;
+		environment?: string;
+		exec?: (cmd: string, args: string[]) => Promise<{ code: number; stderr: string }>;
+	},
+): Promise<{ applied: string[]; errors: string[] }> {
+	const applied: string[] = [];
+	const errors: string[] = [];
+
+	if (destination === "dotenv") {
+		for (const { key, value } of provided) {
+			try {
+				await writeEnvKey(opts.envFilePath, key, value);
+				applied.push(key);
+			} catch (err: any) {
+				errors.push(`${key}: ${err.message}`);
+			}
+		}
+	}
+
+	if (destination === "vercel" && opts.exec) {
+		const env = opts.environment ?? "development";
+		for (const { key, value } of provided) {
+			try {
+				const result = await opts.exec("sh", [
+					"-c",
+					`printf %s ${shellEscapeSingle(value)} | vercel env add ${key} ${env}`,
+				]);
+				if (result.code !== 0) {
+					errors.push(`${key}: ${result.stderr.slice(0, 200)}`);
+				} else {
+					applied.push(key);
+				}
+			} catch (err: any) {
+				errors.push(`${key}: ${err.message}`);
+			}
+		}
+	}
+
+	if (destination === "convex" && opts.exec) {
+		for (const { key, value } of provided) {
+			try {
+				const result = await opts.exec("sh", [
+					"-c",
+					`npx convex env set ${key} ${shellEscapeSingle(value)}`,
+				]);
+				if (result.code !== 0) {
+					errors.push(`${key}: ${result.stderr.slice(0, 200)}`);
+				} else {
+					applied.push(key);
+				}
+			} catch (err: any) {
+				errors.push(`${key}: ${err.message}`);
+			}
+		}
+	}
+
+	return { applied, errors };
+}
+
+// ─── Manifest Orchestrator ────────────────────────────────────────────────────
+
+/**
+ * Full orchestrator: reads manifest, checks env, shows summary, collects
+ * only pending keys (with guidance + hint), updates manifest statuses,
+ * writes back, and applies collected values to the destination.
+ *
+ * Returns a structured result matching the tool result shape.
+ */
+export async function collectSecretsFromManifest(
+	base: string,
+	milestoneId: string,
+	ctx: { ui: any; hasUI: boolean; cwd: string },
+): Promise<{ applied: string[]; skipped: string[]; existingSkipped: string[] }> {
+	// (a) Resolve manifest path
+	const manifestPath = resolveMilestoneFile(base, milestoneId, "SECRETS");
+	if (!manifestPath) {
+		throw new Error(`Secrets manifest not found for milestone ${milestoneId} in ${base}`);
+	}
+
+	// (b) Read and parse manifest
+	const content = await readFile(manifestPath, "utf8");
+	const manifest = parseSecretsManifest(content);
+
+	// (c) Check existing keys
+	const envPath = resolve(base, ".env");
+	const allKeys = manifest.entries.map((e) => e.key);
+	const existingKeys = await checkExistingEnvKeys(allKeys, envPath);
+	const existingSet = new Set(existingKeys);
+
+	// (d) Build categorization
+	const existingSkipped: string[] = [];
+	const alreadySkipped: string[] = [];
+	const pendingEntries: SecretsManifestEntry[] = [];
+
+	for (const entry of manifest.entries) {
+		if (existingSet.has(entry.key)) {
+			existingSkipped.push(entry.key);
+		} else if (entry.status === "skipped") {
+			alreadySkipped.push(entry.key);
+		} else if (entry.status === "pending") {
+			pendingEntries.push(entry);
+		}
+		// collected entries that are not in env are left as-is
+	}
+
+	// (e) Show summary screen
+	await showSecretsSummary(ctx, manifest.entries, existingKeys);
+
+	// (f) Detect destination
+	const destination = detectDestination(ctx.cwd);
+
+	// (g) Collect only pending keys that are not already existing
+	const collected: CollectedSecret[] = [];
+	for (let i = 0; i < pendingEntries.length; i++) {
+		const entry = pendingEntries[i] as SecretsManifestEntry;
+		const value = await collectOneSecret(
+			ctx,
+			i,
+			pendingEntries.length,
+			entry.key,
+			entry.formatHint || undefined,
+			entry.guidance.length > 0 ? entry.guidance : undefined,
+		);
+		collected.push({ key: entry.key, value });
+	}
+
+	// (h) Update manifest entry statuses
+	for (const { key, value } of collected) {
+		const entry = manifest.entries.find((e) => e.key === key);
+		if (entry) {
+			entry.status = value !== null ? "collected" : "skipped";
+		}
+	}
+
+	// (i) Write manifest back to disk
+	await writeFile(manifestPath, formatSecretsManifest(manifest), "utf8");
+
+	// (j) Apply collected values to destination
+	const provided = collected.filter((c) => c.value !== null) as Array<{ key: string; value: string }>;
+	const { applied } = await applySecrets(provided, destination, {
+		envFilePath: resolve(ctx.cwd, ".env"),
+	});
+
+	const skipped = [
+		...alreadySkipped,
+		...collected.filter((c) => c.value === null).map((c) => c.key),
+	];
+
+	return { applied, skipped, existingSkipped };
+}
+
 // ─── Extension ────────────────────────────────────────────────────────────────
 
 export default function secureEnv(pi: ExtensionAPI) {
@@ -209,16 +520,17 @@ export default function secureEnv(pi: ExtensionAPI) {
 			"Never echo, log, or repeat secret values in your responses. Only report key names and applied/skipped status.",
 		],
 		parameters: Type.Object({
-			destination: Type.Union([
+			destination: Type.Optional(Type.Union([
 				Type.Literal("dotenv"),
 				Type.Literal("vercel"),
 				Type.Literal("convex"),
-			], { description: "Where to write the collected secrets" }),
+			], { description: "Where to write the collected secrets" })),
 			keys: Type.Array(
 				Type.Object({
 					key: Type.String({ description: "Env var name, e.g. OPENAI_API_KEY" }),
 					hint: Type.Optional(Type.String({ description: "Format hint shown to user, e.g. 'starts with sk-'" })),
 					required: Type.Optional(Type.Boolean()),
+					guidance: Type.Optional(Type.Array(Type.String(), { description: "Step-by-step guidance for finding this key" })),
 				}),
 				{ minItems: 1 },
 			),
@@ -240,79 +552,39 @@ export default function secureEnv(pi: ExtensionAPI) {
 				};
 			}
 
+			// Auto-detect destination when not provided
+			const destinationAutoDetected = params.destination == null;
+			const destination = params.destination ?? detectDestination(ctx.cwd);
+
 			const collected: CollectedSecret[] = [];
 
 			// Collect one key per page
 			for (let i = 0; i < params.keys.length; i++) {
 				const item = params.keys[i];
-				const value = await collectOneSecret(ctx, i, params.keys.length, item.key, item.hint);
+				const value = await collectOneSecret(ctx, i, params.keys.length, item.key, item.hint, item.guidance);
 				collected.push({ key: item.key, value });
 			}
 
 			const provided = collected.filter((c) => c.value !== null) as Array<{ key: string; value: string }>;
 			const skipped = collected.filter((c) => c.value === null).map((c) => c.key);
-			const applied: string[] = [];
-			const errors: string[] = [];
-
-			// Apply to destination
-			if (params.destination === "dotenv") {
-				const filePath = resolve(ctx.cwd, params.envFilePath ?? ".env");
-				for (const { key, value } of provided) {
-					try {
-						await writeEnvKey(filePath, key, value);
-						applied.push(key);
-					} catch (err: any) {
-						errors.push(`${key}: ${err.message}`);
-					}
-				}
-			}
 
-			if (params.destination === "vercel") {
-				const env = params.environment ?? "development";
-				for (const { key, value } of provided) {
-					try {
-						const result = await pi.exec("sh", [
-							"-c",
-							`printf %s ${shellEscapeSingle(value)} | vercel env add ${key} ${env}`,
-						]);
-						if (result.code !== 0) {
-							errors.push(`${key}: ${result.stderr.slice(0, 200)}`);
-						} else {
-							applied.push(key);
-						}
-					} catch (err: any) {
-						errors.push(`${key}: ${err.message}`);
-					}
-				}
-			}
-
-			if (params.destination === "convex") {
-				for (const { key, value } of provided) {
-					try {
-						const result = await pi.exec("sh", [
-							"-c",
-							`npx convex env set ${key} ${shellEscapeSingle(value)}`,
-						]);
-						if (result.code !== 0) {
-							errors.push(`${key}: ${result.stderr.slice(0, 200)}`);
-						} else {
-							applied.push(key);
-						}
-					} catch (err: any) {
-						errors.push(`${key}: ${err.message}`);
-					}
-				}
-			}
+			// Apply to destination via shared helper
+			const { applied, errors } = await applySecrets(provided, destination, {
+				envFilePath: resolve(ctx.cwd, params.envFilePath ?? ".env"),
+				environment: params.environment,
+				exec: (cmd, args) => pi.exec(cmd, args),
+			});
 
 			const details: ToolResultDetails = {
-				destination: params.destination,
+				destination,
 				environment: params.environment,
 				applied,
 				skipped,
+				...(destinationAutoDetected ? { detectedDestination: destination } : {}),
 			};
 
 			const lines = [
-				`destination: ${params.destination}${params.environment ? ` (${params.environment})` : ""}`,
+				`destination: ${destination}${destinationAutoDetected ? " (auto-detected)" : ""}${params.environment ? ` (${params.environment})` : ""}`,
 				...applied.map((k) => `✓ ${k}: applied`),
 				...skipped.map((k) => `• ${k}: skipped`),
 				...errors.map((e) => `✗ ${e}`),
@@ -329,7 +601,7 @@ export default function secureEnv(pi: ExtensionAPI) {
 			const count = Array.isArray(args.keys) ? args.keys.length : 0;
 			return new Text(
 				theme.fg("toolTitle", theme.bold("secure_env_collect ")) +
-				theme.fg("muted", `→ ${args.destination}`) +
+				theme.fg("muted", `→ ${args.destination ?? "auto"}`) +
 				theme.fg("dim", `  ${count} key${count !== 1 ? "s" : ""}`),
 				0, 0,
 			);