selftune 0.1.4 → 0.2.0

package/cli/selftune/utils/llm-call.ts

@@ -12,6 +12,24 @@ import { join } from "node:path";
 
 import { AGENT_CANDIDATES } from "../constants.js";
 
+// ---------------------------------------------------------------------------
+// Model alias resolution
+// ---------------------------------------------------------------------------
+
+/**
+ * The claude CLI --model flag only accepts "sonnet" and "opus" as aliases.
+ * "haiku" is NOT a valid --model alias (only valid in --agents subagent config).
+ * Map short names to full model IDs so callers can use friendly names.
+ */
+const CLAUDE_MODEL_ALIASES: Record<string, string> = {
+  haiku: "claude-haiku-4-5-20251001",
+};
+
+/** Resolve a model alias to its full ID for the claude CLI --model flag. */
+function resolveModelFlag(flag: string): string {
+  return CLAUDE_MODEL_ALIASES[flag] ?? flag;
+}
+
 // ---------------------------------------------------------------------------
 // Agent detection
 // ---------------------------------------------------------------------------
@@ -77,6 +95,7 @@ export async function callViaAgent(
   systemPrompt: string,
   userPrompt: string,
   agent: string,
+  modelFlag?: string,
 ): Promise<string> {
   // Write prompt to temp file to avoid shell quoting issues
   const promptFile = join(tmpdir(), `selftune-llm-${Date.now()}.txt`);
@@ -88,6 +107,10 @@ export async function callViaAgent(
 
     if (agent === "claude") {
       cmd = ["claude", "-p", promptContent];
+      if (modelFlag) {
+        const resolved = resolveModelFlag(modelFlag);
+        cmd.push("--model", resolved);
+      }
     } else if (agent === "codex") {
       cmd = ["codex", "exec", "--skip-git-repo-check", promptContent];
     } else if (agent === "opencode") {
@@ -102,8 +125,10 @@ export async function callViaAgent(
       env: { ...process.env, CLAUDECODE: "" },
     });
 
-    // 120s timeout
-    const timeout = setTimeout(() => proc.kill(), 120_000);
+    // Longer timeout for heavier models (sonnet/opus take longer than haiku)
+    const isLightModel = modelFlag === "haiku" || modelFlag?.includes("haiku");
+    const timeoutMs = isLightModel ? 120_000 : 300_000;
+    const timeout = setTimeout(() => proc.kill(), timeoutMs);
     const exitCode = await proc.exited;
     clearTimeout(timeout);
 
@@ -135,9 +160,10 @@ export async function callLlm(
   systemPrompt: string,
   userPrompt: string,
   agent: string,
+  modelFlag?: string,
 ): Promise<string> {
   if (!agent) {
     throw new Error("Agent must be specified for callLlm");
   }
-  return callViaAgent(systemPrompt, userPrompt, agent);
+  return callViaAgent(systemPrompt, userPrompt, agent, modelFlag);
 }

package/cli/selftune/utils/transcript.ts

@@ -228,6 +228,41 @@ export function readExcerpt(transcriptPath: string, maxChars = 8000): string {
   return `${full.slice(0, head)}\n\n... [truncated] ...\n\n${full.slice(-tail)}`;
 }
 
+/**
+ * Extract token usage from a transcript JSONL by summing usage fields.
+ *
+ * Scans for entries with a `usage` object containing `input_tokens` and
+ * `output_tokens` (the format Claude Code transcripts use).
+ */
+export function extractTokenUsage(transcriptPath: string): { input: number; output: number } {
+  if (!existsSync(transcriptPath)) return { input: 0, output: 0 };
+
+  const content = readFileSync(transcriptPath, "utf-8");
+  const lines = content.split("\n");
+  let input = 0;
+  let output = 0;
+
+  for (const raw of lines) {
+    const line = raw.trim();
+    if (!line) continue;
+
+    let entry: Record<string, unknown>;
+    try {
+      entry = JSON.parse(line);
+    } catch {
+      continue;
+    }
+
+    const usage = entry.usage as Record<string, unknown> | undefined;
+    if (usage && typeof usage === "object") {
+      if (typeof usage.input_tokens === "number") input += usage.input_tokens;
+      if (typeof usage.output_tokens === "number") output += usage.output_tokens;
+    }
+  }
+
+  return { input, output };
+}
+
 function emptyMetrics(): TranscriptMetrics {
   return {
     tool_calls: {},

package/cli/selftune/utils/trigger-check.ts

@@ -0,0 +1,89 @@
+/**
+ * Shared trigger-check utilities.
+ *
+ * Extracted from validate-proposal.ts so other modules (e.g. body validation,
+ * routing validation) can reuse the same prompt-building and response-parsing
+ * logic without depending on the evolution layer.
+ */
+
+// ---------------------------------------------------------------------------
+// Prompt building
+// ---------------------------------------------------------------------------
+
+/** Build the trigger check prompt for the LLM. */
+export function buildTriggerCheckPrompt(description: string, query: string): string {
+  return [
+    "Given this skill description, would the following user query trigger this skill?",
+    "Respond YES or NO only.",
+    "",
+    "Skill description:",
+    description,
+    "",
+    "User query:",
+    query,
+  ].join("\n");
+}
+
+// ---------------------------------------------------------------------------
+// Response parsing
+// ---------------------------------------------------------------------------
+
+/** Parse YES/NO from LLM response. */
+export function parseTriggerResponse(response: string): boolean {
+  const normalized = response.trim().toUpperCase();
+  if (normalized.startsWith("YES")) return true;
+  if (normalized.startsWith("NO")) return false;
+  return false; // conservative default
+}
+
+// ---------------------------------------------------------------------------
+// Batch prompt building
+// ---------------------------------------------------------------------------
+
+/** Build a batch trigger check prompt for multiple queries at once. */
+export function buildBatchTriggerCheckPrompt(description: string, queries: string[]): string {
+  const numbered = queries.map((q, i) => `${i + 1}. "${q}"`).join("\n");
+  return [
+    "Given this skill description, would each query trigger this skill?",
+    "Respond with the query number followed by YES or NO, one per line.",
+    "",
+    "Skill description:",
+    description,
+    "",
+    "Queries:",
+    numbered,
+  ].join("\n");
+}
+
+// ---------------------------------------------------------------------------
+// Batch response parsing
+// ---------------------------------------------------------------------------
+
+/**
+ * Parse a batch YES/NO response. Returns a boolean array aligned to the
+ * original query order. Defaults to false for unparseable or missing lines.
+ */
+export function parseBatchTriggerResponse(response: string, queryCount: number): boolean[] {
+  const results: boolean[] = new Array(queryCount).fill(false);
+  const lines = response.trim().split("\n");
+
+  for (const line of lines) {
+    const trimmed = line.trim();
+    if (!trimmed) continue;
+
+    // Try to extract a number prefix: "1. YES", "1: YES", "1 YES", "1) YES"
+    const match = trimmed.match(/^(\d+)[.):\s]+\s*(.*)/);
+    if (!match) continue;
+
+    const idx = parseInt(match[1], 10) - 1; // 1-based to 0-based
+    if (idx < 0 || idx >= queryCount) continue;
+
+    const answer = match[2].trim().toUpperCase();
+    if (answer.startsWith("YES")) {
+      results[idx] = true;
+    }
+    // NO or anything else stays false (the default)
+  }
+
+  return results;
+}

package/cli/selftune/utils/tui.ts

@@ -0,0 +1,156 @@
+/**
+ * tui.ts
+ *
+ * Zero-dependency TUI primitives for the selftune evolve pipeline.
+ * Uses raw ANSI escape codes for spinners, timers, and step progression.
+ * All output goes to stderr to keep stdout clean for JSON results.
+ */
+
+const SPINNER_FRAMES = ["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"];
+const TICK_MS = 80;
+
+export interface EvolveTUI {
+  /** Start a new step with a spinner. Completes the previous step (if any) with checkmark. */
+  step(label: string): void;
+  /** Complete the current step with checkmark and a custom label. */
+  done(label: string): void;
+  /** Complete the current step as failed with cross mark and a custom label. */
+  fail(label: string): void;
+  /** Stop all timers and print a summary line. */
+  finish(summary: string): void;
+  /** Clean up timers without printing. For error paths. */
+  destroy(): void;
+}
+
+function createNoopTUI(): EvolveTUI {
+  return { step() {}, done() {}, fail() {}, finish() {}, destroy() {} };
+}
+
+export function createEvolveTUI(opts: { skillName: string; model: string }): EvolveTUI {
+  const noColor = !!process.env.NO_COLOR;
+  const isTTY = !!process.stderr.isTTY;
+
+  // If not a TTY, return no-op to avoid ANSI noise in pipes/tests
+  if (!isTTY && !process.env.SELFTUNE_TUI_FORCE) {
+    return createNoopTUI();
+  }
+
+  const write = (s: string) => process.stderr.write(s);
+
+  let spinnerFrame = 0;
+  let stepStartTime = Date.now();
+  let currentLabel = "";
+  let hasActiveSpinner = false;
+  let intervalId: ReturnType<typeof setInterval> | null = null;
+  let destroyed = false;
+
+  const checkMark = noColor ? "+" : "\u2713";
+  const crossMark = noColor ? "x" : "\u2717";
+
+  // Print header
+  write(`\n  selftune evolve \u2500\u2500 ${opts.skillName} \u2500\u2500 ${opts.model}\n\n`);
+
+  function formatTime(ms: number): string {
+    return `${(ms / 1000).toFixed(1)}s`;
+  }
+
+  function clearSpinnerLine(): void {
+    if (hasActiveSpinner) {
+      write("\x1b[A\x1b[2K");
+    }
+  }
+
+  function writeSpinnerLine(): void {
+    const frame = noColor ? ">" : SPINNER_FRAMES[spinnerFrame % SPINNER_FRAMES.length];
+    const elapsed = formatTime(Date.now() - stepStartTime);
+    const padding = Math.max(1, 48 - currentLabel.length);
+    write(`  ${frame} ${currentLabel}${" ".repeat(padding)}${elapsed}\n`);
+    hasActiveSpinner = true;
+  }
+
+  function startSpinner(label: string): void {
+    currentLabel = label;
+    stepStartTime = Date.now();
+    spinnerFrame = 0;
+    writeSpinnerLine();
+    intervalId = setInterval(() => {
+      spinnerFrame++;
+      clearSpinnerLine();
+      writeSpinnerLine();
+    }, TICK_MS);
+  }
+
+  function stopSpinner(): void {
+    if (intervalId !== null) {
+      clearInterval(intervalId);
+      intervalId = null;
+    }
+  }
+
+  function writeCompletedLine(marker: string, label: string, elapsed: number): void {
+    const time = formatTime(elapsed);
+    const padding = Math.max(1, 48 - label.length);
+    write(`  ${marker} ${label}${" ".repeat(padding)}${time}\n`);
+  }
+
+  function completeCurrentStep(marker: string, label: string): void {
+    const elapsed = Date.now() - stepStartTime;
+    stopSpinner();
+    clearSpinnerLine();
+    hasActiveSpinner = false;
+    writeCompletedLine(marker, label, elapsed);
+  }
+
+  return {
+    step(label: string): void {
+      if (destroyed) return;
+      // Complete previous step if there was one
+      if (hasActiveSpinner) {
+        completeCurrentStep(checkMark, currentLabel);
+      }
+      startSpinner(label);
+    },
+
+    done(label: string): void {
+      if (destroyed) return;
+      if (hasActiveSpinner) {
+        // Complete active spinner with custom label
+        completeCurrentStep(checkMark, label);
+      } else {
+        // No active spinner — instant step
+        writeCompletedLine(checkMark, label, 0);
+      }
+      currentLabel = "";
+    },
+
+    fail(label: string): void {
+      if (destroyed) return;
+      if (hasActiveSpinner) {
+        completeCurrentStep(crossMark, label);
+      } else {
+        writeCompletedLine(crossMark, label, 0);
+      }
+      currentLabel = "";
+    },
+
+    finish(summary: string): void {
+      if (destroyed) return;
+      if (hasActiveSpinner) {
+        completeCurrentStep(checkMark, currentLabel);
+      }
+      stopSpinner();
+      write(`\n  ${summary}\n`);
+      destroyed = true;
+    },
+
+    destroy(): void {
+      if (destroyed) return;
+      stopSpinner();
+      if (hasActiveSpinner) {
+        clearSpinnerLine();
+        hasActiveSpinner = false;
+      }
+      destroyed = true;
+    },
+  };
+}