@spacek33z/autoauto 0.0.1

package/src/lib/git.ts

@@ -0,0 +1,176 @@
+import { $ } from "bun"
+
+/** Extract a meaningful message from a Bun ShellError (which has .stderr Buffer but a generic .message). */
+export function formatShellError(err: unknown, context?: string): string {
+  if (err instanceof Error) {
+    // Bun ShellError has .stderr as a Buffer
+    const shellErr = err as Error & { stderr?: Buffer; exitCode?: number }
+    const stderr = shellErr.stderr ? shellErr.stderr.toString().trim() : ""
+    const prefix = context ? `${context}: ` : ""
+    if (stderr) return `${prefix}${stderr}`
+    if (shellErr.message && !shellErr.message.startsWith("Failed with exit code")) {
+      return `${prefix}${shellErr.message}`
+    }
+    return `${prefix}exit code ${shellErr.exitCode ?? "unknown"}`
+  }
+  return context ? `${context}: ${String(err)}` : String(err)
+}
+
+export async function getFullSha(cwd: string): Promise<string> {
+  return (await $`git rev-parse HEAD`.cwd(cwd).text()).trim()
+}
+
+export async function getRecentLog(cwd: string, count?: number): Promise<string> {
+  return (await $`git log --oneline --decorate -n ${String(count ?? 10)}`.cwd(cwd).text()).trim()
+}
+
+/** Resets HEAD to the given SHA, discarding all changes. Primary discard mechanism for failed experiments. */
+export async function resetHard(cwd: string, sha: string): Promise<void> {
+  await $`git reset --hard ${sha}`.cwd(cwd).quiet()
+}
+
+export async function getLatestCommitMessage(cwd: string): Promise<string> {
+  return (await $`git log -1 --format=%s`.cwd(cwd).text()).trim()
+}
+
+export async function getCommitDiff(cwd: string, sha: string): Promise<string> {
+  return (await $`git show --stat ${sha}`.cwd(cwd).text()).trim()
+}
+
+export async function branchExists(cwd: string, branchName: string): Promise<boolean> {
+  const result = await $`git show-ref --verify --quiet refs/heads/${branchName}`.cwd(cwd).nothrow().quiet()
+  return result.exitCode === 0
+}
+
+export async function isWorkingTreeClean(cwd: string): Promise<boolean> {
+  return !(await $`git status --porcelain`.cwd(cwd).text()).trim()
+}
+
+export async function getCurrentBranch(cwd: string): Promise<string> {
+  return (await $`git rev-parse --abbrev-ref HEAD`.cwd(cwd).text()).trim()
+}
+
+export async function createExperimentBranch(
+  cwd: string,
+  programSlug: string,
+  runId: string,
+): Promise<string> {
+  const branchName = `autoauto-${programSlug}-${runId}`
+
+  const result = await $`git checkout -b ${branchName}`.cwd(cwd).nothrow().quiet()
+  if (result.exitCode !== 0) {
+    throw new Error(
+      `Failed to create branch "${branchName}" — was a previous run interrupted? ` +
+        `Delete it with \`git branch -D ${branchName}\` to proceed.`,
+    )
+  }
+
+  return branchName
+}
+
+export async function checkoutBranch(cwd: string, branchName: string): Promise<void> {
+  await $`git checkout ${branchName}`.cwd(cwd).quiet()
+}
+
+/** Returns files changed between two SHAs (relative paths). */
+export async function getFilesChangedBetween(
+  cwd: string,
+  fromSha: string,
+  toSha: string,
+): Promise<string[]> {
+  return (await $`git diff --name-only ${fromSha} ${toSha}`.cwd(cwd).text())
+    .trim()
+    .split("\n")
+    .filter(Boolean)
+}
+
+/** Returns the number of commits between two SHAs. */
+export async function countCommitsBetween(
+  cwd: string,
+  fromSha: string,
+  toSha: string,
+): Promise<number> {
+  return parseInt((await $`git rev-list --count ${fromSha}..${toSha}`.cwd(cwd).text()).trim(), 10)
+}
+
+/** Returns the full unified diff between two SHAs. */
+export async function getDiffBetween(cwd: string, fromSha: string, toSha: string): Promise<string> {
+  return await $`git diff ${fromSha} ${toSha}`.cwd(cwd).text()
+}
+
+/** Creates a group branch from baseline, applying only the specified files from headSha.
+ *  Used by finalize to split kept experiments into independent, mergeable branches.
+ *  Returns the new commit SHA. */
+export async function createGroupBranch(
+  cwd: string,
+  branchName: string,
+  baselineSha: string,
+  headSha: string,
+  files: string[],
+  commitMessage: string,
+): Promise<string> {
+  // Delete stale branch from a previous crashed attempt
+  if (await branchExists(cwd, branchName)) {
+    await $`git branch -D ${branchName}`.cwd(cwd).quiet()
+  }
+
+  try {
+    await $`git checkout -b ${branchName} ${baselineSha}`.cwd(cwd).quiet()
+  } catch (err) {
+    throw new Error(formatShellError(err, `git checkout -b ${branchName}`), { cause: err })
+  }
+
+  try {
+    // Stage only this group's files from the final experiment state
+    await $`git checkout ${headSha} -- ${files}`.cwd(cwd).quiet()
+  } catch (err) {
+    throw new Error(formatShellError(err, `git checkout files from ${headSha.slice(0, 10)}`), { cause: err })
+  }
+
+  try {
+    await $`git commit -m ${commitMessage}`.cwd(cwd).quiet()
+  } catch (err) {
+    throw new Error(formatShellError(err, `git commit for group "${branchName}"`), { cause: err })
+  }
+
+  return getFullSha(cwd)
+}
+
+/** Diff statistics: lines added and removed between two SHAs. */
+export interface DiffStats {
+  lines_added: number
+  lines_removed: number
+}
+
+/** Returns lines added/removed between two SHAs using git diff --shortstat. */
+export async function getDiffStats(cwd: string, fromSha: string, toSha: string): Promise<DiffStats> {
+  const output = (await $`git diff --shortstat ${fromSha} ${toSha}`.cwd(cwd).text()).trim()
+  if (!output) return { lines_added: 0, lines_removed: 0 }
+
+  const insertions = output.match(/(\d+) insertion/)
+  const deletions = output.match(/(\d+) deletion/)
+  return {
+    lines_added: insertions ? parseInt(insertions[1], 10) : 0,
+    lines_removed: deletions ? parseInt(deletions[1], 10) : 0,
+  }
+}
+
+/** Returns formatted diff summaries for discarded commits, capped at maxLength chars. */
+export async function getDiscardedDiffs(
+  cwd: string,
+  shas: string[],
+  maxLength = 2000,
+): Promise<string> {
+  const parts: string[] = []
+  let totalLength = 0
+
+  for (const sha of shas) {
+    if (totalLength >= maxLength) break
+    const diff = await getCommitDiff(cwd, sha) // eslint-disable-line no-await-in-loop -- lazy fetch, stops at maxLength
+    const entry = `[${sha.slice(0, 7)}]\n${diff}\n`
+    parts.push(entry)
+    totalLength += entry.length
+  }
+
+  return parts.join("\n")
+}

