gsd-pi 2.43.0-next.8 → 2.44.0-dev.62b5d6c

package/packages/pi-coding-agent/src/core/package-commands.ts

@@ -0,0 +1,310 @@
+import chalk from "chalk";
+import { DefaultPackageManager } from "./package-manager.js";
+import { prepareLifecycleHooks, runLifecycleHooks } from "./lifecycle-hooks.js";
+import { SettingsManager } from "./settings-manager.js";
+
+export type PackageCommand = "install" | "remove" | "update" | "list";
+
+export interface PackageCommandOptions {
+	command: PackageCommand;
+	source?: string;
+	local: boolean;
+	help: boolean;
+	invalidOption?: string;
+}
+
+export interface PackageCommandRunnerOptions {
+	appName: string;
+	args: string[];
+	cwd: string;
+	agentDir: string;
+	stdout?: NodeJS.WriteStream;
+	stderr?: NodeJS.WriteStream;
+	allowedCommands?: ReadonlySet<PackageCommand>;
+}
+
+export interface PackageCommandRunnerResult {
+	handled: boolean;
+	exitCode: number;
+}
+
+function reportSettingsErrors(settingsManager: SettingsManager, context: string, stderr: NodeJS.WriteStream): void {
+	const errors = settingsManager.drainErrors();
+	for (const { scope, error } of errors) {
+		stderr.write(chalk.yellow(`Warning (${context}, ${scope} settings): ${error.message}`) + "\n");
+		if (error.stack) {
+			stderr.write(chalk.dim(error.stack) + "\n");
+		}
+	}
+}
+
+export function getPackageCommandUsage(appName: string, command: PackageCommand): string {
+	switch (command) {
+		case "install":
+			return `${appName} install <source> [-l]`;
+		case "remove":
+			return `${appName} remove <source> [-l]`;
+		case "update":
+			return `${appName} update [source]`;
+		case "list":
+			return `${appName} list`;
+	}
+}
+
+function printPackageCommandHelp(
+	appName: string,
+	command: PackageCommand,
+	stdout: NodeJS.WriteStream,
+): void {
+	switch (command) {
+		case "install":
+			stdout.write(`${chalk.bold("Usage:")}
+  ${getPackageCommandUsage(appName, "install")}
+
+Install a package, add it to settings, and run lifecycle hooks.
+
+Options:
+  -l, --local    Install project-locally (.pi/settings.json)
+
+Examples:
+  ${appName} install npm:@foo/bar
+  ${appName} install git:github.com/user/repo
+  ${appName} install git:git@github.com:user/repo
+  ${appName} install https://github.com/user/repo
+  ${appName} install ssh://git@github.com/user/repo
+  ${appName} install ./local/path
+`);
+			return;
+		case "remove":
+			stdout.write(`${chalk.bold("Usage:")}
+  ${getPackageCommandUsage(appName, "remove")}
+
+Remove a package and its source from settings.
+
+Options:
+  -l, --local    Remove from project settings (.pi/settings.json)
+
+Example:
+  ${appName} remove npm:@foo/bar
+`);
+			return;
+		case "update":
+			stdout.write(`${chalk.bold("Usage:")}
+  ${getPackageCommandUsage(appName, "update")}
+
+Update installed packages.
+If <source> is provided, only that package is updated.
+`);
+			return;
+		case "list":
+			stdout.write(`${chalk.bold("Usage:")}
+  ${getPackageCommandUsage(appName, "list")}
+
+List installed packages from user and project settings.
+`);
+			return;
+	}
+}
+
+export function parsePackageCommand(
+	args: string[],
+	allowedCommands?: ReadonlySet<PackageCommand>,
+): PackageCommandOptions | undefined {
+	const [command, ...rest] = args;
+	if (command !== "install" && command !== "remove" && command !== "update" && command !== "list") {
+		return undefined;
+	}
+	if (allowedCommands && !allowedCommands.has(command)) {
+		return undefined;
+	}
+
+	let local = false;
+	let help = false;
+	let invalidOption: string | undefined;
+	let source: string | undefined;
+
+	for (const arg of rest) {
+		if (arg === "-h" || arg === "--help") {
+			help = true;
+			continue;
+		}
+		if (arg === "-l" || arg === "--local") {
+			if (command === "install" || command === "remove") {
+				local = true;
+			} else {
+				invalidOption = invalidOption ?? arg;
+			}
+			continue;
+		}
+		if (arg.startsWith("-")) {
+			invalidOption = invalidOption ?? arg;
+			continue;
+		}
+		if (!source) {
+			source = arg;
+		}
+	}
+
+	return { command, source, local, help, invalidOption };
+}
+
+export async function runPackageCommand(
+	options: PackageCommandRunnerOptions,
+): Promise<PackageCommandRunnerResult> {
+	const stdout = options.stdout ?? process.stdout;
+	const stderr = options.stderr ?? process.stderr;
+	const parsed = parsePackageCommand(options.args, options.allowedCommands);
+	if (!parsed) {
+		return { handled: false, exitCode: 0 };
+	}
+
+	if (parsed.help) {
+		printPackageCommandHelp(options.appName, parsed.command, stdout);
+		return { handled: true, exitCode: 0 };
+	}
+
+	if (parsed.invalidOption) {
+		stderr.write(chalk.red(`Unknown option ${parsed.invalidOption} for "${parsed.command}".`) + "\n");
+		stderr.write(chalk.dim(`Use "${options.appName} --help" or "${getPackageCommandUsage(options.appName, parsed.command)}".`) + "\n");
+		return { handled: true, exitCode: 1 };
+	}
+
+	const source = parsed.source;
+	if ((parsed.command === "install" || parsed.command === "remove") && !source) {
+		stderr.write(chalk.red(`Missing ${parsed.command} source.`) + "\n");
+		stderr.write(chalk.dim(`Usage: ${getPackageCommandUsage(options.appName, parsed.command)}`) + "\n");
+		return { handled: true, exitCode: 1 };
+	}
+
+	const settingsManager = SettingsManager.create(options.cwd, options.agentDir);
+	reportSettingsErrors(settingsManager, "package command", stderr);
+	const packageManager = new DefaultPackageManager({
+		cwd: options.cwd,
+		agentDir: options.agentDir,
+		settingsManager,
+	});
+	packageManager.setProgressCallback((event) => {
+		if (event.type === "start" && event.message) {
+			stdout.write(chalk.dim(`${event.message}\n`));
+		}
+	});
+
+	try {
+		switch (parsed.command) {
+			case "install": {
+				const lifecycleOptions = {
+					source: source!,
+					local: parsed.local,
+					cwd: options.cwd,
+					agentDir: options.agentDir,
+					appName: options.appName,
+					packageManager,
+					stdout,
+					stderr,
+				};
+
+				const beforeInstallHooks = await prepareLifecycleHooks(lifecycleOptions, "source");
+				const beforeInstallResult = await runLifecycleHooks(beforeInstallHooks, "beforeInstall");
+
+				await packageManager.install(source!, { local: parsed.local });
+				packageManager.addSourceToSettings(source!, { local: parsed.local });
+
+				const afterInstallHooks = await prepareLifecycleHooks(lifecycleOptions, "installed", {
+					verifyRuntimeDependencies: true,
+				});
+				const afterInstallResult = await runLifecycleHooks(afterInstallHooks, "afterInstall");
+
+				const hookErrors = beforeInstallResult.hookErrors + afterInstallResult.hookErrors;
+				if (hookErrors > 0) {
+					stderr.write(chalk.yellow(`Lifecycle hooks completed with ${hookErrors} hook error(s).`) + "\n");
+				}
+				stdout.write(chalk.green(`Installed ${source}`) + "\n");
+				return { handled: true, exitCode: 0 };
+			}
+
+			case "remove": {
+				const lifecycleOptions = {
+					source: source!,
+					local: parsed.local,
+					cwd: options.cwd,
+					agentDir: options.agentDir,
+					appName: options.appName,
+					packageManager,
+					stdout,
+					stderr,
+				};
+				const removeHooks = await prepareLifecycleHooks(lifecycleOptions, "installed");
+				const beforeRemoveResult = await runLifecycleHooks(removeHooks, "beforeRemove");
+
+				await packageManager.remove(source!, { local: parsed.local });
+				const removed = packageManager.removeSourceFromSettings(source!, { local: parsed.local });
+
+				const afterRemoveResult = await runLifecycleHooks(removeHooks, "afterRemove");
+				const hookErrors = beforeRemoveResult.hookErrors + afterRemoveResult.hookErrors;
+				if (hookErrors > 0) {
+					stderr.write(chalk.yellow(`Lifecycle hooks completed with ${hookErrors} hook error(s).`) + "\n");
+				}
+
+				if (!removed) {
+					stderr.write(chalk.red(`No matching package found for ${source}`) + "\n");
+					return { handled: true, exitCode: 1 };
+				}
+				stdout.write(chalk.green(`Removed ${source}`) + "\n");
+				return { handled: true, exitCode: 0 };
+			}
+
+			case "list": {
+				const globalSettings = settingsManager.getGlobalSettings();
+				const projectSettings = settingsManager.getProjectSettings();
+				const globalPackages = globalSettings.packages ?? [];
+				const projectPackages = projectSettings.packages ?? [];
+
+				if (globalPackages.length === 0 && projectPackages.length === 0) {
+					stdout.write(chalk.dim("No packages installed.") + "\n");
+					return { handled: true, exitCode: 0 };
+				}
+
+				const formatPackage = (pkg: (typeof globalPackages)[number], scope: "user" | "project") => {
+					const pkgSource = typeof pkg === "string" ? pkg : pkg.source;
+					const filtered = typeof pkg === "object";
+					const display = filtered ? `${pkgSource} (filtered)` : pkgSource;
+					stdout.write(`  ${display}\n`);
+					const path = packageManager.getInstalledPath(pkgSource, scope);
+					if (path) {
+						stdout.write(chalk.dim(`    ${path}`) + "\n");
+					}
+				};
+
+				if (globalPackages.length > 0) {
+					stdout.write(chalk.bold("User packages:") + "\n");
+					for (const pkg of globalPackages) {
+						formatPackage(pkg, "user");
+					}
+				}
+
+				if (projectPackages.length > 0) {
+					if (globalPackages.length > 0) stdout.write("\n");
+					stdout.write(chalk.bold("Project packages:") + "\n");
+					for (const pkg of projectPackages) {
+						formatPackage(pkg, "project");
+					}
+				}
+
+				return { handled: true, exitCode: 0 };
+			}
+
+			case "update":
+				await packageManager.update(source);
+				if (source) {
+					stdout.write(chalk.green(`Updated ${source}`) + "\n");
+				} else {
+					stdout.write(chalk.green("Updated packages") + "\n");
+				}
+				return { handled: true, exitCode: 0 };
+		}
+	} catch (error) {
+		const message = error instanceof Error ? error.message : "Unknown package command error";
+		stderr.write(chalk.red(`Error: ${message}`) + "\n");
+		return { handled: true, exitCode: 1 };
+	}
+}

