gsd-pi 2.33.1 → 2.34.0-dev.6769913

package/dist/resources/extensions/gsd/migrate-external.ts

@@ -1,140 +0,0 @@
-/**
- * GSD External State Migration
- *
- * Migrates legacy in-project `.gsd/` directories to the external
- * `~/.gsd/projects/<hash>/` state directory. After migration, a
- * symlink replaces the original directory so all paths remain valid.
- */
-
-import { existsSync, lstatSync, mkdirSync, readdirSync, renameSync, cpSync, rmSync, symlinkSync } from "node:fs";
-import { join } from "node:path";
-import { externalGsdRoot } from "./repo-identity.js";
-import { getErrorMessage } from "./error-utils.js";
-
-export interface MigrationResult {
-  migrated: boolean;
-  error?: string;
-}
-
-/**
- * Migrate a legacy in-project `.gsd/` directory to external storage.
- *
- * Algorithm:
- * 1. If `<project>/.gsd` is a symlink or doesn't exist -> skip
- * 2. If `<project>/.gsd` is a real directory:
- *    a. Compute external path from repoIdentity
- *    b. mkdir -p external dir
- *    c. Rename `.gsd` -> `.gsd.migrating` (atomic on same FS, acts as lock)
- *    d. Copy contents to external dir (skip `worktrees/` subdirectory)
- *    e. Create symlink `.gsd -> external path`
- *    f. Remove `.gsd.migrating`
- * 3. On failure: rename `.gsd.migrating` back to `.gsd` (rollback)
- */
-export function migrateToExternalState(basePath: string): MigrationResult {
-  const localGsd = join(basePath, ".gsd");
-
-  // Skip if doesn't exist
-  if (!existsSync(localGsd)) {
-    return { migrated: false };
-  }
-
-  // Skip if already a symlink
-  try {
-    const stat = lstatSync(localGsd);
-    if (stat.isSymbolicLink()) {
-      return { migrated: false };
-    }
-    if (!stat.isDirectory()) {
-      return { migrated: false, error: ".gsd exists but is not a directory or symlink" };
-    }
-  } catch (err) {
-    return { migrated: false, error: `Cannot stat .gsd: ${getErrorMessage(err)}` };
-  }
-
-  const externalPath = externalGsdRoot(basePath);
-  const migratingPath = join(basePath, ".gsd.migrating");
-
-  try {
-    // mkdir -p the external dir
-    mkdirSync(externalPath, { recursive: true });
-
-    // Rename .gsd -> .gsd.migrating (atomic lock).
-    // On Windows, NTFS may reject rename with EPERM if file descriptors are
-    // open (VS Code watchers, antivirus on-access scan). Fall back to
-    // copy+delete (#1292).
-    try {
-      renameSync(localGsd, migratingPath);
-    } catch (renameErr: any) {
-      if (renameErr?.code === "EPERM" || renameErr?.code === "EBUSY") {
-        try {
-          cpSync(localGsd, migratingPath, { recursive: true, force: true });
-          rmSync(localGsd, { recursive: true, force: true });
-        } catch (copyErr) {
-          return { migrated: false, error: `Migration rename/copy failed: ${copyErr instanceof Error ? copyErr.message : String(copyErr)}` };
-        }
-      } else {
-        throw renameErr;
-      }
-    }
-
-    // Copy contents to external dir, skipping worktrees/
-    const entries = readdirSync(migratingPath, { withFileTypes: true });
-    for (const entry of entries) {
-      if (entry.name === "worktrees") continue; // worktrees stay local
-
-      const src = join(migratingPath, entry.name);
-      const dst = join(externalPath, entry.name);
-
-      try {
-        if (entry.isDirectory()) {
-          cpSync(src, dst, { recursive: true, force: true });
-        } else {
-          cpSync(src, dst, { force: true });
-        }
-      } catch {
-        // Non-fatal: continue with other files
-      }
-    }
-
-    // Create symlink .gsd -> external path
-    symlinkSync(externalPath, localGsd, "junction");
-
-    // Remove .gsd.migrating
-    rmSync(migratingPath, { recursive: true, force: true });
-
-    return { migrated: true };
-  } catch (err) {
-    // Rollback: rename .gsd.migrating back to .gsd
-    try {
-      if (existsSync(migratingPath) && !existsSync(localGsd)) {
-        renameSync(migratingPath, localGsd);
-      }
-    } catch {
-      // Rollback failed -- leave .gsd.migrating for doctor to detect
-    }
-
-    return {
-      migrated: false,
-      error: `Migration failed: ${getErrorMessage(err)}`,
-    };
-  }
-}
-
-/**
- * Recover from a failed migration (`.gsd.migrating` exists).
- * Moves `.gsd.migrating` back to `.gsd` if `.gsd` doesn't exist.
- */
-export function recoverFailedMigration(basePath: string): boolean {
-  const localGsd = join(basePath, ".gsd");
-  const migratingPath = join(basePath, ".gsd.migrating");
-
-  if (!existsSync(migratingPath)) return false;
-  if (existsSync(localGsd)) return false; // both exist -- ambiguous, don't touch
-
-  try {
-    renameSync(migratingPath, localGsd);
-    return true;
-  } catch {
-    return false;
-  }
-}

