gsd-pi 2.33.0-dev.bafba33 → 2.33.1-dev.235d83a

package/dist/resources/extensions/gsd/roadmap-slices.ts

@@ -1,149 +0,0 @@
-import type { RoadmapSliceEntry, RiskLevel } from "./types.js";
-
-/**
- * Expand dependency shorthand into individual slice IDs.
- *
- * Handles two common LLM-generated patterns that the roadmap parser
- * previously treated as single literal IDs (silently blocking slices):
- *
- *   "S01-S04"  → ["S01", "S02", "S03", "S04"]  (range syntax)
- *   "S01..S04" → ["S01", "S02", "S03", "S04"]  (dot-range syntax)
- *
- * Plain IDs ("S01", "S02") and empty strings pass through unchanged.
- */
-export function expandDependencies(deps: string[]): string[] {
-  const result: string[] = [];
-  for (const dep of deps) {
-    const trimmed = dep.trim();
-    if (!trimmed) continue;
-
-    // Match range syntax: S01-S04 or S01..S04 (case-insensitive prefix)
-    const rangeMatch = trimmed.match(/^([A-Za-z]+)(\d+)(?:-|\.\.)+([A-Za-z]+)(\d+)$/);
-    if (rangeMatch) {
-      const prefixA = rangeMatch[1]!.toUpperCase();
-      const startNum = parseInt(rangeMatch[2]!, 10);
-      const prefixB = rangeMatch[3]!.toUpperCase();
-      const endNum = parseInt(rangeMatch[4]!, 10);
-
-      // Only expand when both prefixes match and range is valid
-      if (prefixA === prefixB && startNum <= endNum) {
-        const width = rangeMatch[2]!.length; // preserve zero-padding (S01 not S1)
-        for (let i = startNum; i <= endNum; i++) {
-          result.push(`${prefixA}${String(i).padStart(width, "0")}`);
-        }
-        continue;
-      }
-    }
-
-    result.push(trimmed);
-  }
-  return result;
-}
-
-function extractSlicesSection(content: string): string {
-  const headingMatch = /^## Slices\b.*$/m.exec(content);
-  if (!headingMatch || headingMatch.index == null) return "";
-
-  const start = headingMatch.index + headingMatch[0].length;
-  const rest = content.slice(start).replace(/^\r?\n/, "");
-  const nextHeading = /^##\s+/m.exec(rest);
-  return (nextHeading ? rest.slice(0, nextHeading.index) : rest).trimEnd();
-}
-
-export function parseRoadmapSlices(content: string): RoadmapSliceEntry[] {
-  const slicesSection = extractSlicesSection(content);
-  const slices: RoadmapSliceEntry[] = [];
-  if (!slicesSection) {
-    // Fallback: detect prose-style slice headers (## Slice S01: Title)
-    // when the LLM writes freeform prose instead of the ## Slices checklist.
-    // This prevents a permanent "No slice eligible" block (#807).
-    return parseProseSliceHeaders(content);
-  }
-
-  const checkboxItems = slicesSection.split("\n");
-  let currentSlice: RoadmapSliceEntry | null = null;
-
-  for (const line of checkboxItems) {
-    const cbMatch = line.match(/^\s*-\s+\[([ xX])\]\s+\*\*([\w.]+):\s+(.+?)\*\*\s*(.*)/);
-    if (cbMatch) {
-      if (currentSlice) slices.push(currentSlice);
-
-      const done = cbMatch[1].toLowerCase() === "x";
-      const id = cbMatch[2]!;
-      const title = cbMatch[3]!;
-      const rest = cbMatch[4] ?? "";
-
-      const riskMatch = rest.match(/`risk:(\w+)`/);
-      const risk = (riskMatch ? riskMatch[1] : "low") as RiskLevel;
-
-      const depsMatch = rest.match(/`depends:\[([^\]]*)\]`/);
-      const depends = depsMatch && depsMatch[1]!.trim()
-        ? expandDependencies(depsMatch[1]!.split(",").map(s => s.trim()))
-        : [];
-
-      currentSlice = { id, title, risk, depends, done, demo: "" };
-      continue;
-    }
-
-    if (currentSlice && line.trim().startsWith(">")) {
-      currentSlice.demo = line.trim().replace(/^>\s*/, "").replace(/^After this:\s*/i, "");
-    }
-  }
-
-  if (currentSlice) slices.push(currentSlice);
-  return slices;
-}
-
-/**
- * Fallback parser for prose-style roadmaps where the LLM wrote
- * slice headers instead of the machine-readable `## Slices` checklist.
- * Extracts slice IDs and titles so auto-mode can at least identify
- * slices and plan them.
- *
- * Handles these LLM-generated variants:
- *   ## S01: Title           (H2, colon separator)
- *   ### S01: Title          (H3)
- *   #### S01: Title         (H4)
- *   ## Slice S01: Title     (with "Slice" prefix)
- *   ## S01 — Title          (em dash)
- *   ## S01 – Title          (en dash)
- *   ## S01 - Title          (hyphen)
- *   ## S01. Title           (dot separator)
- *   ## S01 Title            (space only, no separator)
- *   ## **S01: Title**       (bold-wrapped)
- *   ## **S01**: Title       (bold ID only)
- *   ## S1: Title            (non-zero-padded ID)
- */
-function parseProseSliceHeaders(content: string): RoadmapSliceEntry[] {
-  const slices: RoadmapSliceEntry[] = [];
-  // Match H1–H4 headers containing S<digits> with optional "Slice" prefix and bold markers.
-  // Separator after the ID is flexible: colon, dash, em/en dash, dot, or just whitespace.
-  const headerPattern = /^#{1,4}\s+\*{0,2}(?:Slice\s+)?(S\d+)\*{0,2}[:\s.—–-]*\s*(.+)/gm;
-  let match: RegExpExecArray | null;
-
-  while ((match = headerPattern.exec(content)) !== null) {
-    const id = match[1]!;
-    let title = match[2]!.trim().replace(/\*{1,2}$/g, "").trim(); // strip trailing bold markers
-    if (!title) continue; // skip if we only matched the ID with no title
-
-    // Try to extract depends from prose: "Depends on: S01" or "**Depends on:** S01, S02"
-    const afterHeader = content.slice(match.index + match[0].length);
-    const nextHeader = afterHeader.search(/^#{1,4}\s/m);
-    const section = nextHeader !== -1 ? afterHeader.slice(0, nextHeader) : afterHeader.slice(0, 500);
-
-    const depsMatch = section.match(/\*{0,2}Depends\s+on:?\*{0,2}\s*(.+)/i);
-    let depends: string[] = [];
-    if (depsMatch) {
-      const rawDeps = depsMatch[1]!.replace(/none/i, "").trim();
-      if (rawDeps) {
-        depends = expandDependencies(
-          rawDeps.split(/[,;]/).map(s => s.trim().replace(/[^A-Za-z0-9]/g, "")).filter(Boolean)
-        );
-      }
-    }
-
-    slices.push({ id, title, risk: "medium" as RiskLevel, depends, done: false, demo: "" });
-  }
-
-  return slices;
-}

package/dist/resources/extensions/gsd/routing-history.ts

@@ -1,286 +0,0 @@
-// GSD Extension — Routing History (Adaptive Learning)
-// Tracks success/failure per tier per unit-type pattern to improve
-// classification accuracy over time.
-
-import { join } from "node:path";
-import { gsdRoot } from "./paths.js";
-import type { ComplexityTier } from "./types.js";
-import { loadJsonFile, saveJsonFile } from "./json-persistence.js";
-
-// ─── Types ───────────────────────────────────────────────────────────────────
-
-export interface TierOutcome {
-  success: number;
-  fail: number;
-}
-
-export interface PatternHistory {
-  light: TierOutcome;
-  standard: TierOutcome;
-  heavy: TierOutcome;
-}
-
-export interface RoutingHistoryData {
-  version: 1;
-  /** Keyed by pattern string, e.g. "execute-task:docs" or "complete-slice" */
-  patterns: Record<string, PatternHistory>;
-  /** User feedback entries (from /gsd:rate-unit) */
-  feedback: FeedbackEntry[];
-  /** Last updated timestamp */
-  updatedAt: string;
-}
-
-export interface FeedbackEntry {
-  unitType: string;
-  unitId: string;
-  tier: ComplexityTier;
-  rating: "over" | "under" | "ok";
-  timestamp: string;
-}
-
-// ─── Constants ───────────────────────────────────────────────────────────────
-
-const HISTORY_FILE = "routing-history.json";
-const ROLLING_WINDOW = 50;        // only consider last N entries per pattern
-const FAILURE_THRESHOLD = 0.20;   // >20% failure rate triggers tier bump
-const FEEDBACK_WEIGHT = 2;        // feedback signals count 2x vs automatic
-
-// ─── In-Memory State ─────────────────────────────────────────────────────────
-
-let history: RoutingHistoryData | null = null;
-let historyBasePath = "";
-
-// ─── Public API ──────────────────────────────────────────────────────────────
-
-/**
- * Initialize routing history for a project.
- */
-export function initRoutingHistory(base: string): void {
-  historyBasePath = base;
-  history = loadHistory(base);
-}
-
-/**
- * Reset routing history state.
- */
-export function resetRoutingHistory(): void {
-  history = null;
-  historyBasePath = "";
-}
-
-/**
- * Record the outcome of a unit dispatch.
- *
- * @param unitType  The unit type (e.g. "execute-task")
- * @param tier      The tier that was used
- * @param success   Whether the unit completed successfully
- * @param tags      Optional tags from task metadata (e.g. ["docs", "test"])
- */
-export function recordOutcome(
-  unitType: string,
-  tier: ComplexityTier,
-  success: boolean,
-  tags?: string[],
-): void {
-  if (!history) return;
-
-  // Record for the base unit type
-  const basePattern = unitType;
-  ensurePattern(basePattern);
-  const outcome = history.patterns[basePattern][tier];
-  if (success) outcome.success++;
-  else outcome.fail++;
-
-  // Record for tag-specific patterns (e.g. "execute-task:docs")
-  if (tags && tags.length > 0) {
-    for (const tag of tags) {
-      const tagPattern = `${unitType}:${tag}`;
-      ensurePattern(tagPattern);
-      const tagOutcome = history.patterns[tagPattern][tier];
-      if (success) tagOutcome.success++;
-      else tagOutcome.fail++;
-    }
-  }
-
-  // Apply rolling window — cap total entries per tier per pattern
-  for (const pattern of Object.keys(history.patterns)) {
-    const p = history.patterns[pattern];
-    for (const t of ["light", "standard", "heavy"] as const) {
-      const total = p[t].success + p[t].fail;
-      if (total > ROLLING_WINDOW) {
-        const scale = ROLLING_WINDOW / total;
-        p[t].success = Math.round(p[t].success * scale);
-        p[t].fail = Math.round(p[t].fail * scale);
-      }
-    }
-  }
-
-  history.updatedAt = new Date().toISOString();
-  saveHistory(historyBasePath, history);
-}
-
-/**
- * Record user feedback for the last completed unit.
- */
-export function recordFeedback(
-  unitType: string,
-  unitId: string,
-  tier: ComplexityTier,
-  rating: "over" | "under" | "ok",
-): void {
-  if (!history) return;
-
-  history.feedback.push({
-    unitType,
-    unitId,
-    tier,
-    rating,
-    timestamp: new Date().toISOString(),
-  });
-
-  // Cap feedback array at 200 entries
-  if (history.feedback.length > 200) {
-    history.feedback = history.feedback.slice(-200);
-  }
-
-  // Apply feedback as weighted outcome
-  const pattern = unitType;
-  ensurePattern(pattern);
-
-  if (rating === "over") {
-    // User says this could have used a simpler model → record as success at current tier
-    // and also as success at one tier lower (encourages more downgrading)
-    const lower = tierBelow(tier);
-    if (lower) {
-      const outcomes = history.patterns[pattern][lower];
-      outcomes.success += FEEDBACK_WEIGHT;
-    }
-  } else if (rating === "under") {
-    // User says this needed a better model → record as failure at current tier
-    const outcomes = history.patterns[pattern][tier];
-    outcomes.fail += FEEDBACK_WEIGHT;
-  }
-  // "ok" = no adjustment needed
-
-  history.updatedAt = new Date().toISOString();
-  saveHistory(historyBasePath, history);
-}
-
-/**
- * Get the recommended tier adjustment for a given pattern.
- * Returns the tier to bump to if the failure rate exceeds threshold,
- * or null if no adjustment is needed.
- */
-export function getAdaptiveTierAdjustment(
-  unitType: string,
-  currentTier: ComplexityTier,
-  tags?: string[],
-): ComplexityTier | null {
-  if (!history) return null;
-
-  // Check tag-specific patterns first (more specific)
-  if (tags && tags.length > 0) {
-    for (const tag of tags) {
-      const tagPattern = `${unitType}:${tag}`;
-      const adjustment = checkPatternFailureRate(tagPattern, currentTier);
-      if (adjustment) return adjustment;
-    }
-  }
-
-  // Fall back to base pattern
-  return checkPatternFailureRate(unitType, currentTier);
-}
-
-/**
- * Clear all routing history (user-triggered reset).
- */
-export function clearRoutingHistory(base: string): void {
-  history = createEmptyHistory();
-  saveHistory(base, history);
-}
-
-/**
- * Get current history data (for display/debugging).
- */
-export function getRoutingHistory(): RoutingHistoryData | null {
-  return history;
-}
-
-// ─── Internal ────────────────────────────────────────────────────────────────
-
-function checkPatternFailureRate(
-  pattern: string,
-  tier: ComplexityTier,
-): ComplexityTier | null {
-  if (!history?.patterns[pattern]) return null;
-
-  const outcomes = history.patterns[pattern][tier];
-  const total = outcomes.success + outcomes.fail;
-  if (total < 3) return null; // Not enough data
-
-  const failureRate = outcomes.fail / total;
-  if (failureRate > FAILURE_THRESHOLD) {
-    // Bump to next tier
-    return tierAbove(tier);
-  }
-
-  return null;
-}
-
-function tierAbove(tier: ComplexityTier): ComplexityTier | null {
-  switch (tier) {
-    case "light": return "standard";
-    case "standard": return "heavy";
-    case "heavy": return null;
-  }
-}
-
-function tierBelow(tier: ComplexityTier): ComplexityTier | null {
-  switch (tier) {
-    case "light": return null;
-    case "standard": return "light";
-    case "heavy": return "standard";
-  }
-}
-
-function ensurePattern(pattern: string): void {
-  if (!history) return;
-  if (!history.patterns[pattern]) {
-    history.patterns[pattern] = {
-      light: { success: 0, fail: 0 },
-      standard: { success: 0, fail: 0 },
-      heavy: { success: 0, fail: 0 },
-    };
-  }
-}
-
-function createEmptyHistory(): RoutingHistoryData {
-  return {
-    version: 1,
-    patterns: {},
-    feedback: [],
-    updatedAt: new Date().toISOString(),
-  };
-}
-
-function historyPath(base: string): string {
-  return join(gsdRoot(base), HISTORY_FILE);
-}
-
-function isRoutingHistoryData(data: unknown): data is RoutingHistoryData {
-  return (
-    typeof data === "object" &&
-    data !== null &&
-    (data as RoutingHistoryData).version === 1 &&
-    typeof (data as RoutingHistoryData).patterns === "object" &&
-    (data as RoutingHistoryData).patterns !== null
-  );
-}
-
-function loadHistory(base: string): RoutingHistoryData {
-  return loadJsonFile(historyPath(base), isRoutingHistoryData, createEmptyHistory);
-}
-
-function saveHistory(base: string, data: RoutingHistoryData): void {
-  saveJsonFile(historyPath(base), data);
-}

package/dist/resources/extensions/gsd/safe-fs.ts

@@ -1,47 +0,0 @@
-import { existsSync, mkdirSync, cpSync, type CopySyncOptions } from "node:fs"
-import { dirname } from "node:path"
-
-/**
- * Safely creates a directory. Returns true if successful, false on error.
- * Logs to stderr when GSD_DEBUG is set.
- */
-export function safeMkdir(dirPath: string): boolean {
-  try {
-    mkdirSync(dirPath, { recursive: true })
-    return true
-  } catch (err) {
-    if (process.env.GSD_DEBUG) console.error(`[gsd] mkdir failed: ${dirPath}`, err)
-    return false
-  }
-}
-
-/**
- * Safely copies src to dst. Returns true if successful, false if src doesn't exist or copy fails.
- * Logs to stderr when GSD_DEBUG is set.
- */
-export function safeCopy(src: string, dst: string, opts?: CopySyncOptions): boolean {
-  if (!existsSync(src)) return false
-  try {
-    cpSync(src, dst, opts)
-    return true
-  } catch (err) {
-    if (process.env.GSD_DEBUG) console.error(`[gsd] copy failed: ${src} → ${dst}`, err)
-    return false
-  }
-}
-
-/**
- * Safely copies a directory recursively, creating the parent of dst if needed.
- * Returns true if successful.
- */
-export function safeCopyRecursive(src: string, dst: string, opts?: Omit<CopySyncOptions, 'recursive'>): boolean {
-  if (!existsSync(src)) return false
-  try {
-    mkdirSync(dirname(dst), { recursive: true })
-    cpSync(src, dst, { ...opts, recursive: true })
-    return true
-  } catch (err) {
-    if (process.env.GSD_DEBUG) console.error(`[gsd] recursive copy failed: ${src} → ${dst}`, err)
-    return false
-  }
-}