package/packages/pi-coding-agent/src/core/sdk.ts

@@ -333,6 +333,10 @@ export async function createAgentSession(options: CreateAgentSessionOptions = {}
 			if (!resolvedProvider) {
 				throw new Error("No model selected");
 			}
+			const authMode = modelRegistry.getProviderAuthMode(resolvedProvider);
+			if (authMode === "externalCli" || authMode === "none") {
+				return undefined;
+			}
 
 			// Retry key resolution with backoff to handle transient network failures
 			// (e.g., OAuth token refresh failing due to brief connectivity loss).

package/packages/pi-coding-agent/src/index.ts

@@ -94,6 +94,11 @@ export type {
 	MessageRenderOptions,
 	ProviderConfig,
 	ProviderModelConfig,
+	LifecycleHookContext,
+	LifecycleHookHandler,
+	LifecycleHookMap,
+	LifecycleHookPhase,
+	LifecycleHookScope,
 	ReadToolCallEvent,
 	RegisteredCommand,
 	RegisteredTool,
@@ -152,6 +157,8 @@ export type {
 	ResolvedResource,
 } from "./core/package-manager.js";
 export { DefaultPackageManager } from "./core/package-manager.js";
+export type { PackageCommand, PackageCommandOptions, PackageCommandRunnerOptions, PackageCommandRunnerResult } from "./core/package-commands.js";
+export { getPackageCommandUsage, parsePackageCommand, runPackageCommand } from "./core/package-commands.js";
 export type { ResourceCollision, ResourceDiagnostic, ResourceLoader } from "./core/resource-loader.js";
 export { DefaultResourceLoader } from "./core/resource-loader.js";
 // SDK for programmatic usage

package/packages/pi-coding-agent/src/main.ts

@@ -20,6 +20,7 @@ import type { LoadExtensionsResult } from "./core/extensions/index.js";
 import { KeybindingsManager } from "./core/keybindings.js";
 import { ModelRegistry } from "./core/model-registry.js";
 import { resolveCliModel, resolveModelScope, type ScopedModel } from "./core/model-resolver.js";
+import { runPackageCommand } from "./core/package-commands.js";
 import { DefaultPackageManager } from "./core/package-manager.js";
 import { DefaultResourceLoader } from "./core/resource-loader.js";
 import { type CreateAgentSessionOptions, createAgentSession } from "./core/sdk.js";
@@ -69,237 +70,6 @@ function isTruthyEnvFlag(value: string | undefined): boolean {
 	return value === "1" || value.toLowerCase() === "true" || value.toLowerCase() === "yes";
 }
 
-type PackageCommand = "install" | "remove" | "update" | "list";
-
-interface PackageCommandOptions {
-	command: PackageCommand;
-	source?: string;
-	local: boolean;
-	help: boolean;
-	invalidOption?: string;
-}
-
-function getPackageCommandUsage(command: PackageCommand): string {
-	switch (command) {
-		case "install":
-			return `${APP_NAME} install <source> [-l]`;
-		case "remove":
-			return `${APP_NAME} remove <source> [-l]`;
-		case "update":
-			return `${APP_NAME} update [source]`;
-		case "list":
-			return `${APP_NAME} list`;
-	}
-}
-
-function printPackageCommandHelp(command: PackageCommand): void {
-	switch (command) {
-		case "install":
-			console.log(`${chalk.bold("Usage:")}
-  ${getPackageCommandUsage("install")}
-
-Install a package and add it to settings.
-
-Options:
-  -l, --local    Install project-locally (.pi/settings.json)
-
-Examples:
-  ${APP_NAME} install npm:@foo/bar
-  ${APP_NAME} install git:github.com/user/repo
-  ${APP_NAME} install git:git@github.com:user/repo
-  ${APP_NAME} install https://github.com/user/repo
-  ${APP_NAME} install ssh://git@github.com/user/repo
-  ${APP_NAME} install ./local/path
-`);
-			return;
-
-		case "remove":
-			console.log(`${chalk.bold("Usage:")}
-  ${getPackageCommandUsage("remove")}
-
-Remove a package and its source from settings.
-
-Options:
-  -l, --local    Remove from project settings (.pi/settings.json)
-
-Example:
-  ${APP_NAME} remove npm:@foo/bar
-`);
-			return;
-
-		case "update":
-			console.log(`${chalk.bold("Usage:")}
-  ${getPackageCommandUsage("update")}
-
-Update installed packages.
-If <source> is provided, only that package is updated.
-`);
-			return;
-
-		case "list":
-			console.log(`${chalk.bold("Usage:")}
-  ${getPackageCommandUsage("list")}
-
-List installed packages from user and project settings.
-`);
-			return;
-	}
-}
-
-function parsePackageCommand(args: string[]): PackageCommandOptions | undefined {
-	const [command, ...rest] = args;
-	if (command !== "install" && command !== "remove" && command !== "update" && command !== "list") {
-		return undefined;
-	}
-
-	let local = false;
-	let help = false;
-	let invalidOption: string | undefined;
-	let source: string | undefined;
-
-	for (const arg of rest) {
-		if (arg === "-h" || arg === "--help") {
-			help = true;
-			continue;
-		}
-
-		if (arg === "-l" || arg === "--local") {
-			if (command === "install" || command === "remove") {
-				local = true;
-			} else {
-				invalidOption = invalidOption ?? arg;
-			}
-			continue;
-		}
-
-		if (arg.startsWith("-")) {
-			invalidOption = invalidOption ?? arg;
-			continue;
-		}
-
-		if (!source) {
-			source = arg;
-		}
-	}
-
-	return { command, source, local, help, invalidOption };
-}
-
-async function handlePackageCommand(args: string[]): Promise<boolean> {
-	const options = parsePackageCommand(args);
-	if (!options) {
-		return false;
-	}
-
-	if (options.help) {
-		printPackageCommandHelp(options.command);
-		return true;
-	}
-
-	if (options.invalidOption) {
-		console.error(chalk.red(`Unknown option ${options.invalidOption} for "${options.command}".`));
-		console.error(chalk.dim(`Use "${APP_NAME} --help" or "${getPackageCommandUsage(options.command)}".`));
-		process.exitCode = 1;
-		return true;
-	}
-
-	const source = options.source;
-	if ((options.command === "install" || options.command === "remove") && !source) {
-		console.error(chalk.red(`Missing ${options.command} source.`));
-		console.error(chalk.dim(`Usage: ${getPackageCommandUsage(options.command)}`));
-		process.exitCode = 1;
-		return true;
-	}
-
-	const cwd = process.cwd();
-	const agentDir = getAgentDir();
-	const settingsManager = SettingsManager.create(cwd, agentDir);
-	reportSettingsErrors(settingsManager, "package command");
-	const packageManager = new DefaultPackageManager({ cwd, agentDir, settingsManager });
-
-	packageManager.setProgressCallback((event) => {
-		if (event.type === "start") {
-			process.stdout.write(chalk.dim(`${event.message}\n`));
-		}
-	});
-
-	try {
-		switch (options.command) {
-			case "install":
-				await packageManager.install(source!, { local: options.local });
-				packageManager.addSourceToSettings(source!, { local: options.local });
-				console.log(chalk.green(`Installed ${source}`));
-				return true;
-
-			case "remove": {
-				await packageManager.remove(source!, { local: options.local });
-				const removed = packageManager.removeSourceFromSettings(source!, { local: options.local });
-				if (!removed) {
-					console.error(chalk.red(`No matching package found for ${source}`));
-					process.exitCode = 1;
-					return true;
-				}
-				console.log(chalk.green(`Removed ${source}`));
-				return true;
-			}
-
-			case "list": {
-				const globalSettings = settingsManager.getGlobalSettings();
-				const projectSettings = settingsManager.getProjectSettings();
-				const globalPackages = globalSettings.packages ?? [];
-				const projectPackages = projectSettings.packages ?? [];
-
-				if (globalPackages.length === 0 && projectPackages.length === 0) {
-					console.log(chalk.dim("No packages installed."));
-					return true;
-				}
-
-				const formatPackage = (pkg: (typeof globalPackages)[number], scope: "user" | "project") => {
-					const source = typeof pkg === "string" ? pkg : pkg.source;
-					const filtered = typeof pkg === "object";
-					const display = filtered ? `${source} (filtered)` : source;
-					console.log(`  ${display}`);
-					const path = packageManager.getInstalledPath(source, scope);
-					if (path) {
-						console.log(chalk.dim(`    ${path}`));
-					}
-				};
-
-				if (globalPackages.length > 0) {
-					console.log(chalk.bold("User packages:"));
-					for (const pkg of globalPackages) {
-						formatPackage(pkg, "user");
-					}
-				}
-
-				if (projectPackages.length > 0) {
-					if (globalPackages.length > 0) console.log();
-					console.log(chalk.bold("Project packages:"));
-					for (const pkg of projectPackages) {
-						formatPackage(pkg, "project");
-					}
-				}
-
-				return true;
-			}
-
-			case "update":
-				await packageManager.update(source);
-				if (source) {
-					console.log(chalk.green(`Updated ${source}`));
-				} else {
-					console.log(chalk.green("Updated packages"));
-				}
-				return true;
-		}
-	} catch (error: unknown) {
-		const message = error instanceof Error ? error.message : "Unknown package command error";
-		console.error(chalk.red(`Error: ${message}`));
-		process.exitCode = 1;
-		return true;
-	}
-}
-
 async function prepareInitialMessage(
 	parsed: Args,
 	autoResizeImages: boolean,
@@ -590,7 +360,16 @@ export async function main(args: string[]) {
 		process.env.PI_SKIP_VERSION_CHECK = "1";
 	}
 
-	if (await handlePackageCommand(args)) {
+	const packageCommand = await runPackageCommand({
+		appName: APP_NAME,
+		args,
+		cwd: process.cwd(),
+		agentDir: getAgentDir(),
+		stdout: process.stdout,
+		stderr: process.stderr,
+	});
+	if (packageCommand.handled) {
+		process.exitCode = packageCommand.exitCode;
 		return;
 	}
 

package/pkg/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@glittercowboy/gsd",
-  "version": "2.43.0",
+  "version": "2.44.0",
   "piConfig": {
     "name": "gsd",
     "configDir": ".gsd"

package/src/resources/extensions/gsd/auto-direct-dispatch.ts

@@ -11,6 +11,7 @@ import type {
 import { deriveState } from "./state.js";
 import { loadFile } from "./files.js";
 import { isDbAvailable, getMilestoneSlices } from "./gsd-db.js";
+import { parseRoadmap } from "./parsers-legacy.js";
 import {
   resolveMilestoneFile, resolveSliceFile, relSliceFile,
 } from "./paths.js";
@@ -152,13 +153,20 @@ export async function dispatchDirectPhase(
 
     case "reassess":
     case "reassess-roadmap": {
-      // DB primary path — get completed slices
+      // DB primary path — get completed slices, fall back to file parsing when DB has no data
       let completedSliceIds: string[] = [];
       if (isDbAvailable()) {
         completedSliceIds = getMilestoneSlices(mid).filter(s => s.status === "complete").map(s => s.id);
-      } else {
-        ctx.ui.notify("Cannot dispatch reassess-roadmap: DB unavailable.", "warning");
-        return;
+      }
+      if (completedSliceIds.length === 0) {
+        // File-based fallback: parse roadmap checkboxes
+        const roadmapPath = resolveMilestoneFile(base, mid, "ROADMAP");
+        if (roadmapPath) {
+          const roadmapContent = await loadFile(roadmapPath);
+          if (roadmapContent) {
+            completedSliceIds = parseRoadmap(roadmapContent).slices.filter(s => s.done).map(s => s.id);
+          }
+        }
       }
       if (completedSliceIds.length === 0) {
         ctx.ui.notify("Cannot dispatch reassess-roadmap: no completed slices.", "warning");
@@ -180,9 +188,16 @@ export async function dispatchDirectPhase(
       let uatCompletedSliceIds: string[] = [];
       if (isDbAvailable()) {
         uatCompletedSliceIds = getMilestoneSlices(mid).filter(s => s.status === "complete").map(s => s.id);
-      } else {
-        ctx.ui.notify("Cannot dispatch run-uat: DB unavailable.", "warning");
-        return;
+      }
+      if (uatCompletedSliceIds.length === 0) {
+        // File-based fallback: parse roadmap checkboxes
+        const roadmapPath = resolveMilestoneFile(base, mid, "ROADMAP");
+        if (roadmapPath) {
+          const roadmapContent = await loadFile(roadmapPath);
+          if (roadmapContent) {
+            uatCompletedSliceIds = parseRoadmap(roadmapContent).slices.filter(s => s.done).map(s => s.id);
+          }
+        }
       }
       if (uatCompletedSliceIds.length === 0) {
         ctx.ui.notify("Cannot dispatch run-uat: no completed slices.", "warning");