@tuan_son.dinh/gsd 2.6.0

package/dist/cli.js

@@ -0,0 +1,269 @@
+import { AuthStorage, DefaultResourceLoader, ModelRegistry, SettingsManager, SessionManager, createAgentSession, InteractiveMode, runPrintMode, runRpcMode, } from '@mariozechner/pi-coding-agent';
+import { existsSync, readdirSync, renameSync, readFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { agentDir, sessionsDir, authFilePath } from './app-paths.js';
+import { initResources, buildResourceLoader } from './resource-loader.js';
+import { ensureManagedTools } from './tool-bootstrap.js';
+import { loadStoredEnvKeys } from './wizard.js';
+import { migratePiCredentials } from './pi-migration.js';
+import { shouldRunOnboarding, runOnboarding } from './onboarding.js';
+function parseCliArgs(argv) {
+    const flags = { extensions: [], messages: [] };
+    const args = argv.slice(2); // skip node + script
+    for (let i = 0; i < args.length; i++) {
+        const arg = args[i];
+        if (arg === '--mode' && i + 1 < args.length) {
+            const m = args[++i];
+            if (m === 'text' || m === 'json' || m === 'rpc')
+                flags.mode = m;
+        }
+        else if (arg === '--print' || arg === '-p') {
+            flags.print = true;
+        }
+        else if (arg === '--no-session') {
+            flags.noSession = true;
+        }
+        else if (arg === '--model' && i + 1 < args.length) {
+            flags.model = args[++i];
+        }
+        else if (arg === '--extension' && i + 1 < args.length) {
+            flags.extensions.push(args[++i]);
+        }
+        else if (arg === '--append-system-prompt' && i + 1 < args.length) {
+            flags.appendSystemPrompt = args[++i];
+        }
+        else if (arg === '--tools' && i + 1 < args.length) {
+            flags.tools = args[++i].split(',');
+        }
+        else if (arg === '--version' || arg === '-v') {
+            process.stdout.write((process.env.GSD_VERSION || '0.0.0') + '\n');
+            process.exit(0);
+        }
+        else if (arg === '--help' || arg === '-h') {
+            process.stdout.write(`GSD v${process.env.GSD_VERSION || '0.0.0'} — Get Shit Done\n\n`);
+            process.stdout.write('Usage: gsd [options] [message...]\n\n');
+            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('  --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');
+            process.stdout.write('  --tools <a,b,c>          Restrict available tools\n');
+            process.stdout.write('  --version, -v            Print version and exit\n');
+            process.stdout.write('  --help, -h               Print this help and exit\n');
+            process.stdout.write('\nSubcommands:\n');
+            process.stdout.write('  config                   Re-run the setup wizard\n');
+            process.exit(0);
+        }
+        else if (!arg.startsWith('--') && !arg.startsWith('-')) {
+            flags.messages.push(arg);
+        }
+    }
+    return flags;
+}
+const cliFlags = parseCliArgs(process.argv);
+const isPrintMode = cliFlags.print || cliFlags.mode !== undefined;
+// `gsd config` — replay the setup wizard and exit
+if (cliFlags.messages[0] === 'config') {
+    const authStorage = AuthStorage.create(authFilePath);
+    await runOnboarding(authStorage);
+    process.exit(0);
+}
+// Pi's tool bootstrap can mis-detect already-installed fd/rg on some systems
+// because spawnSync(..., ["--version"]) returns EPERM despite a zero exit code.
+// Provision local managed binaries first so Pi sees them without probing PATH.
+ensureManagedTools(join(agentDir, 'bin'));
+const authStorage = AuthStorage.create(authFilePath);
+loadStoredEnvKeys(authStorage);
+migratePiCredentials(authStorage);
+// Run onboarding wizard on first launch (no LLM provider configured)
+if (!isPrintMode && shouldRunOnboarding(authStorage)) {
+    await runOnboarding(authStorage);
+}
+const modelRegistry = new ModelRegistry(authStorage);
+const settingsManager = SettingsManager.create(agentDir);
+// Validate configured model on startup — catches stale settings from prior installs
+// (e.g. grok-2 which no longer exists) and fresh installs with no settings.
+// Only resets the default when the configured model no longer exists in the registry;
+// never overwrites a valid user choice.
+const configuredProvider = settingsManager.getDefaultProvider();
+const configuredModel = settingsManager.getDefaultModel();
+const allModels = modelRegistry.getAll();
+const configuredExists = configuredProvider && configuredModel &&
+    allModels.some((m) => m.provider === configuredProvider && m.id === configuredModel);
+if (!configuredModel || !configuredExists) {
+    // Fallback: pick the best available Anthropic model
+    const preferred = allModels.find((m) => m.provider === 'anthropic' && m.id === 'claude-opus-4-6') ||
+        allModels.find((m) => m.provider === 'anthropic' && m.id.includes('opus')) ||
+        allModels.find((m) => m.provider === 'anthropic');
+    if (preferred) {
+        settingsManager.setDefaultModelAndProvider(preferred.provider, preferred.id);
+    }
+}
+// Default thinking level: off (always reset if not explicitly set)
+if (settingsManager.getDefaultThinkingLevel() !== 'off' && !configuredExists) {
+    settingsManager.setDefaultThinkingLevel('off');
+}
+// GSD always uses quiet startup — the gsd extension renders its own branded header
+if (!settingsManager.getQuietStartup()) {
+    settingsManager.setQuietStartup(true);
+}
+// Collapse changelog by default — avoid wall of text on updates
+if (!settingsManager.getCollapseChangelog()) {
+    settingsManager.setCollapseChangelog(true);
+}
+// ---------------------------------------------------------------------------
+// Print / subagent mode — single-shot execution, no TTY required
+// ---------------------------------------------------------------------------
+if (isPrintMode) {
+    const sessionManager = cliFlags.noSession
+        ? SessionManager.inMemory()
+        : SessionManager.create(process.cwd());
+    // Read --append-system-prompt file content (subagent writes agent system prompts to temp files)
+    let appendSystemPrompt;
+    if (cliFlags.appendSystemPrompt) {
+        try {
+            appendSystemPrompt = readFileSync(cliFlags.appendSystemPrompt, 'utf-8');
+        }
+        catch {
+            // If it's not a file path, treat it as literal text
+            appendSystemPrompt = cliFlags.appendSystemPrompt;
+        }
+    }
+    initResources(agentDir);
+    const resourceLoader = new DefaultResourceLoader({
+        agentDir,
+        additionalExtensionPaths: cliFlags.extensions.length > 0 ? cliFlags.extensions : undefined,
+        appendSystemPrompt,
+    });
+    await resourceLoader.reload();
+    const { session, extensionsResult } = await createAgentSession({
+        authStorage,
+        modelRegistry,
+        settingsManager,
+        sessionManager,
+        resourceLoader,
+    });
+    if (extensionsResult.errors.length > 0) {
+        for (const err of extensionsResult.errors) {
+            process.stderr.write(`[gsd] Extension load error: ${err.error}\n`);
+        }
+    }
+    // Apply --model override if specified
+    if (cliFlags.model) {
+        const available = modelRegistry.getAvailable();
+        const match = available.find((m) => m.id === cliFlags.model) ||
+            available.find((m) => `${m.provider}/${m.id}` === cliFlags.model);
+        if (match) {
+            session.setModel(match);
+        }
+    }
+    const mode = cliFlags.mode || 'text';
+    if (mode === 'rpc') {
+        await runRpcMode(session);
+        process.exit(0);
+    }
+    await runPrintMode(session, {
+        mode,
+        messages: cliFlags.messages,
+    });
+    process.exit(0);
+}
+// ---------------------------------------------------------------------------
+// Interactive mode — normal TTY session
+// ---------------------------------------------------------------------------
+// Per-directory session storage — same encoding as the upstream SDK so that
+// /resume only shows sessions from the current working directory.
+const cwd = process.cwd();
+const safePath = `--${cwd.replace(/^[/\\]/, '').replace(/[/\\:]/g, '-')}--`;
+const projectSessionsDir = join(sessionsDir, safePath);
+// Migrate legacy flat sessions: before per-directory scoping, all .jsonl session
+// files lived directly in ~/.gsd/sessions/. Move them into the correct per-cwd
+// subdirectory so /resume can find them.
+if (existsSync(sessionsDir)) {
+    try {
+        const entries = readdirSync(sessionsDir);
+        const flatJsonl = entries.filter(f => f.endsWith('.jsonl'));
+        if (flatJsonl.length > 0) {
+            const { mkdirSync } = await import('node:fs');
+            mkdirSync(projectSessionsDir, { recursive: true });
+            for (const file of flatJsonl) {
+                const src = join(sessionsDir, file);
+                const dst = join(projectSessionsDir, file);
+                if (!existsSync(dst)) {
+                    renameSync(src, dst);
+                }
+            }
+        }
+    }
+    catch {
+        // Non-fatal — don't block startup if migration fails
+    }
+}
+const sessionManager = SessionManager.create(cwd, projectSessionsDir);
+initResources(agentDir);
+const resourceLoader = buildResourceLoader(agentDir);
+await resourceLoader.reload();
+const { session, extensionsResult } = await createAgentSession({
+    authStorage,
+    modelRegistry,
+    settingsManager,
+    sessionManager,
+    resourceLoader,
+});
+if (extensionsResult.errors.length > 0) {
+    for (const err of extensionsResult.errors) {
+        process.stderr.write(`[gsd] Extension load error: ${err.error}\n`);
+    }
+}
+// Restore scoped models from settings on startup.
+// The upstream InteractiveMode reads enabledModels from settings when /scoped-models is opened,
+// but doesn't apply them to the session at startup — so Ctrl+P cycles all models instead of
+// just the saved selection until the user re-runs /scoped-models.
+const enabledModelPatterns = settingsManager.getEnabledModels();
+if (enabledModelPatterns && enabledModelPatterns.length > 0) {
+    const availableModels = modelRegistry.getAvailable();
+    const scopedModels = [];
+    const seen = new Set();
+    for (const pattern of enabledModelPatterns) {
+        // Patterns are "provider/modelId" exact strings saved by /scoped-models
+        const slashIdx = pattern.indexOf('/');
+        if (slashIdx !== -1) {
+            const provider = pattern.substring(0, slashIdx);
+            const modelId = pattern.substring(slashIdx + 1);
+            const model = availableModels.find((m) => m.provider === provider && m.id === modelId);
+            if (model) {
+                const key = `${model.provider}/${model.id}`;
+                if (!seen.has(key)) {
+                    seen.add(key);
+                    scopedModels.push({ model });
+                }
+            }
+        }
+        else {
+            // Fallback: match by model id alone
+            const model = availableModels.find((m) => m.id === pattern);
+            if (model) {
+                const key = `${model.provider}/${model.id}`;
+                if (!seen.has(key)) {
+                    seen.add(key);
+                    scopedModels.push({ model });
+                }
+            }
+        }
+    }
+    // Only apply if we resolved some models and it's a genuine subset
+    if (scopedModels.length > 0 && scopedModels.length < availableModels.length) {
+        session.setScopedModels(scopedModels);
+    }
+}
+if (!process.stdin.isTTY) {
+    process.stderr.write('[gsd] Error: Interactive mode requires a terminal (TTY).\n');
+    process.stderr.write('[gsd] Non-interactive alternatives:\n');
+    process.stderr.write('[gsd]   gsd --print "your message"     Single-shot prompt\n');
+    process.stderr.write('[gsd]   gsd --mode rpc                 JSON-RPC over stdin/stdout\n');
+    process.stderr.write('[gsd]   gsd --mode text "message"      Text output mode\n');
+    process.exit(1);
+}
+const interactiveMode = new InteractiveMode(session);
+await interactiveMode.run();

package/dist/loader.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/loader.js

@@ -0,0 +1,70 @@
+#!/usr/bin/env node
+import { fileURLToPath } from 'url';
+import { dirname, resolve, join } from 'path';
+import { readFileSync } from 'fs';
+import { agentDir } from './app-paths.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:
+//   1. Read piConfig.name → "gsd" (branding)
+//   2. Resolve themes via dist/ (no src/ present → uses dist path)
+const pkgDir = resolve(dirname(fileURLToPath(import.meta.url)), '..', 'pkg');
+// MUST be set before any dynamic import of pi SDK fires — this is what config.js
+// reads to determine APP_NAME and CONFIG_DIR_NAME
+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)
+// 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.
+// Without this, extensions (e.g. browser-tools) can't resolve dependencies like
+// `playwright` because jiti resolves modules from pi-coding-agent's location, not gsd's.
+// Prepending gsd's node_modules to NODE_PATH fixes this for all extensions.
+const gsdRoot = resolve(dirname(fileURLToPath(import.meta.url)), '..');
+const gsdNodeModules = join(gsdRoot, 'node_modules');
+process.env.NODE_PATH = process.env.NODE_PATH
+    ? `${gsdNodeModules}:${process.env.NODE_PATH}`
+    : gsdNodeModules;
+// Force Node to re-evaluate module search paths with the updated NODE_PATH.
+// Must happen synchronously before cli.js imports → extension loading.
+// eslint-disable-next-line @typescript-eslint/no-require-imports
+const { Module } = await import('module');
+Module._initPaths?.();
+// GSD_VERSION — expose package version so extensions can display it
+try {
+    const gsdPkg = JSON.parse(readFileSync(join(gsdRoot, 'package.json'), 'utf-8'));
+    process.env.GSD_VERSION = gsdPkg.version || '0.0.0';
+}
+catch {
+    process.env.GSD_VERSION = '0.0.0';
+}
+// GSD_BIN_PATH — absolute path to this loader (dist/loader.js), used by patched subagent
+// to spawn gsd instead of pi when dispatching workflow tasks
+process.env.GSD_BIN_PATH = process.argv[1];
+// GSD_WORKFLOW_PATH — absolute path to bundled GSD-WORKFLOW.md, used by patched gsd extension
+// when dispatching workflow prompts (dist/loader.js → ../src/resources/GSD-WORKFLOW.md)
+const resourcesDir = resolve(dirname(fileURLToPath(import.meta.url)), '..', 'src', 'resources');
+process.env.GSD_WORKFLOW_PATH = join(resourcesDir, 'GSD-WORKFLOW.md');
+// GSD_BUNDLED_EXTENSION_PATHS — colon-joined list of all bundled extension entry point absolute
+// paths, used by patched subagent to pass --extension <path> to spawned gsd processes.
+// IMPORTANT: paths point to agentDir (~/.gsd/agent/extensions/) NOT src/resources/extensions/.
+// initResources() syncs bundled extensions to agentDir before any extension loading occurs,
+// so these paths are always valid at runtime. Using agentDir paths matches what buildResourceLoader
+// discovers (it scans agentDir), so pi's deduplication works correctly and extensions are not
+// double-loaded in subagent child processes.
+// Note: shared/ is NOT included — it's a library imported by gsd and ask-user-questions, not an entry point.
+process.env.GSD_BUNDLED_EXTENSION_PATHS = [
+    join(agentDir, 'extensions', 'gsd', 'index.ts'),
+    join(agentDir, 'extensions', 'bg-shell', 'index.ts'),
+    join(agentDir, 'extensions', 'browser-tools', 'index.ts'),
+    join(agentDir, 'extensions', 'context7', 'index.ts'),
+    join(agentDir, 'extensions', 'search-the-web', 'index.ts'),
+    join(agentDir, 'extensions', 'slash-commands', 'index.ts'),
+    join(agentDir, 'extensions', 'subagent', 'index.ts'),
+    join(agentDir, 'extensions', 'mac-tools', 'index.ts'),
+    join(agentDir, 'extensions', 'ask-user-questions.ts'),
+    join(agentDir, 'extensions', 'get-secrets-from-user.ts'),
+].join(':');
+// Dynamic import defers ESM evaluation — config.js will see PI_PACKAGE_DIR above
+await import('./cli.js');