package/dist/resources/extensions/gsd/milestone-actions.ts

@@ -1,126 +0,0 @@
-/**
- * GSD Milestone Actions — Park, Unpark, and Discard operations.
- *
- * Park: Creates a PARKED.md marker file. deriveState() skips parked milestones
- * when finding the active milestone, but keeps them in the registry.
- *
- * Unpark: Removes the PARKED.md marker. The milestone resumes normal state
- * derivation (active/pending depending on position and dependencies).
- *
- * Discard: Permanently removes the milestone directory. Also prunes
- * QUEUE-ORDER.json if the discarded milestone was in it.
- */
-
-import { existsSync, rmSync, writeFileSync, readFileSync, unlinkSync } from "node:fs";
-import { join } from "node:path";
-import {
-  resolveMilestonePath,
-  resolveMilestoneFile,
-  buildMilestoneFileName,
-} from "./paths.js";
-import { invalidateAllCaches } from "./cache.js";
-import { loadQueueOrder, saveQueueOrder } from "./queue-order.js";
-
-// ─── Park ──────────────────────────────────────────────────────────────────
-
-/**
- * Park a milestone — creates a PARKED.md marker file with reason and timestamp.
- * Parked milestones are skipped during active-milestone discovery but stay on disk.
- * Returns true if successfully parked, false if milestone not found or already parked.
- */
-export function parkMilestone(basePath: string, milestoneId: string, reason: string): boolean {
-  const mDir = resolveMilestonePath(basePath, milestoneId);
-  if (!mDir || !existsSync(mDir)) return false;
-
-  // Guard: do not park a completed milestone — it would corrupt depends_on satisfaction
-  const summaryFile = resolveMilestoneFile(basePath, milestoneId, "SUMMARY");
-  if (summaryFile) return false;
-
-  const parkedPath = join(mDir, buildMilestoneFileName(milestoneId, "PARKED"));
-  if (existsSync(parkedPath)) return false; // already parked
-
-  const content = [
-    "---",
-    `parked_at: ${new Date().toISOString()}`,
-    `reason: "${reason.replace(/"/g, '\\"')}"`,
-    "---",
-    "",
-    `# ${milestoneId} — Parked`,
-    "",
-    `> ${reason}`,
-    "",
-  ].join("\n");
-
-  writeFileSync(parkedPath, content, "utf-8");
-  invalidateAllCaches();
-  return true;
-}
-
-// ─── Unpark ────────────────────────────────────────────────────────────────
-
-/**
- * Unpark a milestone — removes the PARKED.md marker file.
- * Returns true if successfully unparked, false if milestone not found or not parked.
- */
-export function unparkMilestone(basePath: string, milestoneId: string): boolean {
-  const mDir = resolveMilestonePath(basePath, milestoneId);
-  if (!mDir || !existsSync(mDir)) return false;
-
-  const parkedPath = join(mDir, buildMilestoneFileName(milestoneId, "PARKED"));
-  if (!existsSync(parkedPath)) return false; // not parked
-
-  unlinkSync(parkedPath);
-  invalidateAllCaches();
-  return true;
-}
-
-// ─── Discard ───────────────────────────────────────────────────────────────
-
-/**
- * Discard a milestone — permanently removes the milestone directory and
- * prunes it from QUEUE-ORDER.json if present.
- * Returns true if successfully discarded, false if milestone not found.
- */
-export function discardMilestone(basePath: string, milestoneId: string): boolean {
-  const mDir = resolveMilestonePath(basePath, milestoneId);
-  if (!mDir || !existsSync(mDir)) return false;
-
-  rmSync(mDir, { recursive: true, force: true });
-
-  // Prune from queue order if present
-  const order = loadQueueOrder(basePath);
-  if (order && order.includes(milestoneId)) {
-    saveQueueOrder(basePath, order.filter(id => id !== milestoneId));
-  }
-
-  invalidateAllCaches();
-  return true;
-}
-
-// ─── Query ─────────────────────────────────────────────────────────────────
-
-/**
- * Check whether a milestone is parked (PARKED.md exists).
- */
-export function isParked(basePath: string, milestoneId: string): boolean {
-  return !!resolveMilestoneFile(basePath, milestoneId, "PARKED");
-}
-
-/**
- * Read the park reason from PARKED.md frontmatter.
- * Returns null if the milestone is not parked or the reason can't be extracted.
- */
-export function getParkedReason(basePath: string, milestoneId: string): string | null {
-  const parkedFile = resolveMilestoneFile(basePath, milestoneId, "PARKED");
-  if (!parkedFile) return null;
-
-  try {
-    const content = readFileSync(parkedFile, "utf-8");
-    const match = content.match(/^---\n([\s\S]*?)\n---/);
-    if (!match) return null;
-    const reasonMatch = match[1].match(/reason:\s*"([^"]*?)"/);
-    return reasonMatch ? reasonMatch[1] : null;
-  } catch {
-    return null;
-  }
-}

