gsd-pi 2.33.1 → 2.34.0-dev.6769913

package/dist/resources/extensions/gsd/prompt-ordering.ts

@@ -1,200 +0,0 @@
-/**
- * Prompt Ordering Optimizer — reorders assembled prompt sections
- * to maximize cache prefix stability.
- *
- * Identifies sections by markdown heading patterns and rearranges
- * them so stable content appears first. Anthropic caches the last
- * user message by prefix match, so placing static/semi-static
- * content before dynamic content improves cache hit rates.
- */
-
-/** Section extracted from a prompt by heading markers */
-export interface ExtractedSection {
-  heading: string;
-  content: string;
-  role: "static" | "semi-static" | "dynamic";
-}
-
-/**
- * Known heading to role mappings for GSD prompts.
- * Static: templates, executor constraints, system instructions
- * Semi-static: slice plan, decisions, requirements, prior summaries, overrides
- * Dynamic: task plan, resume state, carry-forward, verification
- */
-const HEADING_ROLES: Record<string, "static" | "semi-static" | "dynamic"> = {
-  // Static — never changes per task
-  "Output Template": "static",
-  "Executor Context Constraints": "static",
-  "Working Directory": "static",
-  "Backing Source Artifacts": "static",
-
-  // Semi-static — changes per slice but not per task
-  "Slice Plan Excerpt": "semi-static",
-  "Decisions": "semi-static",
-  "Requirements": "semi-static",
-  "Prior Task Summaries": "semi-static",
-  "Overrides": "semi-static",
-  "Project Knowledge": "semi-static",
-  "Dependency Summaries": "semi-static",
-
-  // Dynamic — changes per task
-  "Inlined Task Plan": "dynamic",
-  "Resume State": "dynamic",
-  "Carry-Forward Context": "dynamic",
-  "Verification": "dynamic",
-  "Verification Evidence": "dynamic",
-};
-
-/**
- * Extract the heading text from a line like "## Some Heading" or "## UNIT: Execute Task ...".
- * Returns the full text after "## " for role lookup.
- */
-function extractHeadingText(line: string): string {
-  return line.replace(/^##\s+/, "").trim();
-}
-
-/**
- * Classify a heading by matching against known roles.
- * Uses substring matching so headings like "## UNIT: Execute Task T1.1" don't match
- * but "## Inlined Task Plan" does. Unknown headings default to "dynamic".
- */
-function classifyHeading(heading: string): "static" | "semi-static" | "dynamic" {
-  for (const [key, role] of Object.entries(HEADING_ROLES)) {
-    if (heading === key || heading.startsWith(key)) {
-      return role;
-    }
-  }
-  return "dynamic";
-}
-
-/**
- * Split a prompt into sections at ## heading boundaries.
- * Sub-headings (### and deeper) stay with their parent ## section.
- * Returns a preamble (content before first ##) and an array of sections.
- */
-function splitSections(prompt: string): { preamble: string; sections: ExtractedSection[] } {
-  const lines = prompt.split("\n");
-  let preamble = "";
-  const sections: ExtractedSection[] = [];
-  let currentHeading = "";
-  let currentContent: string[] = [];
-
-  for (const line of lines) {
-    // Match ## headings but NOT ### or deeper
-    if (/^## (?!#)/.test(line)) {
-      // Flush previous section
-      if (currentHeading) {
-        sections.push({
-          heading: currentHeading,
-          content: currentContent.join("\n"),
-          role: classifyHeading(currentHeading),
-        });
-      } else if (currentContent.length > 0) {
-        preamble = currentContent.join("\n");
-      }
-      currentHeading = extractHeadingText(line);
-      currentContent = [line];
-    } else {
-      currentContent.push(line);
-    }
-  }
-
-  // Flush last section
-  if (currentHeading) {
-    sections.push({
-      heading: currentHeading,
-      content: currentContent.join("\n"),
-      role: classifyHeading(currentHeading),
-    });
-  } else if (currentContent.length > 0) {
-    preamble = currentContent.join("\n");
-  }
-
-  return { preamble, sections };
-}
-
-const ROLE_ORDER: Record<string, number> = {
-  "static": 0,
-  "semi-static": 1,
-  "dynamic": 2,
-};
-
-/**
- * Reorder a prompt's sections for cache efficiency.
- * Extracts sections by ## heading markers, classifies them,
- * and reorders: static -> semi-static -> dynamic.
- *
- * Content before the first ## heading is treated as a preamble
- * and always placed first (it's usually static instructions).
- *
- * @param prompt The assembled prompt string
- * @returns Reordered prompt string
- */
-export function reorderForCaching(prompt: string): string {
-  const { preamble, sections } = splitSections(prompt);
-
-  // Nothing to reorder
-  if (sections.length <= 1) {
-    return prompt;
-  }
-
-  // Stable sort: sections with the same role keep their original relative order
-  const sorted = [...sections].sort((a, b) => {
-    return ROLE_ORDER[a.role] - ROLE_ORDER[b.role];
-  });
-
-  const parts: string[] = [];
-  if (preamble) {
-    parts.push(preamble);
-  }
-  for (const section of sorted) {
-    parts.push(section.content);
-  }
-
-  return parts.join("\n");
-}
-
-/**
- * Analyze a prompt's cache efficiency without reordering.
- * Returns stats about how much of the prompt is cacheable.
- */
-export function analyzeCacheEfficiency(prompt: string): {
-  totalChars: number;
-  staticChars: number;
-  semiStaticChars: number;
-  dynamicChars: number;
-  cacheEfficiency: number;
-} {
-  const { preamble, sections } = splitSections(prompt);
-
-  let staticChars = preamble.length;
-  let semiStaticChars = 0;
-  let dynamicChars = 0;
-
-  for (const section of sections) {
-    switch (section.role) {
-      case "static":
-        staticChars += section.content.length;
-        break;
-      case "semi-static":
-        semiStaticChars += section.content.length;
-        break;
-      case "dynamic":
-        dynamicChars += section.content.length;
-        break;
-    }
-  }
-
-  const totalChars = staticChars + semiStaticChars + dynamicChars;
-  const cacheEfficiency = totalChars > 0
-    ? (staticChars + semiStaticChars) / totalChars
-    : 0;
-
-  return {
-    totalChars,
-    staticChars,
-    semiStaticChars,
-    dynamicChars,
-    cacheEfficiency,
-  };
-}

package/dist/resources/extensions/gsd/provider-error-pause.ts

@@ -1,88 +0,0 @@
-export type ProviderErrorPauseUI = {
-  notify(message: string, level?: "info" | "warning" | "error" | "success"): void;
-};
-
-/**
- * Classify a provider error as transient (auto-resume) or permanent (manual resume).
- *
- * Transient: rate limits, server errors (500/502/503), overloaded, internal errors.
- * These are expected to self-resolve and should auto-resume after a delay.
- *
- * Permanent: auth errors, invalid API key, billing issues.
- * These require user intervention and should pause indefinitely.
- */
-export function classifyProviderError(errorMsg: string): {
-  isTransient: boolean;
-  isRateLimit: boolean;
-  suggestedDelayMs: number;
-} {
-  const isRateLimit = /rate.?limit|too many requests|429/i.test(errorMsg);
-  const isServerError = /internal server error|500|502|503|overloaded|server_error|api_error|service.?unavailable/i.test(errorMsg);
-
-  // Permanent errors — never auto-resume
-  const isPermanent = /auth|unauthorized|forbidden|invalid.*key|invalid.*api|billing|quota exceeded|account/i.test(errorMsg);
-
-  if (isPermanent && !isRateLimit) {
-    return { isTransient: false, isRateLimit: false, suggestedDelayMs: 0 };
-  }
-
-  if (isRateLimit) {
-    // Try to extract retry-after from the message
-    const resetMatch = errorMsg.match(/reset in (\d+)s/i);
-    const delayMs = resetMatch ? Number(resetMatch[1]) * 1000 : 60_000; // default 60s for rate limits
-    return { isTransient: true, isRateLimit: true, suggestedDelayMs: delayMs };
-  }
-
-  if (isServerError) {
-    return { isTransient: true, isRateLimit: false, suggestedDelayMs: 30_000 }; // 30s for server errors
-  }
-
-  // Unknown error — treat as permanent (user reviews)
-  return { isTransient: false, isRateLimit: false, suggestedDelayMs: 0 };
-}
-
-/**
- * Pause auto-mode due to a provider error.
- *
- * For transient errors (rate limits, server errors, overloaded), schedules
- * an automatic resume after a delay. For permanent errors (auth, billing),
- * pauses indefinitely — user must manually resume.
- */
-export async function pauseAutoForProviderError(
-  ui: ProviderErrorPauseUI,
-  errorDetail: string,
-  pause: () => Promise<void>,
-  options?: {
-    isRateLimit?: boolean;
-    isTransient?: boolean;
-    retryAfterMs?: number;
-    resume?: () => void;
-  },
-): Promise<void> {
-  const shouldAutoResume = (options?.isRateLimit || options?.isTransient)
-    && options.retryAfterMs
-    && options.retryAfterMs > 0
-    && options.resume;
-
-  if (shouldAutoResume) {
-    const delaySec = Math.ceil(options!.retryAfterMs! / 1000);
-    const reason = options!.isRateLimit ? "Rate limited" : "Server error (transient)";
-    ui.notify(
-      `${reason}${errorDetail}. Auto-resuming in ${delaySec}s...`,
-      "warning",
-    );
-    await pause();
-
-    // Schedule auto-resume after the delay
-    setTimeout(() => {
-      const resumeMsg = options!.isRateLimit
-        ? "Rate limit window elapsed. Resuming auto-mode."
-        : "Server error recovery delay elapsed. Resuming auto-mode.";
-      ui.notify(resumeMsg, "info");
-      options!.resume!();
-    }, options!.retryAfterMs!);
-  } else {
-    ui.notify(`Auto-mode paused due to provider error${errorDetail}`, "warning");
-    await pause();
-  }
-}

package/dist/resources/extensions/gsd/queue-order.ts

@@ -1,230 +0,0 @@
-/**
- * GSD Queue Order — Custom milestone execution ordering.
- *
- * Stores an explicit execution order in `.gsd/QUEUE-ORDER.json`.
- * When present, `findMilestoneIds()` uses this order instead of
- * the default numeric sort (milestoneIdSort).
- *
- * The file is committed to git (not gitignored) so ordering
- * survives branch switches and is shared across sessions.
- */
-
-import { join } from "node:path";
-import { gsdRoot } from "./paths.js";
-import { milestoneIdSort } from "./milestone-ids.js";
-import { loadJsonFileOrNull, saveJsonFile } from "./json-persistence.js";
-
-// ─── Types ───────────────────────────────────────────────────────────────────
-
-interface QueueOrderFile {
-  order: string[];
-  updatedAt: string;
-}
-
-export interface DependencyViolation {
-  milestone: string;
-  dependsOn: string;
-  type: 'would_block' | 'circular' | 'missing_dep';
-  message: string;
-}
-
-export interface DependencyRedundancy {
-  milestone: string;
-  dependsOn: string;
-}
-
-export interface DependencyValidation {
-  valid: boolean;
-  violations: DependencyViolation[];
-  redundant: DependencyRedundancy[];
-}
-
-// ─── Path ────────────────────────────────────────────────────────────────────
-
-function queueOrderPath(basePath: string): string {
-  return join(gsdRoot(basePath), "QUEUE-ORDER.json");
-}
-
-// ─── Type Guards ─────────────────────────────────────────────────────────────
-
-function isQueueOrderFile(data: unknown): data is QueueOrderFile {
-  return data !== null && typeof data === "object" && "order" in data! && Array.isArray((data as QueueOrderFile).order);
-}
-
-// ─── Read / Write ────────────────────────────────────────────────────────────
-
-/**
- * Load the custom queue order. Returns null if no file exists or if
- * the file is corrupt/unreadable.
- */
-export function loadQueueOrder(basePath: string): string[] | null {
-  const data = loadJsonFileOrNull(queueOrderPath(basePath), isQueueOrderFile);
-  return data?.order ?? null;
-}
-
-/**
- * Save a custom queue order to disk.
- */
-export function saveQueueOrder(basePath: string, order: string[]): void {
-  const data: QueueOrderFile = {
-    order,
-    updatedAt: new Date().toISOString(),
-  };
-  saveJsonFile(queueOrderPath(basePath), data);
-}
-
-// ─── Sorting ─────────────────────────────────────────────────────────────────
-
-/**
- * Sort milestone IDs respecting a custom order.
- *
- * - IDs present in `customOrder` appear in that exact sequence.
- * - IDs on disk but NOT in `customOrder` are appended at the end,
- *   sorted by the default `milestoneIdSort` (numeric).
- * - IDs in `customOrder` but NOT on disk are silently skipped.
- * - When `customOrder` is null, falls back to `milestoneIdSort`.
- */
-export function sortByQueueOrder(ids: string[], customOrder: string[] | null): string[] {
-  if (!customOrder) return [...ids].sort(milestoneIdSort);
-
-  const idSet = new Set(ids);
-  const ordered: string[] = [];
-
-  // First: IDs from customOrder that exist on disk
-  for (const id of customOrder) {
-    if (idSet.has(id)) {
-      ordered.push(id);
-      idSet.delete(id);
-    }
-  }
-
-  // Then: remaining IDs not in customOrder, in default sort order
-  const remaining = [...idSet].sort(milestoneIdSort);
-  return [...ordered, ...remaining];
-}
-
-// ─── Pruning ─────────────────────────────────────────────────────────────────
-
-/**
- * Remove IDs from the queue order file that are no longer valid
- * (completed or deleted milestones). No-op if file doesn't exist.
- */
-export function pruneQueueOrder(basePath: string, validIds: string[]): void {
-  const order = loadQueueOrder(basePath);
-  if (!order) return;
-
-  const validSet = new Set(validIds);
-  const pruned = order.filter(id => validSet.has(id));
-
-  if (pruned.length !== order.length) {
-    saveQueueOrder(basePath, pruned);
-  }
-}
-
-// ─── Validation ──────────────────────────────────────────────────────────────
-
-/**
- * Validate a proposed queue order against dependency constraints.
- *
- * Checks:
- * - would_block: A milestone is placed before one of its dependencies
- * - circular: Two or more milestones form a dependency cycle
- * - missing_dep: A milestone depends on an ID that doesn't exist
- * - redundant: A dependency is satisfied by queue position (dep comes earlier)
- */
-export function validateQueueOrder(
-  order: string[],
-  depsMap: Map<string, string[]>,
-  completedIds: Set<string>,
-): DependencyValidation {
-  const violations: DependencyViolation[] = [];
-  const redundant: DependencyRedundancy[] = [];
-
-  const positionMap = new Map<string, number>();
-  for (let i = 0; i < order.length; i++) {
-    positionMap.set(order[i], i);
-  }
-
-  const allKnownIds = new Set([...order, ...completedIds]);
-
-  for (const [mid, deps] of depsMap) {
-    const midPos = positionMap.get(mid);
-    if (midPos === undefined) continue; // not in pending order
-
-    for (const dep of deps) {
-      // Dep already completed — always satisfied
-      if (completedIds.has(dep)) continue;
-
-      // Dep doesn't exist anywhere
-      if (!allKnownIds.has(dep)) {
-        violations.push({
-          milestone: mid,
-          dependsOn: dep,
-          type: 'missing_dep',
-          message: `${mid} depends on ${dep}, but ${dep} does not exist.`,
-        });
-        continue;
-      }
-
-      const depPos = positionMap.get(dep);
-      if (depPos === undefined) continue; // dep not in pending order (edge case)
-
-      if (depPos > midPos) {
-        // Dep comes AFTER this milestone in the order — violation
-        violations.push({
-          milestone: mid,
-          dependsOn: dep,
-          type: 'would_block',
-          message: `${mid} cannot run before ${dep} — ${mid} depends_on: [${dep}].`,
-        });
-      } else {
-        // Dep comes before — satisfied by position, redundant
-        redundant.push({ milestone: mid, dependsOn: dep });
-      }
-    }
-  }
-
-  // Check for circular dependencies
-  const visited = new Set<string>();
-  const inStack = new Set<string>();
-
-  function hasCycle(node: string, path: string[]): string[] | null {
-    if (inStack.has(node)) return [...path, node];
-    if (visited.has(node)) return null;
-
-    visited.add(node);
-    inStack.add(node);
-
-    const deps = depsMap.get(node) ?? [];
-    for (const dep of deps) {
-      if (completedIds.has(dep)) continue;
-      const cycle = hasCycle(dep, [...path, node]);
-      if (cycle) return cycle;
-    }
-
-    inStack.delete(node);
-    return null;
-  }
-
-  for (const mid of order) {
-    if (!visited.has(mid)) {
-      const cycle = hasCycle(mid, []);
-      if (cycle) {
-        const cycleStr = cycle.join(' → ');
-        violations.push({
-          milestone: cycle[0],
-          dependsOn: cycle[cycle.length - 2],
-          type: 'circular',
-          message: `Circular dependency: ${cycleStr}`,
-        });
-        break; // one cycle report is enough
-      }
-    }
-  }
-
-  return {
-    valid: violations.length === 0,
-    violations,
-    redundant,
-  };
-}