package/src/lib/ideas-backlog.test.ts

@@ -0,0 +1,54 @@
+import { describe, expect, test } from "bun:test"
+import { mkdtemp, readFile, rm } from "node:fs/promises"
+import { join } from "node:path"
+import { tmpdir } from "node:os"
+import {
+  appendIdeasBacklog,
+  parseExperimentNotes,
+  readIdeasBacklogSummary,
+} from "./ideas-backlog.ts"
+
+describe("ideas backlog", () => {
+  test("parses orchestrator notes block", () => {
+    const notes = parseExperimentNotes(`
+done
+<autoauto_notes>
+{"hypothesis":"cache hot path","why":"avoids repeated work","avoid":["global cache"],"next":["try local memo"]}
+</autoauto_notes>
+`)
+
+    expect(notes).toEqual({
+      hypothesis: "cache hot path",
+      why: "avoids repeated work",
+      avoid: ["global cache"],
+      next: ["try local memo"],
+    })
+  })
+
+  test("writes readable experiment entries", async () => {
+    const runDir = await mkdtemp(join(tmpdir(), "autoauto-ideas-"))
+    try {
+      await appendIdeasBacklog(runDir, {
+        experiment_number: 1,
+        commit: "abc1234",
+        metric_value: 42,
+        secondary_values: "",
+        status: "discard",
+        description: "noise: cache hot path",
+        measurement_duration_ms: 100,
+      }, {
+        hypothesis: "cache hot path",
+        why: "within noise",
+        avoid: ["global cache"],
+        next: ["try local memo"],
+      })
+
+      const raw = await readFile(join(runDir, "ideas.md"), "utf-8")
+      expect(raw).toContain("# Ideas Backlog")
+      expect(raw).toContain("## Experiment #1 - discard")
+      expect(await readIdeasBacklogSummary(runDir)).toContain("try local memo")
+    } finally {
+      await rm(runDir, { recursive: true, force: true })
+    }
+  })
+})

