gsd-pi 2.33.1 → 2.34.0-dev.6769913

package/dist/resources/extensions/gsd/preferences-models.js

@@ -0,0 +1,294 @@
+/**
+ * Model-related preferences: resolution, fallbacks, profile defaults, and routing.
+ *
+ * Contains all logic for resolving model configurations from preferences,
+ * including per-phase model selection, fallback chains, token profiles,
+ * and dynamic routing configuration.
+ */
+import { existsSync, readFileSync, writeFileSync } from "node:fs";
+import { defaultRoutingConfig } from "./model-router.js";
+import { loadEffectiveGSDPreferences, getGlobalGSDPreferencesPath } from "./preferences.js";
+/**
+ * Resolve which model ID to use for a given auto-mode unit type.
+ * Returns undefined if no model preference is set for this unit type.
+ */
+export function resolveModelForUnit(unitType) {
+    const resolved = resolveModelWithFallbacksForUnit(unitType);
+    return resolved?.primary;
+}
+/**
+ * Resolve model and fallbacks for a given auto-mode unit type.
+ * Returns the primary model and ordered fallbacks, or undefined if not configured.
+ *
+ * Supports both legacy string format and extended object format:
+ * - Legacy: `planning: claude-opus-4-6`
+ * - Extended: `planning: { model: claude-opus-4-6, fallbacks: [glm-5, minimax-m2.5] }`
+ */
+export function resolveModelWithFallbacksForUnit(unitType) {
+    const prefs = loadEffectiveGSDPreferences();
+    if (!prefs?.preferences.models)
+        return undefined;
+    const m = prefs.preferences.models;
+    let phaseConfig;
+    switch (unitType) {
+        case "research-milestone":
+        case "research-slice":
+            phaseConfig = m.research;
+            break;
+        case "plan-milestone":
+        case "plan-slice":
+        case "replan-slice":
+            phaseConfig = m.planning;
+            break;
+        case "execute-task":
+            phaseConfig = m.execution;
+            break;
+        case "execute-task-simple":
+            phaseConfig = m.execution_simple ?? m.execution;
+            break;
+        case "complete-slice":
+        case "run-uat":
+            phaseConfig = m.completion;
+            break;
+        default:
+            // Subagent unit types (e.g., "subagent", "subagent/scout")
+            if (unitType === "subagent" || unitType.startsWith("subagent/")) {
+                phaseConfig = m.subagent;
+                break;
+            }
+            return undefined;
+    }
+    if (!phaseConfig)
+        return undefined;
+    // Normalize: string -> { model, fallbacks: [] }
+    if (typeof phaseConfig === "string") {
+        return { primary: phaseConfig, fallbacks: [] };
+    }
+    // When provider is explicitly set, prepend it to the model ID so the
+    // resolution code in auto.ts can do an explicit provider match.
+    const primary = phaseConfig.provider && !phaseConfig.model.includes("/")
+        ? `${phaseConfig.provider}/${phaseConfig.model}`
+        : phaseConfig.model;
+    return {
+        primary,
+        fallbacks: phaseConfig.fallbacks ?? [],
+    };
+}
+/**
+ * Determines the next fallback model to try when the current model fails.
+ * If the current model is not in the configured list, returns the primary model.
+ * If the current model is the last in the list, returns undefined (exhausted).
+ */
+export function getNextFallbackModel(currentModelId, modelConfig) {
+    const modelsToTry = [modelConfig.primary, ...modelConfig.fallbacks];
+    if (!currentModelId) {
+        return modelsToTry[0];
+    }
+    let foundCurrent = false;
+    for (let i = 0; i < modelsToTry.length; i++) {
+        const mId = modelsToTry[i];
+        // Check for exact match or provider/model suffix match
+        if (mId === currentModelId || (mId.includes("/") && mId.endsWith(`/${currentModelId}`))) {
+            foundCurrent = true;
+            return modelsToTry[i + 1]; // Return the next one, or undefined if at the end
+        }
+    }
+    // If the current model wasn't in our preference list, default to starting the sequence
+    if (!foundCurrent) {
+        return modelsToTry[0];
+    }
+}
+/**
+ * Detect whether an error message indicates a transient network error
+ * (worth retrying the same model) vs a permanent provider error
+ * (auth failure, quota exceeded, etc. -- should fall back immediately).
+ */
+export function isTransientNetworkError(errorMsg) {
+    if (!errorMsg)
+        return false;
+    const hasNetworkSignal = /network|ECONNRESET|ETIMEDOUT|ECONNREFUSED|socket hang up|fetch failed|connection.*reset|dns/i.test(errorMsg);
+    const hasPermanentSignal = /auth|unauthorized|forbidden|invalid.*key|quota|billing/i.test(errorMsg);
+    return hasNetworkSignal && !hasPermanentSignal;
+}
+/**
+ * Validate a model ID string.
+ * Returns true if the ID looks like a valid model identifier.
+ */
+export function validateModelId(modelId) {
+    if (!modelId || typeof modelId !== "string")
+        return false;
+    const trimmed = modelId.trim();
+    if (trimmed.length === 0 || trimmed.length > 256)
+        return false;
+    // Allow alphanumeric, hyphens, underscores, dots, slashes, colons
+    return /^[a-zA-Z0-9\-_./:]+$/.test(trimmed);
+}
+/**
+ * Update the models section of the global GSD preferences file.
+ * Performs a safe read-modify-write: reads current content, updates the models
+ * YAML block, and writes back. Creates the file if it doesn't exist.
+ */
+export function updatePreferencesModels(models) {
+    const prefsPath = getGlobalGSDPreferencesPath();
+    let content = "";
+    if (existsSync(prefsPath)) {
+        content = readFileSync(prefsPath, "utf-8");
+    }
+    // Build the new models block
+    const lines = ["models:"];
+    for (const [phase, value] of Object.entries(models)) {
+        if (typeof value === "string") {
+            lines.push(`  ${phase}: ${value}`);
+        }
+        else if (value && typeof value === "object") {
+            const config = value;
+            lines.push(`  ${phase}:`);
+            lines.push(`    model: ${config.model}`);
+            if (config.provider) {
+                lines.push(`    provider: ${config.provider}`);
+            }
+            if (config.fallbacks && config.fallbacks.length > 0) {
+                lines.push(`    fallbacks:`);
+                for (const fb of config.fallbacks) {
+                    lines.push(`      - ${fb}`);
+                }
+            }
+        }
+    }
+    const modelsBlock = lines.join("\n");
+    // Replace existing models block or append
+    const modelsRegex = /^models:[\s\S]*?(?=\n[a-z_]|\n*$)/m;
+    if (modelsRegex.test(content)) {
+        content = content.replace(modelsRegex, modelsBlock);
+    }
+    else {
+        content = content.trimEnd() + "\n\n" + modelsBlock + "\n";
+    }
+    writeFileSync(prefsPath, content, "utf-8");
+}
+/**
+ * Resolve the dynamic routing configuration from effective preferences.
+ * Returns the merged config with defaults applied.
+ */
+export function resolveDynamicRoutingConfig() {
+    const prefs = loadEffectiveGSDPreferences();
+    const configured = prefs?.preferences.dynamic_routing;
+    if (!configured)
+        return defaultRoutingConfig();
+    return {
+        ...defaultRoutingConfig(),
+        ...configured,
+    };
+}
+export function resolveAutoSupervisorConfig() {
+    const prefs = loadEffectiveGSDPreferences();
+    const configured = prefs?.preferences.auto_supervisor ?? {};
+    return {
+        soft_timeout_minutes: configured.soft_timeout_minutes ?? 20,
+        idle_timeout_minutes: configured.idle_timeout_minutes ?? 10,
+        hard_timeout_minutes: configured.hard_timeout_minutes ?? 30,
+        ...(configured.model ? { model: configured.model } : {}),
+    };
+}
+// ─── Token Profile Resolution ─────────────────────────────────────────────
+const VALID_TOKEN_PROFILES = new Set(["budget", "balanced", "quality"]);
+/**
+ * Resolve profile defaults for a given token profile tier.
+ * Returns a partial GSDPreferences that is used as the base layer --
+ * explicit user preferences always override these defaults.
+ */
+export function resolveProfileDefaults(profile) {
+    switch (profile) {
+        case "budget":
+            return {
+                models: {
+                    planning: "claude-sonnet-4-5-20250514",
+                    execution: "claude-sonnet-4-5-20250514",
+                    execution_simple: "claude-haiku-4-5-20250414",
+                    completion: "claude-haiku-4-5-20250414",
+                    subagent: "claude-haiku-4-5-20250414",
+                },
+                phases: {
+                    skip_research: true,
+                    skip_reassess: true,
+                    skip_slice_research: true,
+                    skip_milestone_validation: true,
+                },
+            };
+        case "balanced":
+            return {
+                models: {
+                    subagent: "claude-sonnet-4-5-20250514",
+                },
+                phases: {
+                    skip_research: true,
+                    skip_reassess: true,
+                    skip_slice_research: true,
+                },
+            };
+        case "quality":
+            return {
+                models: {},
+                phases: {
+                    skip_research: true,
+                    skip_slice_research: true,
+                    skip_reassess: true,
+                },
+            };
+    }
+}
+/**
+ * Resolve the effective token profile from preferences.
+ * Returns "balanced" when no profile is set (D046).
+ */
+export function resolveEffectiveProfile() {
+    const prefs = loadEffectiveGSDPreferences();
+    const profile = prefs?.preferences.token_profile;
+    if (profile && VALID_TOKEN_PROFILES.has(profile))
+        return profile;
+    return "balanced";
+}
+/**
+ * Resolve the inline level from the active token profile.
+ * budget -> minimal, balanced -> standard, quality -> full.
+ */
+export function resolveInlineLevel() {
+    const profile = resolveEffectiveProfile();
+    switch (profile) {
+        case "budget": return "minimal";
+        case "balanced": return "standard";
+        case "quality": return "full";
+    }
+}
+/**
+ * Resolve the compression strategy from the active token profile.
+ * budget/balanced -> "compress", quality -> "truncate".
+ * Explicit preference always wins.
+ */
+export function resolveCompressionStrategy() {
+    const prefs = loadEffectiveGSDPreferences();
+    if (prefs?.preferences.compression_strategy)
+        return prefs.preferences.compression_strategy;
+    const profile = resolveEffectiveProfile();
+    return profile === "quality" ? "truncate" : "compress";
+}
+/**
+ * Resolve the context selection mode from the active token profile.
+ * budget -> "smart", balanced/quality -> "full".
+ * Explicit preference always wins.
+ */
+export function resolveContextSelection() {
+    const prefs = loadEffectiveGSDPreferences();
+    if (prefs?.preferences.context_selection)
+        return prefs.preferences.context_selection;
+    const profile = resolveEffectiveProfile();
+    return profile === "budget" ? "smart" : "full";
+}
+/**
+ * Resolve the search provider preference from preferences.md.
+ * Returns undefined if not configured (caller falls back to existing behavior).
+ */
+export function resolveSearchProviderFromPreferences() {
+    const prefs = loadEffectiveGSDPreferences();
+    return prefs?.preferences.search_provider;
+}

