@spacek33z/autoauto 0.0.1

package/src/screens/PreRunScreen.tsx

@@ -0,0 +1,206 @@
+import { useState, useEffect } from "react"
+import { useKeyboard } from "@opentui/react"
+import {
+  type Screen,
+  type ProgramConfig,
+  getProgramDir,
+  loadProgramConfig,
+} from "../lib/programs.ts"
+import { getLatestRun, readAllResults, getAvgMeasurementDuration } from "../lib/run.ts"
+import {
+  type ModelSlot,
+  cycleChoice,
+  formatEffortSlot,
+  formatModelSlot,
+  getEffortChoicesForSlot,
+  isEffortConfigurable,
+  mergeSelectedModelSlot,
+  PROVIDER_CHOICES,
+  PROVIDER_LABELS,
+} from "../lib/config.ts"
+import { CycleField } from "../components/CycleField.tsx"
+import { ModelPicker } from "../components/ModelPicker.tsx"
+
+export interface PreRunOverrides {
+  modelConfig: ModelSlot
+  maxExperiments: number
+  useWorktree: boolean
+}
+
+interface PreRunScreenProps {
+  cwd: string
+  programSlug: string
+  defaultModelConfig: ModelSlot
+  navigate: (screen: Screen) => void
+  onStart: (overrides: PreRunOverrides) => void
+}
+
+// 0=maxExperiments, 1=provider, 2=model, 3=effort, 4=runMode
+const FIELD_COUNT = 5
+
+export function PreRunScreen({ cwd, programSlug, defaultModelConfig, navigate, onStart }: PreRunScreenProps) {
+  const [selected, setSelected] = useState(0)
+  const [maxExpText, setMaxExpText] = useState("")
+  const [modelSlot, setModelSlot] = useState<ModelSlot>(defaultModelConfig)
+  const [useWorktree, setUseWorktree] = useState(true)
+  const [pickingModel, setPickingModel] = useState(false)
+  const [programConfig, setProgramConfig] = useState<ProgramConfig | null>(null)
+  const [avgDurationMs, setAvgDurationMs] = useState<number | null>(null)
+
+  useEffect(() => {
+    const programDir = getProgramDir(cwd, programSlug)
+    loadProgramConfig(programDir).then((config) => {
+      setProgramConfig(config)
+      if (config.max_experiments) {
+        setMaxExpText(String(config.max_experiments))
+      }
+    })
+    getLatestRun(programDir).then(async (run) => {
+      if (!run) return
+      const results = await readAllResults(run.run_dir)
+      setAvgDurationMs(getAvgMeasurementDuration(results))
+    })
+  }, [cwd, programSlug])
+
+  function handleStart() {
+    const parsed = parseInt(maxExpText, 10)
+    if (isNaN(parsed) || parsed < 1) return // require a valid limit
+    onStart({ modelConfig: modelSlot, maxExperiments: parsed, useWorktree })
+  }
+
+  function handleCycleProvider(direction: -1 | 1) {
+    setModelSlot((slot) => {
+      const nextProvider = cycleChoice(PROVIDER_CHOICES, slot.provider, direction)
+      const defaultModel = nextProvider === "claude" ? "sonnet" : "default"
+      return { provider: nextProvider, model: defaultModel, effort: slot.effort }
+    })
+  }
+
+  function handleCycleEffort(direction: -1 | 1) {
+    if (!isEffortConfigurable(modelSlot)) return
+    const validEfforts = getEffortChoicesForSlot(modelSlot)
+    setModelSlot((slot) => ({ ...slot, effort: cycleChoice(validEfforts, slot.effort, direction) }))
+  }
+
+  useKeyboard((key) => {
+    if (pickingModel) return
+    if (key.name === "escape") {
+      navigate("home")
+      return
+    }
+    if (key.name === "return") {
+      if (selected === 2) {
+        setPickingModel(true)
+        return
+      }
+      handleStart()
+      return
+    }
+
+    // Navigation
+    if (key.name === "tab" || key.name === "down" || key.name === "j") {
+      setSelected((s) => Math.min(FIELD_COUNT - 1, s + 1))
+      return
+    }
+    if (key.name === "shift-tab" || key.name === "up" || key.name === "k") {
+      setSelected((s) => Math.max(0, s - 1))
+      return
+    }
+
+    // Field-specific input
+    if (selected === 0) {
+      if (key.name === "backspace") setMaxExpText((t) => t.slice(0, -1))
+      else if (/^\d$/.test(key.name)) setMaxExpText((t) => t + key.name)
+    } else if (selected === 1) {
+      if (key.name === "left" || key.name === "h") handleCycleProvider(-1)
+      if (key.name === "right" || key.name === "l") handleCycleProvider(1)
+    } else if (selected === 2) {
+      if (key.name === "left" || key.name === "h" || key.name === "right" || key.name === "l") setPickingModel(true)
+    } else if (selected === 3) {
+      if (key.name === "left" || key.name === "h") handleCycleEffort(-1)
+      if (key.name === "right" || key.name === "l") handleCycleEffort(1)
+    } else if (selected === 4) {
+      if (key.name === "left" || key.name === "h" || key.name === "right" || key.name === "l") {
+        setUseWorktree((v) => !v)
+      }
+    }
+  })
+
+  // Time estimate
+  const avgMs = avgDurationMs
+  const repeats = programConfig?.repeats ?? 3
+  const maxExp = parseInt(maxExpText, 10)
+  const hasMaxExp = !isNaN(maxExp) && maxExp > 0
+  const effortDisplay = formatEffortSlot(modelSlot)
+
+  if (pickingModel) {
+    return (
+      <ModelPicker
+        cwd={cwd}
+        title={`Run Model — ${PROVIDER_LABELS[modelSlot.provider]}`}
+        providerId={modelSlot.provider}
+        onCancel={() => setPickingModel(false)}
+        onSelect={(slot) => {
+          setModelSlot((prev) => mergeSelectedModelSlot(prev, slot))
+          setPickingModel(false)
+        }}
+      />
+    )
+  }
+
+  return (
+    <box flexDirection="column" flexGrow={1} border borderStyle="rounded" title={`Run: ${programSlug}`}>
+      <box height={1} />
+
+      <box flexDirection="column">
+        <text>
+          {selected === 0 ? (
+            <span fg="#7aa2f7"><strong>{`  Max Experiments: ${maxExpText || ""}`}<span fg="#7aa2f7">{"\u2588"}</span></strong></span>
+          ) : (
+            `  Max Experiments: ${maxExpText || "(required)"}`
+          )}
+        </text>
+        {selected === 0 && (
+          <text fg="#888888">{"  Type a number (required)"}</text>
+        )}
+      </box>
+
+      <box height={1} />
+
+      <CycleField label="Provider" value={PROVIDER_LABELS[modelSlot.provider]} isFocused={selected === 1} />
+      <CycleField label="Model" value={formatModelSlot(modelSlot)} isFocused={selected === 2} />
+      <CycleField label="Effort" value={effortDisplay.label} description={effortDisplay.description} isFocused={selected === 3} />
+
+      <box height={1} />
+
+      <CycleField label="Run Mode" value={useWorktree ? "Worktree (recommended)" : "In-place"} isFocused={selected === 4} />
+      {!useWorktree && (
+        <box flexDirection="column">
+          <text fg="#ff5555">{"  \u26A0 DANGER: Runs git reset --hard in your main checkout."}</text>
+          <text fg="#ff5555">{"    All uncommitted changes will be destroyed between experiments."}</text>
+          <text fg="#ff5555">{"    Your branch will be changed. Only use on a clean, throwaway branch."}</text>
+        </box>
+      )}
+
+      <box height={1} />
+
+      {/* Time estimate */}
+      {avgMs != null && (
+        <box flexDirection="column">
+          <text fg="#888888">
+            {`  Each measurement takes ~${(avgMs / 1000).toFixed(1)}s (×${repeats} repeats)`}
+          </text>
+          {hasMaxExp && (
+            <text fg="#888888">
+              {`  ${maxExp} experiments \u2248 ~${Math.ceil((avgMs * maxExp * repeats) / 60000)} min (measurement only)`}
+            </text>
+          )}
+        </box>
+      )}
+
+      <box flexGrow={1} />
+
+      <text fg="#666666">{"  Enter: start/open model picker | Escape: back | Tab: next field"}</text>
+    </box>
+  )
+}