package/dist/resources/extensions/gsd/model-cost-table.ts

@@ -1,65 +0,0 @@
-// GSD Extension — Model Cost Table
-// Static cost reference for known models, used by the dynamic router
-// for cross-provider cost comparison.
-//
-// Costs are approximate per-1K-token rates in USD (input tokens).
-// Updated with GSD releases. Users can override via preferences.
-
-export interface ModelCostEntry {
-  /** Model ID (bare, without provider prefix) */
-  id: string;
-  /** Approximate cost per 1K input tokens in USD */
-  inputPer1k: number;
-  /** Approximate cost per 1K output tokens in USD */
-  outputPer1k: number;
-  /** Last updated date */
-  updatedAt: string;
-}
-
-/**
- * Bundled cost table for known models.
- * Updated periodically with GSD releases.
- */
-export const BUNDLED_COST_TABLE: ModelCostEntry[] = [
-  // Anthropic
-  { id: "claude-opus-4-6", inputPer1k: 0.015, outputPer1k: 0.075, updatedAt: "2025-03-15" },
-  { id: "claude-sonnet-4-6", inputPer1k: 0.003, outputPer1k: 0.015, updatedAt: "2025-03-15" },
-  { id: "claude-haiku-4-5", inputPer1k: 0.0008, outputPer1k: 0.004, updatedAt: "2025-03-15" },
-  { id: "claude-sonnet-4-5-20250514", inputPer1k: 0.003, outputPer1k: 0.015, updatedAt: "2025-03-15" },
-  { id: "claude-3-5-sonnet-latest", inputPer1k: 0.003, outputPer1k: 0.015, updatedAt: "2025-03-15" },
-  { id: "claude-3-5-haiku-latest", inputPer1k: 0.0008, outputPer1k: 0.004, updatedAt: "2025-03-15" },
-  { id: "claude-3-opus-latest", inputPer1k: 0.015, outputPer1k: 0.075, updatedAt: "2025-03-15" },
-
-  // OpenAI
-  { id: "gpt-4o", inputPer1k: 0.0025, outputPer1k: 0.01, updatedAt: "2025-03-15" },
-  { id: "gpt-4o-mini", inputPer1k: 0.00015, outputPer1k: 0.0006, updatedAt: "2025-03-15" },
-  { id: "o1", inputPer1k: 0.015, outputPer1k: 0.06, updatedAt: "2025-03-15" },
-  { id: "o3", inputPer1k: 0.015, outputPer1k: 0.06, updatedAt: "2025-03-15" },
-  { id: "gpt-4-turbo", inputPer1k: 0.01, outputPer1k: 0.03, updatedAt: "2025-03-15" },
-
-  // Google
-  { id: "gemini-2.0-flash", inputPer1k: 0.0001, outputPer1k: 0.0004, updatedAt: "2025-03-15" },
-  { id: "gemini-flash-2.0", inputPer1k: 0.0001, outputPer1k: 0.0004, updatedAt: "2025-03-15" },
-  { id: "gemini-2.5-pro", inputPer1k: 0.00125, outputPer1k: 0.005, updatedAt: "2025-03-15" },
-
-  // DeepSeek
-  { id: "deepseek-chat", inputPer1k: 0.00014, outputPer1k: 0.00028, updatedAt: "2025-03-15" },
-];
-
-/**
- * Lookup cost for a model ID. Returns undefined if not found.
- */
-export function lookupModelCost(modelId: string): ModelCostEntry | undefined {
-  const bareId = modelId.includes("/") ? modelId.split("/").pop()! : modelId;
-  return BUNDLED_COST_TABLE.find(e => e.id === bareId)
-    ?? BUNDLED_COST_TABLE.find(e => bareId.includes(e.id) || e.id.includes(bareId));
-}
-
-/**
- * Compare two models by input cost. Returns negative if a is cheaper.
- */
-export function compareModelCost(modelIdA: string, modelIdB: string): number {
-  const costA = lookupModelCost(modelIdA)?.inputPer1k ?? 999;
-  const costB = lookupModelCost(modelIdB)?.inputPer1k ?? 999;
-  return costA - costB;
-}

