@spacek33z/autoauto 0.0.1

package/src/lib/programs.ts

@@ -0,0 +1,247 @@
+import { readdir, mkdir } from "node:fs/promises"
+import { join } from "node:path"
+import { $ } from "bun"
+
+export interface Program {
+  name: string
+  configPath: string
+}
+
+export interface QualityGate {
+  min?: number
+  max?: number
+}
+
+export interface SecondaryMetric {
+  direction: "lower" | "higher"
+}
+
+export interface ProgramConfig {
+  metric_field: string
+  direction: "lower" | "higher"
+  noise_threshold: number
+  repeats: number
+  quality_gates: Record<string, QualityGate>
+  secondary_metrics?: Record<string, SecondaryMetric>
+  max_experiments: number
+  max_consecutive_discards?: number
+  max_turns?: number
+}
+
+export type Screen = "home" | "setup" | "settings" | "program-detail" | "pre-run" | "execution" | "first-setup"
+
+export const AUTOAUTO_DIR = ".autoauto"
+
+let cachedRoot: string | undefined
+
+function assertFiniteNumber(value: unknown, path: string): asserts value is number {
+  if (typeof value !== "number" || !isFinite(value)) {
+    throw new Error(`config.json: ${path} must be a finite number`)
+  }
+}
+
+export function validateProgramConfig(raw: unknown): ProgramConfig {
+  if (typeof raw !== "object" || raw === null || Array.isArray(raw)) {
+    throw new Error("config.json: must be a JSON object")
+  }
+
+  const config = raw as Record<string, unknown>
+
+  if (!config.metric_field || typeof config.metric_field !== "string") {
+    throw new Error("config.json: metric_field must be a non-empty string")
+  }
+  if (config.direction !== "lower" && config.direction !== "higher") {
+    throw new Error('config.json: direction must be "lower" or "higher"')
+  }
+  assertFiniteNumber(config.noise_threshold, "noise_threshold")
+  if (config.noise_threshold <= 0) {
+    throw new Error("config.json: noise_threshold must be positive")
+  }
+  if (typeof config.repeats !== "number" || !Number.isInteger(config.repeats) || config.repeats < 1) {
+    throw new Error("config.json: repeats must be an integer >= 1")
+  }
+  if (
+    typeof config.max_experiments !== "number" ||
+    !Number.isInteger(config.max_experiments) ||
+    config.max_experiments < 1
+  ) {
+    throw new Error("config.json: max_experiments must be an integer >= 1")
+  }
+  if (
+    config.max_consecutive_discards !== undefined &&
+    (typeof config.max_consecutive_discards !== "number" ||
+      !Number.isInteger(config.max_consecutive_discards) ||
+      config.max_consecutive_discards < 1)
+  ) {
+    throw new Error("config.json: max_consecutive_discards must be an integer >= 1")
+  }
+  if (
+    config.max_turns !== undefined &&
+    (typeof config.max_turns !== "number" ||
+      !Number.isInteger(config.max_turns) ||
+      config.max_turns < 1)
+  ) {
+    throw new Error("config.json: max_turns must be an integer >= 1")
+  }
+  if (typeof config.quality_gates !== "object" || config.quality_gates === null || Array.isArray(config.quality_gates)) {
+    throw new Error("config.json: quality_gates must be an object")
+  }
+
+  for (const [field, gate] of Object.entries(config.quality_gates as Record<string, unknown>)) {
+    if (typeof gate !== "object" || gate === null || Array.isArray(gate)) {
+      throw new Error(`config.json: quality_gates.${field} must be an object`)
+    }
+
+    const gateConfig = gate as Record<string, unknown>
+    const hasMin = gateConfig.min !== undefined
+    const hasMax = gateConfig.max !== undefined
+
+    if (!hasMin && !hasMax) {
+      throw new Error(`config.json: quality_gates.${field} must define min or max`)
+    }
+    if (hasMin) assertFiniteNumber(gateConfig.min, `quality_gates.${field}.min`)
+    if (hasMax) assertFiniteNumber(gateConfig.max, `quality_gates.${field}.max`)
+    if (typeof gateConfig.min === "number" && typeof gateConfig.max === "number" && gateConfig.min > gateConfig.max) {
+      throw new Error(`config.json: quality_gates.${field}.min must be <= max`)
+    }
+  }
+
+  if (config.secondary_metrics !== undefined) {
+    if (typeof config.secondary_metrics !== "object" || config.secondary_metrics === null || Array.isArray(config.secondary_metrics)) {
+      throw new Error("config.json: secondary_metrics must be an object")
+    }
+
+    for (const [field, metric] of Object.entries(config.secondary_metrics as Record<string, unknown>)) {
+      if (typeof metric !== "object" || metric === null || Array.isArray(metric)) {
+        throw new Error(`config.json: secondary_metrics.${field} must be an object`)
+      }
+      const metricConfig = metric as Record<string, unknown>
+      if (metricConfig.direction !== "lower" && metricConfig.direction !== "higher") {
+        throw new Error(`config.json: secondary_metrics.${field}.direction must be "lower" or "higher"`)
+      }
+
+      // Prevent overlap with primary metric and quality gates
+      if (field === config.metric_field) {
+        throw new Error(`config.json: secondary_metrics.${field} overlaps with metric_field`)
+      }
+      if (field in (config.quality_gates as Record<string, unknown>)) {
+        throw new Error(`config.json: secondary_metrics.${field} overlaps with quality_gates`)
+      }
+    }
+  }
+
+  return config as unknown as ProgramConfig
+}
+
+/** Returns the main git repo root, resolving through worktrees. */
+export async function getProjectRoot(cwd: string): Promise<string> {
+  if (cachedRoot) return cachedRoot
+  const result = await $`git rev-parse --show-superproject-working-tree`.cwd(cwd).nothrow().quiet()
+  const superproject = result.stdout.toString().trim()
+  if (superproject) {
+    cachedRoot = superproject
+    return superproject
+  }
+  const toplevel = (await $`git rev-parse --show-toplevel`.cwd(cwd).text()).trim()
+  cachedRoot = toplevel
+  return toplevel
+}
+
+export async function listPrograms(cwd: string): Promise<Program[]> {
+  const root = await getProjectRoot(cwd)
+  const programsDir = join(root, AUTOAUTO_DIR, "programs")
+  try {
+    const entries = await readdir(programsDir, { withFileTypes: true })
+    return entries
+      .filter((e) => e.isDirectory())
+      .map((e) => ({
+        name: e.name,
+        configPath: join(programsDir, e.name, "config.json"),
+      }))
+  } catch {
+    return []
+  }
+}
+
+/** Enriched program metadata for the home screen. */
+export interface ProgramInfo {
+  name: string
+  totalRuns: number
+  lastRunDate: string | null
+  hasActiveRun: boolean
+}
+
+/** Returns the absolute path to the programs directory */
+export function getProgramsDir(cwd: string): string {
+  return join(cwd, AUTOAUTO_DIR, "programs")
+}
+
+/** Returns the absolute path to a specific program's directory */
+export function getProgramDir(cwd: string, slug: string): string {
+  return join(cwd, AUTOAUTO_DIR, "programs", slug)
+}
+
+/** Returns the absolute path to a specific run's directory */
+export function getRunDir(cwd: string, slug: string, runId: string): string {
+  return join(cwd, AUTOAUTO_DIR, "programs", slug, "runs", runId)
+}
+
+/** Reads and validates config.json from a program directory. */
+export async function loadProgramConfig(programDir: string): Promise<ProgramConfig> {
+  const raw = await Bun.file(join(programDir, "config.json")).json()
+  return validateProgramConfig(raw)
+}
+
+/** Summary of an existing program for duplicate detection during setup. */
+export interface ProgramSummary {
+  slug: string
+  goal: string
+}
+
+/** Loads summaries (slug + goal line from program.md) for all existing programs. */
+export async function loadProgramSummaries(cwd: string): Promise<ProgramSummary[]> {
+  const root = await getProjectRoot(cwd)
+  const programsDir = join(root, AUTOAUTO_DIR, "programs")
+  let entries: import("node:fs").Dirent[]
+  try {
+    entries = (await readdir(programsDir, { withFileTypes: true })).filter((e) => e.isDirectory())
+  } catch {
+    return []
+  }
+  const summaries = await Promise.all(
+    entries.map(async (e) => {
+      try {
+        const md = await Bun.file(join(programsDir, e.name, "program.md")).text()
+        const goalMatch = md.match(/## Goal\n+([\s\S]*?)(?:\n##|\n*$)/)
+        const goal = goalMatch ? goalMatch[1].trim() : "(no goal defined)"
+        return { slug: e.name, goal }
+      } catch {
+        return { slug: e.name, goal: "(could not read program.md)" }
+      }
+    }),
+  )
+  return summaries
+}
+
+export async function ensureAutoAutoDir(cwd: string): Promise<void> {
+  const root = await getProjectRoot(cwd)
+  const dir = join(root, AUTOAUTO_DIR)
+  await mkdir(dir, { recursive: true })
+
+  const gitignorePath = join(root, ".gitignore")
+  const gitignoreFile = Bun.file(gitignorePath)
+  let gitignoreChanged = false
+  if (await gitignoreFile.exists()) {
+    const existing = await gitignoreFile.text()
+    if (!existing.includes(AUTOAUTO_DIR)) {
+      await Bun.write(gitignorePath, existing.trimEnd() + `\n${AUTOAUTO_DIR}/\n`)
+      gitignoreChanged = true
+    }
+  } else {
+    await Bun.write(gitignorePath, `${AUTOAUTO_DIR}/\n`)
+    gitignoreChanged = true
+  }
+  if (gitignoreChanged) {
+    await $`git add .gitignore`.cwd(root).quiet()
+  }
+}

package/src/lib/push-stream.ts

@@ -0,0 +1,48 @@
+export interface PushStream<T> extends AsyncIterable<T> {
+  push(value: T): void
+  end(): void
+}
+
+export function createPushStream<T>(): PushStream<T> {
+  const queue: T[] = []
+  let waiting: ((result: IteratorResult<T>) => void) | null = null
+  let done = false
+
+  return {
+    push(value: T) {
+      if (done) return
+      if (waiting) {
+        const resolve = waiting
+        waiting = null
+        resolve({ value, done: false })
+      } else {
+        queue.push(value)
+      }
+    },
+
+    end() {
+      done = true
+      if (waiting) {
+        const resolve = waiting
+        waiting = null
+        resolve({ value: undefined as never, done: true })
+      }
+    },
+
+    [Symbol.asyncIterator]() {
+      return {
+        next(): Promise<IteratorResult<T>> {
+          if (queue.length > 0) {
+            return Promise.resolve({ value: queue.shift()!, done: false })
+          }
+          if (done) {
+            return Promise.resolve({ value: undefined as never, done: true })
+          }
+          return new Promise((resolve) => {
+            waiting = resolve
+          })
+        },
+      }
+    },
+  }
+}

package/src/lib/run-context.ts

@@ -0,0 +1,112 @@
+import { readdir } from "node:fs/promises"
+import { join } from "node:path"
+import { getLatestRun, readAllResults, getRunStats } from "./run.ts"
+import { loadProgramConfig } from "./programs.ts"
+import { streamLogName } from "./daemon-callbacks.ts"
+
+const MAX_LOG_LINES = 500
+
+/**
+ * Builds the auto-analysis initial message for the update agent.
+ * Gathers context from the latest run: summary stats, last experiment log, log paths.
+ */
+export async function buildUpdateRunContext(programDir: string): Promise<string> {
+  const latest = await getLatestRun(programDir)
+  if (!latest || !latest.state) {
+    return "No previous runs found for this program. Please describe what you'd like to change."
+  }
+
+  const { run_dir: runDir, state } = latest
+
+  const [config, results] = await Promise.all([
+    loadProgramConfig(programDir).catch(() => null),
+    readAllResults(runDir),
+  ])
+
+  const direction = config?.direction ?? "lower"
+  const stats = getRunStats(state, direction)
+
+  // Build run summary
+  const lines: string[] = [
+    "Here are the results from the latest run of this program:",
+    "",
+    "## Run Summary",
+    `- Phase: ${state.phase}`,
+  ]
+
+  if (state.termination_reason) {
+    lines.push(`- Termination reason: ${state.termination_reason}`)
+  }
+
+  lines.push(
+    `- Experiments: ${stats.total_experiments} total (${stats.total_keeps} kept, ${stats.total_discards} discarded, ${stats.total_crashes} crashed)`,
+  )
+
+  if (stats.total_experiments > 0) {
+    lines.push(`- Keep rate: ${(stats.keep_rate * 100).toFixed(0)}%`)
+    lines.push(
+      `- Original baseline: ${state.original_baseline} → Best: ${state.best_metric} (${stats.improvement_pct >= 0 ? "+" : ""}${stats.improvement_pct.toFixed(1)}%)`,
+    )
+  }
+
+  if (state.error) {
+    lines.push(`- Error: ${state.error}`)
+  }
+
+  // Last few results from results.tsv
+  if (results.length > 0) {
+    lines.push("", "## Recent Experiment Results")
+    const recent = results.slice(-5)
+    for (const r of recent) {
+      const tag = r.status === "keep" ? "KEEP" : r.status === "discard" ? "DISCARD" : r.status.toUpperCase()
+      lines.push(`- #${r.experiment_number} [${tag}] metric=${r.metric_value} — ${r.description}`)
+    }
+  }
+
+  // Read last experiment stream log
+  const lastExpNum = state.experiment_number
+  if (lastExpNum > 0) {
+    const logFile = streamLogName(lastExpNum)
+    const logPath = join(runDir, logFile)
+    try {
+      const logContent = await Bun.file(logPath).text()
+      const logLines = logContent.split("\n")
+      const truncated = logLines.length > MAX_LOG_LINES
+      const displayLines = truncated ? logLines.slice(-MAX_LOG_LINES) : logLines
+      lines.push(
+        "",
+        `## Last Experiment (#${lastExpNum}) Stream Log${truncated ? ` (last ${MAX_LOG_LINES} lines)` : ""}`,
+        "```",
+        displayLines.join("\n"),
+        "```",
+      )
+    } catch {
+      // Log file doesn't exist
+    }
+  }
+
+  // List all available stream logs
+  try {
+    const entries = await readdir(runDir)
+    const logFiles = entries.filter((f) => f.startsWith("stream-") && f.endsWith(".log")).toSorted()
+    if (logFiles.length > 0) {
+      lines.push(
+        "",
+        "## Additional Logs",
+        "The following log files are available if you need more context (use the Read tool):",
+      )
+      for (const f of logFiles) {
+        lines.push(`- ${join(runDir, f)}`)
+      }
+    }
+  } catch {
+    // Can't list directory
+  }
+
+  lines.push(
+    "",
+    "Please analyze these results and suggest what should be fixed or improved in the program configuration.",
+  )
+
+  return lines.join("\n")
+}

package/src/lib/run-setup.ts

@@ -0,0 +1,34 @@
+import { mkdir, chmod } from "node:fs/promises"
+import { join } from "node:path"
+
+// --- Measurement Locking ---
+
+/** Files protected from agent modification during experiment runs. */
+export const MEASUREMENT_FILES = ["measure.sh", "config.json", "build.sh"] as const
+
+/** Makes measurement files read-only (chmod 444). #1 safeguard against metric gaming. */
+export async function lockMeasurement(programDir: string): Promise<void> {
+  await Promise.all(
+    MEASUREMENT_FILES.map((f) => chmod(join(programDir, f), 0o444).catch(() => {})),
+  )
+}
+
+export async function unlockMeasurement(programDir: string): Promise<void> {
+  await Promise.all(
+    MEASUREMENT_FILES.map((f) => chmod(join(programDir, f), 0o644).catch(() => {})),
+  )
+}
+
+// --- Run Directory ---
+
+export async function initRunDir(programDir: string, runId: string): Promise<string> {
+  const runDir = join(programDir, "runs", runId)
+  await mkdir(runDir, { recursive: true })
+
+  await Bun.write(
+    join(runDir, "results.tsv"),
+    "experiment#\tcommit\tmetric_value\tsecondary_values\tstatus\tdescription\tmeasurement_duration_ms\tdiff_stats\n",
+  )
+
+  return runDir
+}