package/src/screens/SettingsScreen.tsx

@@ -0,0 +1,189 @@
+import { useState } from "react"
+import { useKeyboard } from "@opentui/react"
+import type { Screen } from "../lib/programs.ts"
+import {
+  type ProjectConfig,
+  cycleChoice,
+  formatEffortSlot,
+  formatModelSlot,
+  getEffortChoicesForSlot,
+  isEffortConfigurable,
+  mergeSelectedModelSlot,
+  saveProjectConfig,
+  PROVIDER_CHOICES,
+  PROVIDER_LABELS,
+} from "../lib/config.ts"
+import { CycleField } from "../components/CycleField.tsx"
+import { ModelPicker } from "../components/ModelPicker.tsx"
+
+interface SettingsScreenProps {
+  cwd: string
+  navigate: (screen: Screen) => void
+  config: ProjectConfig
+  onConfigChange: (config: ProjectConfig) => void
+}
+
+// Row layout:
+// 0: exec provider   1: exec model   2: exec effort
+// 3: support provider 4: support model 5: support effort
+// 6: ideas backlog
+const ROW_COUNT = 7
+
+function slotKeyForRow(row: number): "executionModel" | "supportModel" {
+  return row < 3 ? "executionModel" : "supportModel"
+}
+
+export function SettingsScreen({ cwd, navigate, config, onConfigChange }: SettingsScreenProps) {
+  const [selected, setSelected] = useState(0)
+  const [pickingSlot, setPickingSlot] = useState<"executionModel" | "supportModel" | null>(null)
+
+  const updateConfig = (updater: (prev: ProjectConfig) => ProjectConfig) => {
+    const next = updater(config)
+    onConfigChange(next)
+    saveProjectConfig(cwd, next)
+  }
+
+  function cycleProvider(slotKey: "executionModel" | "supportModel", direction: -1 | 1) {
+    updateConfig((prev) => {
+      const slot = prev[slotKey]
+      const nextProvider = cycleChoice(PROVIDER_CHOICES, slot.provider, direction)
+      // Reset model to a sensible default when switching provider
+      const defaultModel = nextProvider === "claude" ? "sonnet" : "default"
+      const effort = nextProvider === "opencode" ? slot.effort : slot.effort
+      return { ...prev, [slotKey]: { provider: nextProvider, model: defaultModel, effort } }
+    })
+  }
+
+  function cycleValue(direction: -1 | 1) {
+    // Provider rows
+    if (selected === 0) return cycleProvider("executionModel", direction)
+    if (selected === 3) return cycleProvider("supportModel", direction)
+
+    // Model rows — open picker
+    if (selected === 1 || selected === 4) {
+      setPickingSlot(selected === 1 ? "executionModel" : "supportModel")
+      return
+    }
+
+    // Ideas backlog
+    if (selected === 6) {
+      updateConfig((prev) => ({ ...prev, ideasBacklogEnabled: !prev.ideasBacklogEnabled }))
+      return
+    }
+
+    // Effort rows
+    const slotKey = slotKeyForRow(selected)
+    updateConfig((prev) => {
+      const slot = { ...prev[slotKey] }
+      if (!isEffortConfigurable(slot)) return prev
+      const validEfforts = getEffortChoicesForSlot(slot)
+      slot.effort = cycleChoice(validEfforts, slot.effort, direction)
+      return { ...prev, [slotKey]: slot }
+    })
+  }
+
+  useKeyboard((key) => {
+    if (pickingSlot) return
+    if (key.name === "escape") navigate("home")
+    if (key.name === "up" || key.name === "k")
+      setSelected((s) => Math.max(0, s - 1))
+    if (key.name === "down" || key.name === "j")
+      setSelected((s) => Math.min(ROW_COUNT - 1, s + 1))
+    if (key.name === "left" || key.name === "h") cycleValue(-1)
+    if (key.name === "right" || key.name === "l") cycleValue(1)
+    if (key.name === "return" && (selected === 1 || selected === 4)) {
+      setPickingSlot(selected === 1 ? "executionModel" : "supportModel")
+    }
+  })
+
+  const execSlot = config.executionModel
+  const supportSlot = config.supportModel
+  const execEffort = formatEffortSlot(execSlot)
+  const supportEffort = formatEffortSlot(supportSlot)
+
+  if (pickingSlot) {
+    const slot = config[pickingSlot]
+    const title = pickingSlot === "executionModel" ? "Execution Model" : "Support Model"
+    return (
+      <ModelPicker
+        cwd={cwd}
+        title={`${title} — ${PROVIDER_LABELS[slot.provider]}`}
+        providerId={slot.provider}
+        onCancel={() => setPickingSlot(null)}
+        onSelect={(newSlot) => {
+          updateConfig((prev) => ({
+            ...prev,
+            [pickingSlot]: mergeSelectedModelSlot(prev[pickingSlot], newSlot),
+          }))
+          setPickingSlot(null)
+        }}
+      />
+    )
+  }
+
+  return (
+    <box
+      flexDirection="column"
+      flexGrow={1}
+      border
+      borderStyle="rounded"
+      title="Settings"
+    >
+      <box height={1} />
+      <box flexDirection="row">
+        <text><strong>{"  Execution Model "}</strong></text>
+        <text fg="#888888">{"(experiment agents)"}</text>
+      </box>
+      <CycleField
+        label="Provider"
+        value={PROVIDER_LABELS[execSlot.provider]}
+        isFocused={selected === 0}
+      />
+      <CycleField
+        label="Model"
+        value={formatModelSlot(execSlot)}
+        isFocused={selected === 1}
+      />
+      <CycleField
+        label="Effort"
+        value={execEffort.label}
+        description={execEffort.description}
+        isFocused={selected === 2}
+      />
+      <box height={1} />
+      <box flexDirection="row">
+        <text><strong>{"  Support Model "}</strong></text>
+        <text fg="#888888">{"(setup & finalize)"}</text>
+      </box>
+      <CycleField
+        label="Provider"
+        value={PROVIDER_LABELS[supportSlot.provider]}
+        isFocused={selected === 3}
+      />
+      <CycleField
+        label="Model"
+        value={formatModelSlot(supportSlot)}
+        isFocused={selected === 4}
+      />
+      <CycleField
+        label="Effort"
+        value={supportEffort.label}
+        description={supportEffort.description}
+        isFocused={selected === 5}
+      />
+      <box height={1} />
+      <box flexDirection="row">
+        <text><strong>{"  Experiment Memory "}</strong></text>
+        <text fg="#888888">{"(ideas backlog)"}</text>
+      </box>
+      <CycleField
+        label="Ideas Backlog"
+        value={config.ideasBacklogEnabled ? "On" : "Off"}
+        description={config.ideasBacklogEnabled
+          ? "Capture why experiments worked or failed and what to try next"
+          : "Use results.tsv-based experiment memory only"}
+        isFocused={selected === 6}
+      />
+    </box>
+  )
+}