package/dist/logo.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Shared GSD block-letter ASCII logo.
+ *
+ * Single source of truth — imported by:
+ *   - scripts/postinstall.js (via dist/logo.js)
+ *   - src/onboarding.ts (via ./logo.js)
+ */
+/** Raw logo lines — no ANSI codes, no leading newline. */
+export declare const GSD_LOGO: 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``
+ * @returns Ready-to-write string with leading/trailing newlines.
+ */
+export declare function renderLogo(color: (s: string) => string): string;

package/dist/logo.js

@@ -0,0 +1,25 @@
+/**
+ * Shared GSD block-letter ASCII logo.
+ *
+ * Single source of truth — imported by:
+ *   - scripts/postinstall.js (via dist/logo.js)
+ *   - src/onboarding.ts (via ./logo.js)
+ */
+/** Raw logo lines — no ANSI codes, no leading newline. */
+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``
+ * @returns Ready-to-write string with leading/trailing newlines.
+ */
+export function renderLogo(color) {
+    return '\n' + GSD_LOGO.map(color).join('\n') + '\n';
+}

package/dist/onboarding.d.ts

@@ -0,0 +1,43 @@
+/**
+ * Unified first-run onboarding wizard.
+ *
+ * Replaces the raw API-key-only wizard with a branded, clack-based experience
+ * that guides users through LLM provider authentication before the TUI launches.
+ *
+ * Flow: logo -> choose LLM provider -> authenticate (OAuth or API key) ->
+ *       optional tool keys -> summary -> TUI launches.
+ *
+ * All steps are skippable. All errors are recoverable. Never crashes boot.
+ */
+import type { AuthStorage } from '@mariozechner/pi-coding-agent';
+/**
+ * Determine if the onboarding wizard should run.
+ *
+ * Returns true when:
+ * - No LLM provider has credentials in authStorage
+ * - We're on a TTY (interactive terminal)
+ *
+ * Returns false (skip wizard) when:
+ * - Any LLM provider is already authed (returning user)
+ * - Not a TTY (piped input, subagent, CI)
+ */
+export declare function shouldRunOnboarding(authStorage: AuthStorage): boolean;
+/**
+ * Run the unified onboarding wizard.
+ *
+ * Walks the user through:
+ * 1. Choose LLM provider
+ * 2. Authenticate (OAuth or API key)
+ * 3. Optional tool API keys
+ * 4. Summary
+ *
+ * All steps are skippable. All errors are recoverable.
+ * Writes status to stderr during execution.
+ */
+export declare function runOnboarding(authStorage: AuthStorage): Promise<void>;
+/**
+ * Hydrate process.env from stored auth.json credentials for optional tool keys.
+ * Runs on every launch so extensions see Brave/Context7/Jina keys stored via the
+ * wizard on prior launches.
+ */
+export declare function loadStoredEnvKeys(authStorage: AuthStorage): void;