package/dist/resources/extensions/gsd/model-router.ts

@@ -1,256 +0,0 @@
-// GSD Extension — Dynamic Model Router
-// Maps complexity tiers to models, enforcing downgrade-only semantics.
-// The user's configured model is always the ceiling.
-
-import type { ComplexityTier, ClassificationResult } from "./complexity-classifier.js";
-import { tierOrdinal } from "./complexity-classifier.js";
-import type { ResolvedModelConfig } from "./preferences.js";
-
-// ─── Types ───────────────────────────────────────────────────────────────────
-
-export interface DynamicRoutingConfig {
-  enabled?: boolean;
-  tier_models?: {
-    light?: string;
-    standard?: string;
-    heavy?: string;
-  };
-  escalate_on_failure?: boolean;   // default: true
-  budget_pressure?: boolean;       // default: true
-  cross_provider?: boolean;        // default: true
-  hooks?: boolean;                 // default: true
-}
-
-export interface RoutingDecision {
-  /** The model ID to use (may be downgraded from configured) */
-  modelId: string;
-  /** Fallback chain: [selected_model, ...configured_fallbacks, configured_primary] */
-  fallbacks: string[];
-  /** The complexity tier that drove this decision */
-  tier: ComplexityTier;
-  /** True if the model was downgraded from the configured primary */
-  wasDowngraded: boolean;
-  /** Human-readable reason for this decision */
-  reason: string;
-}
-
-// ─── Known Model Tiers ───────────────────────────────────────────────────────
-// Maps known model IDs to their capability tier. Used when tier_models is not
-// explicitly configured to pick the best available model for each tier.
-
-const MODEL_CAPABILITY_TIER: Record<string, ComplexityTier> = {
-  // Light-tier models (cheapest)
-  "claude-haiku-4-5": "light",
-  "claude-3-5-haiku-latest": "light",
-  "claude-3-haiku-20240307": "light",
-  "gpt-4o-mini": "light",
-  "gemini-2.0-flash": "light",
-  "gemini-flash-2.0": "light",
-
-  // Standard-tier models
-  "claude-sonnet-4-6": "standard",
-  "claude-sonnet-4-5-20250514": "standard",
-  "claude-3-5-sonnet-latest": "standard",
-  "gpt-4o": "standard",
-  "gemini-2.5-pro": "standard",
-  "deepseek-chat": "standard",
-
-  // Heavy-tier models (most capable)
-  "claude-opus-4-6": "heavy",
-  "claude-3-opus-latest": "heavy",
-  "gpt-4-turbo": "heavy",
-  "o1": "heavy",
-  "o3": "heavy",
-};
-
-// ─── Cost Table (per 1K input tokens, approximate USD) ───────────────────────
-// Used for cross-provider cost comparison when multiple providers offer
-// the same capability tier.
-
-const MODEL_COST_PER_1K_INPUT: Record<string, number> = {
-  "claude-haiku-4-5": 0.0008,
-  "claude-3-5-haiku-latest": 0.0008,
-  "claude-sonnet-4-6": 0.003,
-  "claude-sonnet-4-5-20250514": 0.003,
-  "claude-opus-4-6": 0.015,
-  "gpt-4o-mini": 0.00015,
-  "gpt-4o": 0.0025,
-  "gemini-2.0-flash": 0.0001,
-  "gemini-2.5-pro": 0.00125,
-  "deepseek-chat": 0.00014,
-};
-
-// ─── Public API ──────────────────────────────────────────────────────────────
-
-/**
- * Resolve the model to use for a given complexity tier.
- *
- * Downgrade-only: the returned model is always equal to or cheaper than
- * the user's configured primary model. Never upgrades beyond configuration.
- *
- * @param classification  The complexity classification result
- * @param phaseConfig     The user's configured model for this phase (ceiling)
- * @param routingConfig   Dynamic routing configuration
- * @param availableModelIds  List of available model IDs (from registry)
- */
-export function resolveModelForComplexity(
-  classification: ClassificationResult,
-  phaseConfig: ResolvedModelConfig | undefined,
-  routingConfig: DynamicRoutingConfig,
-  availableModelIds: string[],
-): RoutingDecision {
-  // If no phase config or routing disabled, pass through
-  if (!phaseConfig || !routingConfig.enabled) {
-    return {
-      modelId: phaseConfig?.primary ?? "",
-      fallbacks: phaseConfig?.fallbacks ?? [],
-      tier: classification.tier,
-      wasDowngraded: false,
-      reason: "dynamic routing disabled or no phase config",
-    };
-  }
-
-  const configuredPrimary = phaseConfig.primary;
-  const configuredTier = getModelTier(configuredPrimary);
-  const requestedTier = classification.tier;
-
-  // Downgrade-only: if requested tier >= configured tier, no change
-  if (tierOrdinal(requestedTier) >= tierOrdinal(configuredTier)) {
-    return {
-      modelId: configuredPrimary,
-      fallbacks: phaseConfig.fallbacks,
-      tier: requestedTier,
-      wasDowngraded: false,
-      reason: `tier ${requestedTier} >= configured ${configuredTier}`,
-    };
-  }
-
-  // Find the best model for the requested tier
-  const targetModelId = findModelForTier(
-    requestedTier,
-    routingConfig,
-    availableModelIds,
-    routingConfig.cross_provider !== false,
-  );
-
-  if (!targetModelId) {
-    // No suitable model found — use configured primary
-    return {
-      modelId: configuredPrimary,
-      fallbacks: phaseConfig.fallbacks,
-      tier: requestedTier,
-      wasDowngraded: false,
-      reason: `no ${requestedTier}-tier model available`,
-    };
-  }
-
-  // Build fallback chain: [downgraded_model, ...configured_fallbacks, configured_primary]
-  const fallbacks = [
-    ...phaseConfig.fallbacks.filter(f => f !== targetModelId),
-    configuredPrimary,
-  ].filter(f => f !== targetModelId);
-
-  return {
-    modelId: targetModelId,
-    fallbacks,
-    tier: requestedTier,
-    wasDowngraded: true,
-    reason: classification.reason,
-  };
-}
-
-/**
- * Escalate to the next tier after a failure.
- * Returns the new tier, or null if already at heavy (max).
- */
-export function escalateTier(currentTier: ComplexityTier): ComplexityTier | null {
-  switch (currentTier) {
-    case "light": return "standard";
-    case "standard": return "heavy";
-    case "heavy": return null;
-  }
-}
-
-/**
- * Get the default routing config (all features enabled).
- */
-export function defaultRoutingConfig(): DynamicRoutingConfig {
-  return {
-    enabled: false,
-    escalate_on_failure: true,
-    budget_pressure: true,
-    cross_provider: true,
-    hooks: true,
-  };
-}
-
-// ─── Internal ────────────────────────────────────────────────────────────────
-
-function getModelTier(modelId: string): ComplexityTier {
-  // Strip provider prefix if present
-  const bareId = modelId.includes("/") ? modelId.split("/").pop()! : modelId;
-
-  // Check exact match first
-  if (MODEL_CAPABILITY_TIER[bareId]) return MODEL_CAPABILITY_TIER[bareId];
-
-  // Check if any known model ID is a prefix/suffix match
-  for (const [knownId, tier] of Object.entries(MODEL_CAPABILITY_TIER)) {
-    if (bareId.includes(knownId) || knownId.includes(bareId)) return tier;
-  }
-
-  // Unknown models are assumed heavy (safest assumption)
-  return "heavy";
-}
-
-function findModelForTier(
-  tier: ComplexityTier,
-  config: DynamicRoutingConfig,
-  availableModelIds: string[],
-  crossProvider: boolean,
-): string | null {
-  // 1. Check explicit tier_models config
-  const explicitModel = config.tier_models?.[tier];
-  if (explicitModel && availableModelIds.includes(explicitModel)) {
-    return explicitModel;
-  }
-  // Also check with provider prefix stripped
-  if (explicitModel) {
-    const match = availableModelIds.find(id => {
-      const bareAvail = id.includes("/") ? id.split("/").pop()! : id;
-      const bareExplicit = explicitModel.includes("/") ? explicitModel.split("/").pop()! : explicitModel;
-      return bareAvail === bareExplicit;
-    });
-    if (match) return match;
-  }
-
-  // 2. Auto-detect: find the cheapest available model in the requested tier
-  const candidates = availableModelIds
-    .filter(id => {
-      const modelTier = getModelTier(id);
-      return modelTier === tier;
-    })
-    .sort((a, b) => {
-      if (!crossProvider) return 0;
-      const costA = getModelCost(a);
-      const costB = getModelCost(b);
-      return costA - costB;
-    });
-
-  return candidates[0] ?? null;
-}
-
-function getModelCost(modelId: string): number {
-  const bareId = modelId.includes("/") ? modelId.split("/").pop()! : modelId;
-
-  if (MODEL_COST_PER_1K_INPUT[bareId] !== undefined) {
-    return MODEL_COST_PER_1K_INPUT[bareId];
-  }
-
-  // Check partial matches
-  for (const [knownId, cost] of Object.entries(MODEL_COST_PER_1K_INPUT)) {
-    if (bareId.includes(knownId) || knownId.includes(bareId)) return cost;
-  }
-
-  // Unknown cost — assume expensive to avoid routing to unknown cheap models
-  return 999;
-}