gsd-pi 2.3.11 → 2.4.0

package/README.md

@@ -200,7 +200,7 @@ Both terminals read and write the same `.gsd/` files on disk. Your decisions in
 
 ### First launch
 
-On first run, GSD launches a branded setup wizard that walks you through LLM provider selection (OAuth or API key), then optional tool API keys (Brave Search, Context7, Jina, Slack, Discord). Every step is skippable — press Enter to skip any. Run `gsd config` anytime to re-run the wizard.
+On first run, GSD launches a branded setup wizard that walks you through LLM provider selection (OAuth or API key), then optional tool API keys (Brave Search, Context7, Jina, Slack, Discord). Every step is skippable — press Enter to skip any. If you have an existing Pi installation, your provider credentials (LLM and tool keys) are imported automatically. Run `gsd config` anytime to re-run the wizard.
 
 ### Commands
 

package/dist/cli.js

@@ -2,9 +2,10 @@ import { AuthStorage, DefaultResourceLoader, ModelRegistry, SettingsManager, Ses
 import { existsSync, readdirSync, renameSync, readFileSync } from 'node:fs';
 import { join } from 'node:path';
 import { agentDir, sessionsDir, authFilePath } from './app-paths.js';
-import { initResources } from './resource-loader.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: [] };
@@ -74,6 +75,7 @@ if (cliFlags.messages[0] === 'config') {
 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);
@@ -200,7 +202,7 @@ if (existsSync(sessionsDir)) {
 }
 const sessionManager = SessionManager.create(cwd, projectSessionsDir);
 initResources(agentDir);
-const resourceLoader = new DefaultResourceLoader({ agentDir });
+const resourceLoader = buildResourceLoader(agentDir);
 await resourceLoader.reload();
 const { session, extensionsResult } = await createAgentSession({
     authStorage,

package/dist/pi-migration.d.ts

@@ -0,0 +1,14 @@
+/**
+ * One-time migration of provider credentials from Pi (~/.pi/agent/auth.json)
+ * into GSD's auth storage. Runs when GSD has no LLM providers configured,
+ * so users with an existing Pi install skip re-authentication.
+ */
+import type { AuthStorage } from '@mariozechner/pi-coding-agent';
+/**
+ * Migrate provider credentials from Pi's auth.json into GSD's AuthStorage.
+ *
+ * Only runs when GSD has no LLM provider configured and Pi's auth.json exists.
+ * Copies any credentials GSD doesn't already have. Returns true if an LLM
+ * provider was migrated (so onboarding can be skipped).
+ */
+export declare function migratePiCredentials(authStorage: AuthStorage): boolean;

package/dist/pi-migration.js

@@ -0,0 +1,57 @@
+/**
+ * One-time migration of provider credentials from Pi (~/.pi/agent/auth.json)
+ * into GSD's auth storage. Runs when GSD has no LLM providers configured,
+ * so users with an existing Pi install skip re-authentication.
+ */
+import { existsSync, readFileSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { join } from 'node:path';
+const PI_AUTH_PATH = join(homedir(), '.pi', 'agent', 'auth.json');
+const LLM_PROVIDER_IDS = [
+    'anthropic',
+    'openai',
+    'github-copilot',
+    'openai-codex',
+    'google-gemini-cli',
+    'google-antigravity',
+    'google',
+    'groq',
+    'xai',
+    'openrouter',
+    'mistral',
+];
+/**
+ * Migrate provider credentials from Pi's auth.json into GSD's AuthStorage.
+ *
+ * Only runs when GSD has no LLM provider configured and Pi's auth.json exists.
+ * Copies any credentials GSD doesn't already have. Returns true if an LLM
+ * provider was migrated (so onboarding can be skipped).
+ */
+export function migratePiCredentials(authStorage) {
+    try {
+        // Only migrate when GSD has no LLM providers
+        const existing = authStorage.list();
+        const hasLlm = existing.some(id => LLM_PROVIDER_IDS.includes(id));
+        if (hasLlm)
+            return false;
+        if (!existsSync(PI_AUTH_PATH))
+            return false;
+        const raw = readFileSync(PI_AUTH_PATH, 'utf-8');
+        const piData = JSON.parse(raw);
+        let migratedLlm = false;
+        for (const [providerId, credential] of Object.entries(piData)) {
+            if (authStorage.has(providerId))
+                continue;
+            authStorage.set(providerId, credential);
+            const isLlm = LLM_PROVIDER_IDS.includes(providerId);
+            if (isLlm)
+                migratedLlm = true;
+            process.stderr.write(`[gsd] Migrated ${isLlm ? 'LLM provider' : 'credential'}: ${providerId} (from Pi)\n`);
+        }
+        return migratedLlm;
+    }
+    catch {
+        // Non-fatal — don't block startup
+        return false;
+    }
+}

package/package.json

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

package/src/resources/extensions/gsd/git-service.ts

@@ -0,0 +1,369 @@
+/**
+ * GSD Git Service
+ *
+ * Core git operations for GSD: types, constants, and pure helpers.
+ * Higher-level operations (commit, staging, branching) build on these.
+ *
+ * This module centralizes the GitPreferences interface, runtime exclusion
+ * paths, commit type inference, and the runGit shell helper.
+ */
+
+import { execSync } from "node:child_process";
+import { sep } from "node:path";
+
+import {
+  detectWorktreeName,
+  getSliceBranchName,
+  SLICE_BRANCH_RE,
+} from "./worktree.ts";
+
+// ─── Types ─────────────────────────────────────────────────────────────────
+
+export interface GitPreferences {
+  auto_push?: boolean;
+  push_branches?: boolean;
+  remote?: string;
+  snapshots?: boolean;
+  pre_merge_check?: boolean | string;
+  commit_type?: string;
+}
+
+export interface CommitOptions {
+  message: string;
+  allowEmpty?: boolean;
+}
+
+export interface MergeSliceResult {
+  branch: string;
+  mergedCommitMessage: string;
+  deletedBranch: boolean;
+}
+
+// ─── Constants ─────────────────────────────────────────────────────────────
+
+/**
+ * GSD runtime paths that should be excluded from smart staging.
+ * These are transient/generated artifacts that should never be committed.
+ * Matches the union of SKIP_PATHS + SKIP_EXACT in worktree-manager.ts
+ * and the first 6 entries in gitignore.ts BASELINE_PATTERNS.
+ */
+export const RUNTIME_EXCLUSION_PATHS: readonly string[] = [
+  ".gsd/activity/",
+  ".gsd/runtime/",
+  ".gsd/worktrees/",
+  ".gsd/auto.lock",
+  ".gsd/metrics.json",
+  ".gsd/STATE.md",
+];
+
+// ─── Git Helper ────────────────────────────────────────────────────────────
+
+/**
+ * Run a git command in the given directory.
+ * Returns trimmed stdout. Throws on non-zero exit unless allowFailure is set.
+ */
+export function runGit(basePath: string, args: string[], options: { allowFailure?: boolean } = {}): string {
+  try {
+    return execSync(`git ${args.join(" ")}`, {
+      cwd: basePath,
+      stdio: ["ignore", "pipe", "pipe"],
+      encoding: "utf-8",
+    }).trim();
+  } catch (error) {
+    if (options.allowFailure) return "";
+    const message = error instanceof Error ? error.message : String(error);
+    throw new Error(`git ${args.join(" ")} failed in ${basePath}: ${message}`);
+  }
+}
+
+// ─── Commit Type Inference ─────────────────────────────────────────────────
+
+/**
+ * Keyword-to-commit-type mapping. Order matters — first match wins.
+ * Each entry: [keywords[], commitType]
+ */
+const COMMIT_TYPE_RULES: [string[], string][] = [
+  [["fix", "bug", "patch", "hotfix"], "fix"],
+  [["refactor", "restructure", "reorganize"], "refactor"],
+  [["doc", "docs", "documentation"], "docs"],
+  [["test", "tests", "testing"], "test"],
+  [["chore", "cleanup", "clean up", "archive", "remove", "delete"], "chore"],
+];
+
+/**
+ * Infer a conventional commit type from a slice title.
+ * Uses case-insensitive word-boundary matching against known keywords.
+ * Returns "feat" when no keywords match.
+ */
+// ─── GitServiceImpl ────────────────────────────────────────────────────
+
+export class GitServiceImpl {
+  readonly basePath: string;
+  readonly prefs: GitPreferences;
+
+  constructor(basePath: string, prefs: GitPreferences = {}) {
+    this.basePath = basePath;
+    this.prefs = prefs;
+  }
+
+  /** Convenience wrapper: run git in this repo's basePath. */
+  private git(args: string[], options: { allowFailure?: boolean } = {}): string {
+    return runGit(this.basePath, args, options);
+  }
+
+  /**
+   * Smart staging: `git add -A` excluding GSD runtime paths via pathspec.
+   * Falls back to plain `git add -A` if the exclusion pathspec fails.
+   */
+  private smartStage(): void {
+    const excludes = RUNTIME_EXCLUSION_PATHS.map(p => `':(exclude)${p}'`);
+    const args = ["add", "-A", "--", ".", ...excludes];
+    try {
+      this.git(args);
+    } catch {
+      console.error("GitService: smart staging failed, falling back to git add -A");
+      this.git(["add", "-A"]);
+    }
+  }
+
+  /**
+   * Stage files (smart staging) and commit.
+   * Returns the commit message string on success, or null if nothing to commit.
+   */
+  commit(opts: CommitOptions): string | null {
+    this.smartStage();
+
+    // Check if anything was actually staged
+    const staged = this.git(["diff", "--cached", "--stat"], { allowFailure: true });
+    if (!staged && !opts.allowEmpty) return null;
+
+    this.git(["commit", "-m", JSON.stringify(opts.message), ...(opts.allowEmpty ? ["--allow-empty"] : [])]);
+    return opts.message;
+  }
+
+  /**
+   * Auto-commit dirty working tree with a conventional chore message.
+   * Returns the commit message on success, or null if nothing to commit.
+   */
+  autoCommit(unitType: string, unitId: string): string | null {
+    // Quick check: is there anything dirty at all?
+    const status = this.git(["status", "--short"], { allowFailure: true });
+    if (!status) return null;
+
+    this.smartStage();
+
+    // After smart staging, check if anything was actually staged
+    // (all changes might have been runtime files that got excluded)
+    const staged = this.git(["diff", "--cached", "--stat"], { allowFailure: true });
+    if (!staged) return null;
+
+    const message = `chore(${unitId}): auto-commit after ${unitType}`;
+    this.git(["commit", "-m", JSON.stringify(message)]);
+    return message;
+  }
+
+  // ─── Branch Queries ────────────────────────────────────────────────────
+
+  /**
+   * Get the "main" branch for this repo.
+   * In a worktree: returns worktree/<name> (the worktree's base branch).
+   * In the main tree: origin/HEAD symbolic-ref → main/master fallback → current branch.
+   */
+  getMainBranch(): string {
+    const wtName = detectWorktreeName(this.basePath);
+    if (wtName) {
+      const wtBranch = `worktree/${wtName}`;
+      const exists = this.git(["show-ref", "--verify", `refs/heads/${wtBranch}`], { allowFailure: true });
+      if (exists) return wtBranch;
+      return this.git(["branch", "--show-current"]);
+    }
+
+    const symbolic = this.git(["symbolic-ref", "refs/remotes/origin/HEAD"], { allowFailure: true });
+    if (symbolic) {
+      const match = symbolic.match(/refs\/remotes\/origin\/(.+)$/);
+      if (match) return match[1]!;
+    }
+
+    const mainExists = this.git(["show-ref", "--verify", "refs/heads/main"], { allowFailure: true });
+    if (mainExists) return "main";
+
+    const masterExists = this.git(["show-ref", "--verify", "refs/heads/master"], { allowFailure: true });
+    if (masterExists) return "master";
+
+    return this.git(["branch", "--show-current"]);
+  }
+
+  /** Get the current branch name. */
+  getCurrentBranch(): string {
+    return this.git(["branch", "--show-current"]);
+  }
+
+  /** True if currently on a GSD slice branch. */
+  isOnSliceBranch(): boolean {
+    const current = this.getCurrentBranch();
+    return SLICE_BRANCH_RE.test(current);
+  }
+
+  /** Returns the slice branch name if on one, null otherwise. */
+  getActiveSliceBranch(): string | null {
+    try {
+      const current = this.getCurrentBranch();
+      return SLICE_BRANCH_RE.test(current) ? current : null;
+    } catch {
+      return null;
+    }
+  }
+
+  // ─── Branch Lifecycle ──────────────────────────────────────────────────
+
+  /**
+   * Check if a local branch exists.
+   */
+  private branchExists(branch: string): boolean {
+    try {
+      this.git(["show-ref", "--verify", "--quiet", `refs/heads/${branch}`]);
+      return true;
+    } catch {
+      return false;
+    }
+  }
+
+  /**
+   * Ensure the slice branch exists and is checked out.
+   *
+   * Creates the branch from the current working branch if it's not a slice
+   * branch (preserves planning artifacts). Falls back to main when on another
+   * slice branch (avoids chaining slice branches).
+   *
+   * Auto-commits dirty state via smart staging before checkout so runtime
+   * files are never accidentally committed during branch switches.
+   *
+   * Returns true if the branch was newly created.
+   */
+  ensureSliceBranch(milestoneId: string, sliceId: string): boolean {
+    const wtName = detectWorktreeName(this.basePath);
+    const branch = getSliceBranchName(milestoneId, sliceId, wtName);
+    const current = this.getCurrentBranch();
+
+    if (current === branch) return false;
+
+    let created = false;
+
+    if (!this.branchExists(branch)) {
+      // Branch from current when it's a normal working branch (not a slice).
+      // If already on a slice branch, fall back to main to avoid chaining.
+      const mainBranch = this.getMainBranch();
+      const base = SLICE_BRANCH_RE.test(current) ? mainBranch : current;
+      this.git(["branch", branch, base]);
+      created = true;
+    } else {
+      // Branch exists — check it's not checked out in another worktree
+      const worktreeList = this.git(["worktree", "list", "--porcelain"]);
+      if (worktreeList.includes(`branch refs/heads/${branch}`)) {
+        throw new Error(
+          `Branch "${branch}" is already in use by another worktree. ` +
+          `Remove that worktree first, or switch it to a different branch.`,
+        );
+      }
+    }
+
+    // Auto-commit dirty state via smart staging before checkout
+    this.autoCommit("pre-switch", current);
+
+    this.git(["checkout", branch]);
+    return created;
+  }
+
+  /**
+   * Switch to main, auto-committing dirty state via smart staging first.
+   */
+  switchToMain(): void {
+    const mainBranch = this.getMainBranch();
+    const current = this.getCurrentBranch();
+    if (current === mainBranch) return;
+
+    this.autoCommit("pre-switch", current);
+
+    this.git(["checkout", mainBranch]);
+  }
+
+  // ─── Merge ─────────────────────────────────────────────────────────────
+
+  /**
+   * Squash-merge a slice branch into main and delete it.
+   *
+   * Must be called from the main branch. Uses `inferCommitType(sliceTitle)`
+   * for the conventional commit type instead of hardcoding `feat`.
+   *
+   * Throws when:
+   * - Not currently on the main branch
+   * - The slice branch does not exist
+   * - The slice branch has no commits ahead of main
+   */
+  mergeSliceToMain(milestoneId: string, sliceId: string, sliceTitle: string): MergeSliceResult {
+    const mainBranch = this.getMainBranch();
+    const current = this.getCurrentBranch();
+
+    if (current !== mainBranch) {
+      throw new Error(
+        `mergeSliceToMain must be called from the main branch ("${mainBranch}"), ` +
+        `but currently on "${current}"`,
+      );
+    }
+
+    const wtName = detectWorktreeName(this.basePath);
+    const branch = getSliceBranchName(milestoneId, sliceId, wtName);
+
+    if (!this.branchExists(branch)) {
+      throw new Error(
+        `Slice branch "${branch}" does not exist. Nothing to merge.`,
+      );
+    }
+
+    // Check commits ahead
+    const aheadCount = this.git(["rev-list", "--count", `${mainBranch}..${branch}`]);
+    if (aheadCount === "0") {
+      throw new Error(
+        `Slice branch "${branch}" has no commits ahead of "${mainBranch}". Nothing to merge.`,
+      );
+    }
+
+    // Squash merge
+    this.git(["merge", "--squash", branch]);
+
+    // Build conventional commit message
+    const commitType = inferCommitType(sliceTitle);
+    const message = `${commitType}(${milestoneId}/${sliceId}): ${sliceTitle}`;
+    this.git(["commit", "-m", JSON.stringify(message)]);
+
+    // Delete the merged branch
+    this.git(["branch", "-D", branch]);
+
+    return {
+      branch,
+      mergedCommitMessage: message,
+      deletedBranch: true,
+    };
+  }
+}
+
+// ─── Commit Type Inference ─────────────────────────────────────────────────
+
+export function inferCommitType(sliceTitle: string): string {
+  const lower = sliceTitle.toLowerCase();
+
+  for (const [keywords, commitType] of COMMIT_TYPE_RULES) {
+    for (const keyword of keywords) {
+      // "clean up" is multi-word — use indexOf for it
+      if (keyword.includes(" ")) {
+        if (lower.includes(keyword)) return commitType;
+      } else {
+        // Word boundary match: keyword must not be surrounded by word chars
+        const re = new RegExp(`\\b${keyword}\\b`, "i");
+        if (re.test(lower)) return commitType;
+      }
+    }
+  }
+
+  return "feat";
+}

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

@@ -158,14 +158,19 @@ export default function (pi: ExtensionAPI) {
 
   // ── session_start: render branded GSD header + remote channel status ──
   pi.on("session_start", async (_event, ctx) => {
-    const theme = ctx.ui.theme;
-    const version = process.env.GSD_VERSION || "0.0.0";
+    // Theme access throws in RPC mode (no TUI) — header is decorative, skip it
+    try {
+      const theme = ctx.ui.theme;
+      const version = process.env.GSD_VERSION || "0.0.0";
 
-    const logoText = GSD_LOGO_LINES.map((line) => theme.fg("accent", line)).join("\n");
-    const titleLine = `  ${theme.bold("Get Shit Done")} ${theme.fg("dim", `v${version}`)}`;
+      const logoText = GSD_LOGO_LINES.map((line) => theme.fg("accent", line)).join("\n");
+      const titleLine = `  ${theme.bold("Get Shit Done")} ${theme.fg("dim", `v${version}`)}`;
 
-    const headerContent = `${logoText}\n${titleLine}`;
-    ctx.ui.setHeader((_ui, _theme) => new Text(headerContent, 1, 0));
+      const headerContent = `${logoText}\n${titleLine}`;
+      ctx.ui.setHeader((_ui, _theme) => new Text(headerContent, 1, 0));
+    } catch {
+      // RPC mode — no TUI, skip header rendering
+    }
 
     // Notify remote questions status if configured
     try {

package/src/resources/extensions/gsd/prompts/execute-task.md

@@ -19,6 +19,7 @@ Start with the inlined context below. Treat the inlined task plan as the authori
 {{priorTaskLines}}
 
 Then:
+0. Narrate step transitions, key implementation decisions, and verification outcomes as you work. Keep it terse — one line between tool-call clusters, not between every call.
 1. If a `GSD Skill Preferences` block is present in system context, use it to decide which skills to load and follow during execution, without relaxing required verification or artifact rules
 2. Execute the steps in the inlined task plan
 3. Build the real thing. If the task plan says "create login endpoint", build an endpoint that actually authenticates against a real store, not one that returns a hardcoded success response. If the task plan says "create dashboard page", build a page that renders real data from the API, not a component with hardcoded props. Stubs and mocks are for tests, not for the shipped feature.

package/src/resources/extensions/gsd/prompts/plan-milestone.md

@@ -6,6 +6,8 @@ All relevant context has been preloaded below — start working immediately with
 
 {{inlinedContext}}
 
+Narrate your decomposition reasoning — why you're grouping work this way, what risks are driving the order, what verification strategy you're choosing and why.
+
 Then:
 1. Read the template at `~/.gsd/agent/extensions/gsd/templates/roadmap.md`
 2. Read `.gsd/REQUIREMENTS.md` if it exists. Treat **Active** requirements as the capability contract for planning. If it does not exist, continue in legacy compatibility mode but explicitly note that requirement coverage is operating without a contract.

package/src/resources/extensions/gsd/prompts/plan-slice.md

@@ -12,6 +12,8 @@ Pay particular attention to **Forward Intelligence** sections — they contain h
 
 {{dependencySummaries}}
 
+Narrate your decomposition reasoning — why you're grouping work this way, what risks are driving the order, what verification strategy you're choosing and why.
+
 Then:
 0. If `REQUIREMENTS.md` was preloaded above, identify which Active requirements the roadmap says this slice owns or supports. These are the requirements this plan must deliver — every owned requirement needs at least one task that directly advances it, and verification must prove the requirement is met.
 1. Read the templates:

package/src/resources/extensions/gsd/prompts/research-milestone.md

@@ -6,7 +6,7 @@ All relevant context has been preloaded below — start working immediately with
 
 {{inlinedContext}}
 
-Then research the codebase and relevant technologies:
+Then research the codebase and relevant technologies. Narrate key findings and surprises as you go — what exists, what's missing, what constrains the approach.
 1. If a `GSD Skill Preferences` block is present in system context, use it to decide which skills to load and follow during research, without relaxing required verification or artifact rules
 2. **Skill Discovery ({{skillDiscoveryMode}}):**{{skillDiscoveryInstructions}}
 3. Explore relevant code. For small/familiar codebases, use `rg`, `find`, and targeted reads. For large or unfamiliar codebases, use `scout` to build a broad map efficiently before diving in.

package/src/resources/extensions/gsd/prompts/research-slice.md

@@ -12,7 +12,7 @@ Pay particular attention to **Forward Intelligence** sections — they contain h
 
 {{dependencySummaries}}
 
-Then research what this slice needs:
+Then research what this slice needs. Narrate key findings and surprises as you go — what exists, what's missing, what constrains the approach.
 0. If `REQUIREMENTS.md` was preloaded above, identify which Active requirements this slice owns or supports. Research should target these requirements — surfacing risks, unknowns, and implementation constraints that could affect whether the slice actually delivers them.
 1. If a `GSD Skill Preferences` block is present in system context, use it to decide which skills to load and follow during research, without relaxing required verification or artifact rules
 2. **Skill Discovery ({{skillDiscoveryMode}}):**{{skillDiscoveryInstructions}}