package/src/lib/ideas-backlog.ts

@@ -0,0 +1,109 @@
+import { appendFile } from "node:fs/promises"
+import { join } from "node:path"
+import type { ExperimentResult } from "./run.ts"
+
+export interface ExperimentNotes {
+  hypothesis?: string
+  why?: string
+  next?: string[]
+  avoid?: string[]
+}
+
+const BACKLOG_FILE = "ideas.md"
+const MAX_FIELD_LENGTH = 500
+const MAX_ITEMS = 5
+
+function cleanText(value: unknown): string | undefined {
+  if (typeof value !== "string") return undefined
+  const normalized = value.replace(/\s+/g, " ").trim()
+  if (!normalized) return undefined
+  return normalized.slice(0, MAX_FIELD_LENGTH)
+}
+
+function cleanList(value: unknown): string[] | undefined {
+  if (!Array.isArray(value)) return undefined
+  const items = value
+    .map(cleanText)
+    .filter((item): item is string => item != null)
+    .slice(0, MAX_ITEMS)
+  return items.length > 0 ? items : undefined
+}
+
+export function parseExperimentNotes(text: string): ExperimentNotes | undefined {
+  const match = text.match(/<autoauto_notes>\s*([\s\S]*?)\s*<\/autoauto_notes>/)
+  if (!match) return undefined
+
+  try {
+    const raw = JSON.parse(match[1]) as Record<string, unknown>
+    const notes: ExperimentNotes = {
+      hypothesis: cleanText(raw.hypothesis),
+      why: cleanText(raw.why),
+      next: cleanList(raw.next),
+      avoid: cleanList(raw.avoid),
+    }
+    return Object.values(notes).some((value) => value != null) ? notes : undefined
+  } catch {
+    return undefined
+  }
+}
+
+function listLines(items: string[] | undefined, fallback: string): string[] {
+  if (!items || items.length === 0) return [`  - ${fallback}`]
+  return items.map((item) => `  - ${item}`)
+}
+
+function formatEntry(result: ExperimentResult, notes?: ExperimentNotes): string {
+  const tried = notes?.hypothesis ?? result.description
+  const agentNote = notes?.why ?? "No agent note captured."
+
+  return [
+    `## Experiment #${result.experiment_number} - ${result.status}`,
+    `- Commit: ${result.commit}`,
+    `- Metric: ${result.metric_value}`,
+    `- Result: ${result.description}`,
+    `- Tried: ${tried}`,
+    `- Agent note: ${agentNote}`,
+    "- Avoid:",
+    ...listLines(notes?.avoid, "No specific avoid note captured."),
+    "- Try next:",
+    ...listLines(notes?.next, "No specific next idea captured."),
+    "",
+  ].join("\n")
+}
+
+async function ensureHeader(runDir: string): Promise<void> {
+  const path = join(runDir, BACKLOG_FILE)
+  if (await Bun.file(path).exists()) return
+  await appendFile(
+      path,
+      [
+        "# Ideas Backlog",
+        "",
+        "Append-only experiment memory. Captures what was tried, why it worked or failed, and what to try next.",
+        "",
+      ].join("\n"),
+    )
+}
+
+export async function appendIdeasBacklog(
+  runDir: string,
+  result: ExperimentResult,
+  notes?: ExperimentNotes,
+): Promise<void> {
+  if (result.experiment_number === 0) return
+  await ensureHeader(runDir)
+  await appendFile(join(runDir, BACKLOG_FILE), formatEntry(result, notes))
+}
+
+export async function readIdeasBacklogSummary(runDir: string, maxChars = 4000): Promise<string> {
+  try {
+    const raw = await Bun.file(join(runDir, BACKLOG_FILE)).text()
+    if (raw.length <= maxChars) return raw.trim()
+
+    const tail = raw.slice(-maxChars)
+    const firstEntry = tail.indexOf("\n## ")
+    return (firstEntry >= 0 ? tail.slice(firstEntry + 1) : tail).trim()
+  } catch {
+    return ""
+  }
+}