package/src/screens/SetupScreen.tsx

@@ -0,0 +1,226 @@
+import { useState, useMemo, useCallback, useEffect } from "react"
+import { mkdir } from "node:fs/promises"
+import { dirname } from "node:path"
+import { useKeyboard } from "@opentui/react"
+import type { TextareaOptions } from "@opentui/core"
+import { Chat } from "../components/Chat.tsx"
+import { getSetupSystemPrompt } from "../lib/system-prompts/index.ts"
+import { getUpdateSystemPrompt } from "../lib/system-prompts/update.ts"
+import { loadProgramSummaries, getProgramDir, type Screen, type ProgramSummary } from "../lib/programs.ts"
+import { buildUpdateRunContext } from "../lib/run-context.ts"
+import { formatModelLabel, type ModelSlot } from "../lib/config.ts"
+import { formatShellError } from "../lib/git.ts"
+
+type OpenTUISubmitEvent = Parameters<NonNullable<TextareaOptions["onSubmit"]>>[0]
+
+const SETUP_TOOLS = ["Read", "Write", "Edit", "Bash", "Glob", "Grep"]
+const SETUP_MAX_TURNS = 40
+
+type SetupMode = "choose" | "scope" | "chat"
+
+const MODE_OPTIONS = [
+  {
+    name: "Analyze my codebase",
+    description: "Scan your project and suggest what to optimize",
+    value: "analyze",
+  },
+  {
+    name: "I know what I want to optimize",
+    description: "Describe your target and start setting up",
+    value: "direct",
+  },
+]
+
+interface SetupScreenProps {
+  cwd: string
+  navigate: (screen: Screen) => void
+  modelConfig: ModelSlot
+  /** When set, enters update mode for an existing program */
+  programSlug?: string
+}
+
+export function SetupScreen({ cwd, navigate, modelConfig, programSlug }: SetupScreenProps) {
+  const isUpdate = Boolean(programSlug)
+  const [existingPrograms, setExistingPrograms] = useState<ProgramSummary[]>([])
+
+  useEffect(() => {
+    if (!isUpdate) {
+      loadProgramSummaries(cwd).then(setExistingPrograms).catch(() => {})
+    }
+  }, [cwd, isUpdate])
+
+  // Setup mode: system prompt from setup.ts
+  const setupResult = useMemo(
+    () => isUpdate ? null : getSetupSystemPrompt(cwd, existingPrograms),
+    [cwd, existingPrograms, isUpdate],
+  )
+  const [setupReady, setSetupReady] = useState(false)
+
+  useEffect(() => {
+    if (!setupResult) return
+    setSetupReady(false)
+    mkdir(dirname(setupResult.referencePath), { recursive: true })
+      .then(() => Bun.write(setupResult.referencePath, setupResult.referenceContent))
+      .then(() => setSetupReady(true))
+      .catch(() => setSetupReady(true)) // proceed anyway — agent can still work without reference
+  }, [setupResult])
+
+  const [updateSystemPrompt, setUpdateSystemPrompt] = useState<string | null>(null)
+  const [updateInitialMessage, setUpdateInitialMessage] = useState<string | null>(null)
+  const [updateLoadError, setUpdateLoadError] = useState<string | null>(null)
+
+  useEffect(() => {
+    if (!programSlug) return
+    const programDir = getProgramDir(cwd, programSlug)
+
+    Promise.all([
+      getUpdateSystemPrompt(cwd, programSlug, programDir).then(async (result) => {
+        await mkdir(dirname(result.referencePath), { recursive: true })
+        await Bun.write(result.referencePath, result.referenceContent)
+        return result.systemPrompt
+      }),
+      buildUpdateRunContext(programDir),
+    ]).then(([prompt, context]) => {
+      setUpdateSystemPrompt(prompt)
+      setUpdateInitialMessage(context)
+    }).catch((err: unknown) => {
+      setUpdateLoadError(formatShellError(err))
+    })
+  }, [cwd, programSlug])
+
+  const [mode, setMode] = useState<SetupMode>(isUpdate ? "chat" : "choose")
+  const [initialMessage, setInitialMessage] = useState<string | undefined>(undefined)
+
+  useKeyboard((key) => {
+    if (key.name === "escape") {
+      if (mode === "scope") {
+        setMode("choose")
+      } else {
+        navigate("home")
+      }
+    }
+  })
+
+  const handleModeSelect = useCallback((_index: number, option: { value?: unknown } | null) => {
+    if (!option) return
+    if (option.value === "direct") {
+      setMode("chat")
+    } else if (option.value === "analyze") {
+      setMode("scope")
+    }
+  }, [])
+
+  const handleScopeSubmit = useCallback((value: unknown) => {
+    if (typeof value !== "string") return
+    const scope = value.trim()
+    if (scope) {
+      setInitialMessage(`What could I optimize in this codebase, focusing on ${scope}?`)
+    } else {
+      setInitialMessage("What could I optimize in this codebase?")
+    }
+    setMode("chat")
+  }, []) as
+    & ((event: OpenTUISubmitEvent) => void)
+    & ((value: string) => void)
+
+  if (isUpdate && updateLoadError) {
+    return (
+      <box flexDirection="column" flexGrow={1}>
+        <box flexDirection="column" flexGrow={1} border borderStyle="rounded" title={`Update: ${programSlug}`}>
+          <box flexGrow={1} justifyContent="center" alignItems="center">
+            <text fg="#ff5555">Failed to load program: {updateLoadError}</text>
+          </box>
+        </box>
+      </box>
+    )
+  }
+
+  if (isUpdate && (!updateSystemPrompt || !updateInitialMessage)) {
+    return (
+      <box flexDirection="column" flexGrow={1}>
+        <box flexDirection="column" flexGrow={1} border borderStyle="rounded" title={`Update: ${programSlug}`}>
+          <box flexGrow={1} justifyContent="center" alignItems="center">
+            <text fg="#888888">Loading program context...</text>
+          </box>
+        </box>
+      </box>
+    )
+  }
+
+  if (mode === "choose") {
+    return (
+      <box flexDirection="column" flexGrow={1}>
+        <box flexDirection="column" flexGrow={1} border borderStyle="rounded" title="New Program">
+          <box height={1} />
+          <text>{"  How would you like to start?"}</text>
+          <box height={1} />
+          <select
+            flexGrow={1}
+            focused
+            options={MODE_OPTIONS}
+            onSelect={handleModeSelect}
+            selectedBackgroundColor="#333333"
+            selectedTextColor="#ffffff"
+          />
+        </box>
+      </box>
+    )
+  }
+
+  if (mode === "scope") {
+    return (
+      <box flexDirection="column" flexGrow={1}>
+        <box flexDirection="column" flexGrow={1} border borderStyle="rounded" title="New Program">
+          <box height={1} />
+          <text>{"  What area should I focus on?"}</text>
+          <box height={1} />
+          <box border borderStyle="rounded" height={3}>
+            <input
+              focused
+              placeholder='e.g. "web app", "packages/ui", "API server"'
+              onSubmit={handleScopeSubmit}
+            />
+          </box>
+          <box height={1} />
+          <text fg="#888888">{"  Press Enter to skip and analyze everything"}</text>
+        </box>
+      </box>
+    )
+  }
+
+  // Wait for reference file to be written before rendering Chat
+  if (!isUpdate && !setupReady) {
+    return (
+      <box flexDirection="column" flexGrow={1}>
+        <box flexDirection="column" flexGrow={1} border borderStyle="rounded" title="New Program">
+          <box flexGrow={1} justifyContent="center" alignItems="center">
+            <text fg="#888888">Preparing...</text>
+          </box>
+        </box>
+      </box>
+    )
+  }
+
+  const modelLabel = formatModelLabel(modelConfig)
+
+  return (
+    <Chat
+      cwd={cwd}
+      systemPrompt={isUpdate ? updateSystemPrompt! : setupResult!.systemPrompt}
+      tools={SETUP_TOOLS}
+      allowedTools={SETUP_TOOLS}
+      maxTurns={SETUP_MAX_TURNS}
+      provider={modelConfig.provider}
+      model={modelConfig.model}
+      effort={modelConfig.effort}
+      initialMessage={isUpdate ? updateInitialMessage! : initialMessage}
+      emptyStateHint={isUpdate
+        ? "Describe what you'd like to change about this program."
+        : (!initialMessage ? 'Describe what you want to optimize — e.g. "reduce bundle size", "improve API latency", "increase test coverage".' : undefined)}
+      inputPlaceholder={isUpdate
+        ? 'e.g. "fix the measurement script" or "widen the scope"'
+        : (!initialMessage ? 'e.g. "I want to reduce the homepage load time"' : undefined)}
+      title={`${isUpdate ? "Update" : "Setup"} · ${modelLabel}`}
+    />
+  )
+}