package/dist/resources/extensions/gsd/preferences-skills.js

@@ -0,0 +1,154 @@
+/**
+ * Skill-related preferences: resolution, discovery, and formatting.
+ *
+ * Contains all logic for resolving skill references from preferences
+ * to absolute filesystem paths, plus skill discovery and staleness config.
+ */
+import { existsSync, readdirSync } from "node:fs";
+import { homedir } from "node:os";
+import { isAbsolute, join } from "node:path";
+import { getAgentDir } from "@gsd/pi-coding-agent";
+import { statSync } from "node:fs";
+import { validatePreferences } from "./preferences-validation.js";
+import { loadEffectiveGSDPreferences } from "./preferences.js";
+/**
+ * Known skill directories, in priority order.
+ * User skills (~/.gsd/agent/skills/) take precedence over project skills.
+ */
+export function getSkillSearchDirs(cwd) {
+    return [
+        { dir: join(getAgentDir(), "skills"), method: "user-skill" },
+        { dir: join(cwd, ".pi", "agent", "skills"), method: "project-skill" },
+    ];
+}
+/**
+ * Resolve a single skill reference to an absolute path.
+ *
+ * Resolution order:
+ * 1. Absolute path to a file -> check existsSync
+ * 2. Absolute path to a directory -> check for SKILL.md inside
+ * 3. Bare name -> scan known skill directories for <name>/SKILL.md
+ */
+export function resolveSkillReference(ref, cwd) {
+    const trimmed = ref.trim();
+    // Expand tilde
+    const expanded = trimmed.startsWith("~/")
+        ? join(homedir(), trimmed.slice(2))
+        : trimmed;
+    // Absolute path
+    if (isAbsolute(expanded)) {
+        // Direct file reference
+        if (existsSync(expanded)) {
+            // Check if it's a directory -- look for SKILL.md inside
+            try {
+                const stat = statSync(expanded);
+                if (stat.isDirectory()) {
+                    const skillFile = join(expanded, "SKILL.md");
+                    if (existsSync(skillFile)) {
+                        return { original: ref, resolvedPath: skillFile, method: "absolute-dir" };
+                    }
+                    return { original: ref, resolvedPath: null, method: "unresolved" };
+                }
+            }
+            catch { /* fall through */ }
+            return { original: ref, resolvedPath: expanded, method: "absolute-path" };
+        }
+        // Maybe it's a directory path without SKILL.md suffix
+        const withSkillMd = join(expanded, "SKILL.md");
+        if (existsSync(withSkillMd)) {
+            return { original: ref, resolvedPath: withSkillMd, method: "absolute-dir" };
+        }
+        return { original: ref, resolvedPath: null, method: "unresolved" };
+    }
+    // Bare name -- scan known skill directories
+    for (const { dir, method } of getSkillSearchDirs(cwd)) {
+        if (!existsSync(dir))
+            continue;
+        try {
+            const entries = readdirSync(dir, { withFileTypes: true });
+            for (const entry of entries) {
+                if (!entry.isDirectory() && !entry.isSymbolicLink())
+                    continue;
+                if (entry.name === expanded) {
+                    const skillFile = join(dir, entry.name, "SKILL.md");
+                    if (existsSync(skillFile)) {
+                        return { original: ref, resolvedPath: skillFile, method };
+                    }
+                }
+            }
+        }
+        catch { /* directory not readable -- skip */ }
+    }
+    return { original: ref, resolvedPath: null, method: "unresolved" };
+}
+/**
+ * Resolve all skill references in a preferences object.
+ * Caches resolution per reference string to avoid redundant filesystem scans.
+ */
+export function resolveAllSkillReferences(preferences, cwd) {
+    const validated = validatePreferences(preferences).preferences;
+    preferences = validated;
+    const resolutions = new Map();
+    const warnings = [];
+    function resolve(ref) {
+        const existing = resolutions.get(ref);
+        if (existing)
+            return existing;
+        const result = resolveSkillReference(ref, cwd);
+        resolutions.set(ref, result);
+        if (result.method === "unresolved") {
+            warnings.push(ref);
+        }
+        return result;
+    }
+    // Resolve all skill lists
+    for (const skill of preferences.always_use_skills ?? [])
+        resolve(skill);
+    for (const skill of preferences.prefer_skills ?? [])
+        resolve(skill);
+    for (const skill of preferences.avoid_skills ?? [])
+        resolve(skill);
+    // Resolve skill rules
+    for (const rule of preferences.skill_rules ?? []) {
+        for (const skill of rule.use ?? [])
+            resolve(skill);
+        for (const skill of rule.prefer ?? [])
+            resolve(skill);
+        for (const skill of rule.avoid ?? [])
+            resolve(skill);
+    }
+    return { resolutions, warnings };
+}
+/**
+ * Format a skill reference for the system prompt.
+ * If resolved, shows the path so the agent knows exactly where to read.
+ * If unresolved, marks it clearly.
+ */
+export function formatSkillRef(ref, resolutions) {
+    const resolution = resolutions.get(ref);
+    if (!resolution || resolution.method === "unresolved") {
+        return `${ref} (⚠ not found — check skill name or path)`;
+    }
+    // For absolute paths where SKILL.md is just appended, don't clutter the output
+    if (resolution.method === "absolute-path" || resolution.method === "absolute-dir") {
+        return ref;
+    }
+    // For bare names resolved from skill directories, show the resolved path
+    return `${ref} → \`${resolution.resolvedPath}\``;
+}
+/**
+ * Resolve the skill discovery mode from effective preferences.
+ * Defaults to "suggest" -- skills are identified during research but not installed automatically.
+ */
+export function resolveSkillDiscoveryMode() {
+    const prefs = loadEffectiveGSDPreferences();
+    return prefs?.preferences.skill_discovery ?? "suggest";
+}
+/**
+ * Resolve the skill staleness threshold in days.
+ * Returns 0 if disabled, default 60 if not configured.
+ */
+export function resolveSkillStalenessDays() {
+    const prefs = loadEffectiveGSDPreferences();
+    return prefs?.preferences.skill_staleness_days ?? 60;
+}

package/dist/resources/extensions/gsd/preferences-types.js

@@ -0,0 +1,73 @@
+/**
+ * Type definitions, constants, and configuration shapes for GSD preferences.
+ *
+ * All interfaces, type aliases, and static lookup tables live here so that
+ * both the validation and runtime modules can import them without pulling
+ * in filesystem or loading logic.
+ */
+/** Default preference values for each workflow mode. */
+export const MODE_DEFAULTS = {
+    solo: {
+        git: {
+            auto_push: true,
+            push_branches: false,
+            pre_merge_check: false,
+            merge_strategy: "squash",
+            isolation: "worktree",
+        },
+        unique_milestone_ids: false,
+    },
+    team: {
+        git: {
+            auto_push: false,
+            push_branches: true,
+            pre_merge_check: true,
+            merge_strategy: "squash",
+            isolation: "worktree",
+        },
+        unique_milestone_ids: true,
+    },
+};
+/** All recognized top-level keys in GSDPreferences. Used to detect typos / stale config. */
+export const KNOWN_PREFERENCE_KEYS = new Set([
+    "version",
+    "mode",
+    "always_use_skills",
+    "prefer_skills",
+    "avoid_skills",
+    "skill_rules",
+    "custom_instructions",
+    "models",
+    "skill_discovery",
+    "skill_staleness_days",
+    "auto_supervisor",
+    "uat_dispatch",
+    "unique_milestone_ids",
+    "budget_ceiling",
+    "budget_enforcement",
+    "context_pause_threshold",
+    "notifications",
+    "remote_questions",
+    "git",
+    "post_unit_hooks",
+    "pre_dispatch_hooks",
+    "dynamic_routing",
+    "token_profile",
+    "phases",
+    "auto_visualize",
+    "auto_report",
+    "parallel",
+    "verification_commands",
+    "verification_auto_fix",
+    "verification_max_retries",
+    "search_provider",
+    "compression_strategy",
+    "context_selection",
+]);
+/** Canonical list of all dispatch unit types. */
+export const KNOWN_UNIT_TYPES = [
+    "research-milestone", "plan-milestone", "research-slice", "plan-slice",
+    "execute-task", "complete-slice", "replan-slice", "reassess-roadmap",
+    "run-uat", "complete-milestone",
+];
+export const SKILL_ACTIONS = new Set(["use", "prefer", "avoid"]);