package/src/tui.tsx

@@ -0,0 +1,17 @@
+#!/usr/bin/env bun
+import { createCliRenderer } from "@opentui/core"
+import { createRoot } from "@opentui/react"
+import { registerDefaultProviders } from "./lib/agent/default-providers.ts"
+import { App } from "./App.tsx"
+
+registerDefaultProviders()
+
+const renderer = await createCliRenderer({ exitOnCtrlC: false })
+
+// Copy-on-select: when the user finishes a mouse selection, copy to clipboard via OSC 52
+renderer.on("selection", (selection: { getSelectedText(): string }) => {
+  const text = selection.getSelectedText()
+  if (text) renderer.copyToClipboardOSC52(text)
+})
+
+createRoot(renderer).render(<App />)

package/tsconfig.json

@@ -0,0 +1,17 @@
+{
+  "compilerOptions": {
+    "target": "ESNext",
+    "module": "NodeNext",
+    "moduleResolution": "NodeNext",
+    "jsx": "react-jsx",
+    "jsxImportSource": "@opentui/react",
+    "lib": ["ESNext", "DOM"],
+    "strict": true,
+    "allowImportingTsExtensions": true,
+    "noEmit": true,
+    "skipLibCheck": true,
+    "outDir": "dist"
+  },
+  "include": ["src"],
+  "exclude": ["src/**/*.test.ts"]
+}