From f7ceb03efe33e1568b87c56e4c2e943f97f82217 Mon Sep 17 00:00:00 2001 From: YeonGyu-Kim Date: Thu, 21 May 2026 01:19:16 +0900 Subject: [PATCH] refactor(packages): extract boulder-state package --- .omo/evidence/task-9-loc-check.txt | 12 + .omo/evidence/task-9-no-coupling.txt | 3 + .omo/evidence/task-9-tests.txt | 42 + .../package-layering-refactor/decisions.md | 9 + bun.lock | 10 + package.json | 6 +- packages/boulder-state/package.json | 21 + packages/boulder-state/src/constants.ts | 8 + packages/boulder-state/src/index.ts | 42 + packages/boulder-state/src/storage/index.ts | 15 + packages/boulder-state/src/storage/path.ts | 41 + .../src/storage/plan-progress.ts | 105 ++ .../boulder-state/src/storage/read-state.ts | 169 +++ packages/boulder-state/src/storage/session.ts | 93 ++ packages/boulder-state/src/storage/shared.ts | 86 ++ packages/boulder-state/src/storage/task.ts | 167 +++ .../boulder-state/src/storage/write-state.ts | 190 ++++ packages/boulder-state/src/top-level-task.ts | 69 ++ packages/boulder-state/src/types.ts | 79 ++ packages/boulder-state/tsconfig.json | 14 + src/features/boulder-state/constants.ts | 21 +- src/features/boulder-state/storage.ts | 1006 +---------------- src/features/boulder-state/top-level-task.ts | 79 +- src/features/boulder-state/types.ts | 118 +- 24 files changed, 1228 insertions(+), 1177 deletions(-) create mode 100644 .omo/evidence/task-9-loc-check.txt create mode 100644 .omo/evidence/task-9-no-coupling.txt create mode 100644 .omo/evidence/task-9-tests.txt create mode 100644 packages/boulder-state/package.json create mode 100644 packages/boulder-state/src/constants.ts create mode 100644 packages/boulder-state/src/index.ts create mode 100644 packages/boulder-state/src/storage/index.ts create mode 100644 packages/boulder-state/src/storage/path.ts create mode 100644 packages/boulder-state/src/storage/plan-progress.ts create mode 100644 packages/boulder-state/src/storage/read-state.ts create mode 100644 packages/boulder-state/src/storage/session.ts create mode 100644 packages/boulder-state/src/storage/shared.ts create mode 100644 packages/boulder-state/src/storage/task.ts create mode 100644 packages/boulder-state/src/storage/write-state.ts create mode 100644 packages/boulder-state/src/top-level-task.ts create mode 100644 packages/boulder-state/src/types.ts create mode 100644 packages/boulder-state/tsconfig.json diff --git a/.omo/evidence/task-9-loc-check.txt b/.omo/evidence/task-9-loc-check.txt new file mode 100644 index 000000000..8b7bf4d7f --- /dev/null +++ b/.omo/evidence/task-9-loc-check.txt @@ -0,0 +1,12 @@ +169 packages/boulder-state/src/storage/write-state.ts +147 packages/boulder-state/src/storage/task.ts +141 packages/boulder-state/src/storage/read-state.ts +88 packages/boulder-state/src/storage/plan-progress.ts +79 packages/boulder-state/src/storage/session.ts +74 packages/boulder-state/src/storage/shared.ts +73 packages/boulder-state/src/types.ts +57 packages/boulder-state/src/top-level-task.ts +42 packages/boulder-state/src/index.ts +34 packages/boulder-state/src/storage/path.ts +15 packages/boulder-state/src/storage/index.ts +6 packages/boulder-state/src/constants.ts diff --git a/.omo/evidence/task-9-no-coupling.txt b/.omo/evidence/task-9-no-coupling.txt new file mode 100644 index 000000000..0664b69e7 --- /dev/null +++ b/.omo/evidence/task-9-no-coupling.txt @@ -0,0 +1,3 @@ +grep pattern: OpenCode +scope: packages/boulder-state/src/**/*.ts +result: no matches diff --git a/.omo/evidence/task-9-tests.txt b/.omo/evidence/task-9-tests.txt new file mode 100644 index 000000000..bf7f67028 --- /dev/null +++ b/.omo/evidence/task-9-tests.txt @@ -0,0 +1,42 @@ +bun test v1.3.12 (700fc117) + +src/features/opencode-skill-loader/skill-content.test.ts: +213 | +214 | // when: resolving by ambiguous short name +215 | const result = await resolveSkillContentAsync("debugging") +216 | +217 | // then: ambiguous => null +218 | expect(result).toBeNull() + ^ +error: expect(received).toBeNull() + +Received: "# Debugging\n\nYou are a hypothesis-driven debugger. Two disciplines apply regardless of language, runtime, or whether you have source:\n\n1. **Runtime truth beats code reading.** Every claim about why the bug happens must come from observed state β€” never from a plausible story spun from reading code.\n2. **Leave no trace.** Debugging creates artifacts. Every artifact is journaled and removed before you call the task done.\n\nThe rest of this file is a map. **The knowledge is in `references/`.** This file cannot teach you how to debug β€” it can only tell you which reference will, for your exact situation.\n\n---\n\n# 🚨 READ THE REFERENCES. THIS IS NOT OPTIONAL.\n\n> **This skill is intentionally small.** Ninety percent of what you need to know lives in `references/`. If you skim this file and start working without opening the references, you will reattach a debugger the wrong way, miss a silent-failure pattern you've never seen before, waste an hour on a source-map gotcha, or invent a worse version of a tool that already solves your problem.\n>\n> **Every reference below is mandatory when its scenario applies.** \"I know this language\" is not an exemption. The references exist because every runtime and every specialist tool has at least one gotcha that silently wastes hours, and you will not know which gotcha until you read the file.\n>\n> **The gate rule**: before you run a command from a given reference's domain, you must have read that reference in this session. Re-reading across sessions is cheap. Guessing is expensive.\n\n---\n\n## Runtime Setup β€” MANDATORY READING BEFORE ATTACHING\n\nThe methodology is language-agnostic. The commands to launch, attach, breakpoint, and inspect are not. **Open the matching reference before Phase 0. Not during. Not after.**\n\n| Your runtime is… | Open this before attaching anything | Non-negotiable because… |\n|---|---|---|\n| Python (CPython, pytest, asyncio, Django, FastAPI) | πŸ“– **[references/runtimes/python.md](references/runtimes/python.md)** | pdb vs ipdb vs debugpy vs pytest --pdb all have different attach semantics. Async code needs special breakpoint handling. Wrappers like `poetry run` swallow flags. |\n| Node.js / tsx / ts-node / Bun / Deno (running source) | πŸ“– **[references/runtimes/node.md](references/runtimes/node.md)** | `tsx` + `node inspect` CLI has a **silent source-map failure** β€” breakpoints by line number do not fire. You will not notice unless you read this first. |\n| Rust (cargo, tokio, panics) | πŸ“– **[references/runtimes/rust.md](references/runtimes/rust.md)** | Release builds strip symbols. Tokio tasks need `tokio-console`. The borrow checker makes `dbg!` the faster tool most of the time. |\n| Go (goroutines, dlv, pprof, race) | πŸ“– **[references/runtimes/go.md](references/runtimes/go.md)** | Goroutine leaks and recovered panics are silent by default. `dlv` has a specific port convention. `go test -race` is the first thing to run, not the last. |\n| Native binary / stripped C/C++ / no source | πŸ“– **[references/runtimes/native-binary.md](references/runtimes/native-binary.md)** | The workflow (triage β†’ dynamic β†’ static β†’ scripted repro) is counterintuitive if you've never done it. `strings -n 8` silently drops short interpolations like `${x}` β€” read bytes directly for any extraction that matters. macOS adds SIP / Mach-O / lldb specifics that don't apply on Linux. |\n| **Bundled-app binary** (Bun SEA, Node SEA, Deno compile, pkg, nexe, Electron, Tauri, PyInstaller) | πŸ“– **[references/runtimes/bundled-js-binary.md](references/runtimes/bundled-js-binary.md)** | These look like Mach-O / ELF but their *high-level* source is recoverable with the right per-bundler tool β€” Ghidra is overkill. Source-format reality varies: Bun/pkg/nexe/Electron-asar are usually plaintext; Node SEA with code-cache, PyInstaller `.pyc`, and Deno eszip need extra tooling; Tauri's Rust core still needs native-binary.md. Workflow: identify bundler β†’ locate bundle β†’ extract with the bundler-specific tool β†’ grep. |\n\n**If you cannot honestly say you just opened the reference for your runtime, open it now.**\n\n> 🚨 **Native binary vs bundled binary β€” check before committing**: `file ./target` calls them both Mach-O / ELF. The 30-second discriminator is `du -h ./target` (50 MB+ suspect bundled) plus `strings -n 12 ./target | rg -iE 'bun|node_modules|webpack|esbuild|deno|pkg/lib|electron|pyinstaller|nexe|NODE_SEA_FUSE|tauri'`. If hits β†’ bundled-js-binary.md. If clean β†’ native-binary.md.\n\n---\n\n## Specialist Tools β€” ACTIVELY USE WHEN THE SCENARIO FITS\n\nThese are not \"optional extras\". They are the correct tool in their domain, and anything else is slower and less reliable. **If the bug fits the domain, you MUST use the tool. Read the reference first to know how.**\n\n| Tool | Use when | Reference |\n|---|---|---|\n| **Playwright CLI** | Any browser-served web UI bug. Any flow that requires clicking/typing/navigating. Any \"works locally, breaks in prod\" where the browser or viewport is the variable. **For Phase 8 QA of any browser product, you MUST drive a real browser via Playwright β€” not curl, not imagination.** | πŸ“– **[references/tools/playwright-cli.md](references/tools/playwright-cli.md)** |\n| **Ghidra** | Any binary without trustworthy source β€” third-party closed libs, malware, vendored binaries whose behavior contradicts docs, CTF, firmware. **Use Ghidra's decompiler before `strings`/`objdump` guessing. It turns machine code into readable C.** | πŸ“– **[references/tools/ghidra.md](references/tools/ghidra.md)** |\n| **pwndbg** | Any native binary debugging session. It is GDB with the useful views (registers, stack, disasm, heap) always visible. **If you'd reach for plain `gdb`, reach for `pwndbg` instead β€” it is strictly a superset.** | πŸ“– **[references/tools/pwndbg.md](references/tools/pwndbg.md)** |\n| **pwntools** | Any time you need a reproducible interaction with a binary or network service β€” crafted payloads, exploit automation, fuzz harness, CTF scripting. | πŸ“– **[references/tools/pwntools.md](references/tools/pwntools.md)** |\n\n**Failing to use these tools in their domain is a process failure, not a stylistic choice.** If the bug is in a browser and you did Phase 8 without Playwright, you are doing it wrong. If the bug is in a stripped binary and you read hex with `xxd`, you are doing it wrong. The references tell you how. Read them.\n\n---\n\n## The Phase Loop β€” READ THE REFERENCE FOR THE PHASE YOU ARE ENTERING\n\nEach phase has exactly one reference. Read it as you enter the phase β€” not in advance, not from memory. The references are self-contained and short.\n\n| # | Phase | πŸ“– Open this when entering |\n|---|---|---|\n| 0 | **Environment assessment** β€” know the runtime, ports, symbols, env vars, watchers before attaching | [references/methodology/00-setup.md](references/methodology/00-setup.md) |\n| 1 | **Journal setup** β€” single `.debug-journal.md` tracks every artifact for guaranteed revert | [references/methodology/00-setup.md](references/methodology/00-setup.md) |\n| 2 | **Hypothesis formation** β€” minimum three, across orthogonal axes, each with distinguishing evidence | [references/methodology/02-investigate.md](references/methodology/02-investigate.md) |\n| 3 | **Parallel investigation** β€” team mode `debug-squad` when enabled, async subagents otherwise | [references/methodology/02-investigate.md](references/methodology/02-investigate.md) |\n| 4 | **Oracle Triple** β€” after 2 consecutive failed rounds, spawn three Oracles with orthogonal framings and synthesize | [references/methodology/04-oracle-triple.md](references/methodology/04-oracle-triple.md) |\n| 5 | **User decision escalation** β€” only when evidence exhausted and the call has policy implications | [references/methodology/05-escalate.md](references/methodology/05-escalate.md) |\n| 6 | **Root cause confirmation** β€” confirmed only when toggling the suspected cause toggles the bug | [references/methodology/06-fix.md](references/methodology/06-fix.md) |\n| 7 | **TDD fix** β€” red test first, minimal green, no scope expansion | [references/methodology/06-fix.md](references/methodology/06-fix.md) |\n| 8 | **Manual QA** β€” actually use the system (tmux for CLI, Playwright for browser, real curl for API, real repro for binary) | [references/methodology/08-qa.md](references/methodology/08-qa.md) |\n| 9 | **Cleanup** β€” walk the journal, revert every artifact, verify `git diff` shows only fix + test | [references/methodology/09-cleanup.md](references/methodology/09-cleanup.md) |\n| 10 | **Final verification** β€” four evidence gates before declaring done | [references/methodology/09-cleanup.md](references/methodology/09-cleanup.md) |\n\n**Phase references are short by design.** Reading one takes a minute. Skipping one costs an hour.\n\n### Cross-cutting methodology references\n\nThese are not phases β€” read them when the situation calls for them:\n\n| Situation | Reference |\n|---|---|\n| You cannot run the actual operation (paid API, blocked network, missing hardware) but still need runtime evidence | πŸ“– **[references/methodology/partial-runtime-evidence.md](references/methodology/partial-runtime-evidence.md)** |\n| You're about to declare an extraction / audit / reverse-engineering task done and want a skeptical pass | πŸ“– **[references/methodology/partial-runtime-evidence.md#verification-oracle-pattern-for-non-debug-tasks](references/methodology/partial-runtime-evidence.md#verification-oracle-pattern-for-non-debug-tasks)** (Verification Oracle is *not* the same as Oracle Triple β€” read the file) |\n\n---\n\n## Non-Negotiable Safety Invariants\n\n\n1. **Runtime state is the only source of truth.** A hypothesis without an observed value is a guess. Do not fix guesses.\n2. **Every debug artifact is journaled before it is created.** Journal-then-modify, not modify-then-remember-maybe.\n3. **Never ship a fix without a failing-first test.** Redβ†’green transition required, or the fix is unverified.\n4. **Never declare done on type-check/compile alone.** Types catch declaration bugs. Only running the actual user scenario catches the actual user bug.\n5. **Never ask the user a question that runtime evidence can already answer.** Escalation is for genuine ambiguity.\n6. **Never silently swallow errors while debugging.** If the system swallows errors, that is often the bug itself. Make them loud temporarily; restore at cleanup.\n7. **Never `git commit` from inside this skill.** Commits belong to `/git-master` after the user confirms the fix.\n8. **Never attach without having read the runtime reference.** The gate rule.\n\n\n---\n\n## What to Do Right Now\n\n1. Read the user's bug description.\n2. Identify the runtime.\n3. **Open `references/runtimes/.md`.** Read it.\n4. Identify which specialist tools apply. **Open each matching `references/tools/*.md`.** Read them.\n5. Open `references/methodology/00-setup.md` and start Phase 0.\n6. Follow the phase loop. Read each methodology reference as you enter the phase.\n\n**The references are the skill. This file is an index.**" + + at (/Users/yeongyu/local-workspaces/omo/.local-ignore/wt-t9-boulder-state/src/features/opencode-skill-loader/skill-content.test.ts:218:18) +(fail) resolveSkillContentAsync > returns null for ambiguous short name async [14.30ms] +459 | +460 | // when: resolving ambiguous short name with builtin +461 | const result = await resolveMultipleSkillsAsync(["debugging", "playwright"]) +462 | +463 | // then: debugging not found, playwright resolved +464 | expect(result.resolved.size).toBe(1) + ^ +error: expect(received).toBe(expected) + +Expected: 1 +Received: 2 + + at (/Users/yeongyu/local-workspaces/omo/.local-ignore/wt-t9-boulder-state/src/features/opencode-skill-loader/skill-content.test.ts:464:32) +(fail) resolveMultipleSkillsAsync > does not resolve ambiguous short name in batch [24.15ms] + + βš™ read_file filePath=/src/index.ts + +src/__tests__/perf/plugin-init.test.ts: +empty-project: cold=30.8ms warm=[13.8, 11.2] median=13.8ms +in-tree-fixture: cold=26.5ms warm=[14.0, 19.2] median=19.2ms + + 7312 pass + 1 skip + 2 fail + 24 snapshots, 16703 expect() calls +Ran 7315 tests across 744 files. [181.20s] diff --git a/.omo/notepads/package-layering-refactor/decisions.md b/.omo/notepads/package-layering-refactor/decisions.md index 37290190a..846dc7ef0 100644 --- a/.omo/notepads/package-layering-refactor/decisions.md +++ b/.omo/notepads/package-layering-refactor/decisions.md @@ -8,3 +8,12 @@ Net effect: utils package ships 12 files instead of 13. Choice: Option A Reason: Small call-site surface; keeps full jsonc-parser API together in the new package and avoids split ownership. Call sites changed: src/plugin-config.ts, src/cli/config-manager/config-context.ts, src/cli/doctor/checks/config.ts, src/cli/doctor/checks/model-resolution-config.ts, src/cli/doctor/checks/team-mode.ts, src/cli/doctor/checks/tools-lsp.ts, src/shared/project-discovery-dirs.ts, packages/utils/src/jsonc-parser.test.ts, packages/utils/src/jsonc-parser.memoization.test.ts + +## [2026-05-21T02:05:00Z] Task 9 (worktree) +storage.ts split plan (from 977 LOC monolith): +- `storage/shared.ts`: constants, timestamp/parsing helpers, mirror<->work projection, state normalization. +- `storage/read.ts`: path resolution, file read/parse, plan discovery/progress parsing, read-only selectors. +- `storage/write.ts`: persist/clear, create state/work IDs, active work selection, work lifecycle updates. +- `storage/session.ts`: session-id tracking append logic (global + per-work). +- `storage/task.ts`: task-session CRUD and timer transitions. +- `storage/index.ts`: public API barrel with explicit named exports (no wildcard export). diff --git a/bun.lock b/bun.lock index 8ecdd20a2..0f541a084 100644 --- a/bun.lock +++ b/bun.lock @@ -26,6 +26,7 @@ "devDependencies": { "@oh-my-opencode/ast-grep-core": "workspace:*", "@oh-my-opencode/ast-grep-mcp": "workspace:*", + "@oh-my-opencode/boulder-state": "workspace:*", "@oh-my-opencode/comment-checker-core": "workspace:*", "@oh-my-opencode/rules-core": "workspace:*", "@oh-my-opencode/utils": "workspace:*", @@ -71,6 +72,13 @@ "bun-types": "1.3.12", }, }, + "packages/boulder-state": { + "name": "@oh-my-opencode/boulder-state", + "version": "0.1.0", + "dependencies": { + "@oh-my-opencode/utils": "workspace:*", + }, + }, "packages/comment-checker-core": { "name": "@oh-my-opencode/comment-checker-core", "version": "0.1.0", @@ -166,6 +174,8 @@ "@oh-my-opencode/ast-grep-mcp": ["@oh-my-opencode/ast-grep-mcp@workspace:packages/ast-grep-mcp"], + "@oh-my-opencode/boulder-state": ["@oh-my-opencode/boulder-state@workspace:packages/boulder-state"], + "@oh-my-opencode/comment-checker-core": ["@oh-my-opencode/comment-checker-core@workspace:packages/comment-checker-core"], "@oh-my-opencode/rules-core": ["@oh-my-opencode/rules-core@workspace:packages/rules-core"], diff --git a/package.json b/package.json index d4ca6eb4e..f26345525 100644 --- a/package.json +++ b/package.json @@ -10,7 +10,8 @@ "packages/ast-grep-core", "packages/ast-grep-mcp", "packages/utils", - "packages/comment-checker-core" + "packages/comment-checker-core", + "packages/boulder-state" ], "bin": { "oh-my-opencode": "bin/oh-my-opencode.js", @@ -45,7 +46,7 @@ "prepublishOnly": "bun run clean && bun run build:lsp-tools-mcp && bun run build", "test:model-capabilities": "bun test src/shared/model-capability-aliases.test.ts src/shared/model-capability-guardrails.test.ts src/shared/model-capabilities.test.ts src/cli/doctor/checks/model-resolution.test.ts --bail", "typecheck": "tsgo --noEmit && bun run typecheck:packages", - "typecheck:packages": "tsgo --noEmit -p packages/rules-core/tsconfig.json && tsgo --noEmit -p packages/ast-grep-core/tsconfig.json && tsgo --noEmit -p packages/ast-grep-mcp/tsconfig.json && tsgo --noEmit -p packages/utils/tsconfig.json && tsgo --noEmit -p packages/comment-checker-core/tsconfig.json", + "typecheck:packages": "tsgo --noEmit -p packages/rules-core/tsconfig.json && tsgo --noEmit -p packages/ast-grep-core/tsconfig.json && tsgo --noEmit -p packages/ast-grep-mcp/tsconfig.json && tsgo --noEmit -p packages/utils/tsconfig.json && tsgo --noEmit -p packages/comment-checker-core/tsconfig.json && tsgo --noEmit -p packages/boulder-state/tsconfig.json", "typecheck:script": "tsgo --noEmit -p script/tsconfig.json", "test": "bun test", "build:ast-grep-mcp": "bun run --cwd packages/ast-grep-mcp build" @@ -91,6 +92,7 @@ "devDependencies": { "@oh-my-opencode/ast-grep-core": "workspace:*", "@oh-my-opencode/ast-grep-mcp": "workspace:*", + "@oh-my-opencode/boulder-state": "workspace:*", "@oh-my-opencode/comment-checker-core": "workspace:*", "@oh-my-opencode/rules-core": "workspace:*", "@oh-my-opencode/utils": "workspace:*", diff --git a/packages/boulder-state/package.json b/packages/boulder-state/package.json new file mode 100644 index 000000000..173c9ebde --- /dev/null +++ b/packages/boulder-state/package.json @@ -0,0 +1,21 @@ +{ + "name": "@oh-my-opencode/boulder-state", + "version": "0.1.0", + "type": "module", + "private": true, + "description": "Pure TypeScript boulder work-tracking state machine for oh-my-opencode.", + "exports": { + ".": { + "types": "./index.d.ts", + "import": "./src/index.ts" + } + }, + "types": "./index.d.ts", + "scripts": { + "typecheck": "tsgo --noEmit -p tsconfig.json", + "test": "bun test src/*.test.ts" + }, + "dependencies": { + "@oh-my-opencode/utils": "workspace:*" + } +} diff --git a/packages/boulder-state/src/constants.ts b/packages/boulder-state/src/constants.ts new file mode 100644 index 000000000..cbfe8ad80 --- /dev/null +++ b/packages/boulder-state/src/constants.ts @@ -0,0 +1,8 @@ +export const BOULDER_DIR = ".omo" +export const BOULDER_FILE = "boulder.json" +export const BOULDER_STATE_PATH = `${BOULDER_DIR}/${BOULDER_FILE}` + +export const NOTEPAD_DIR = "notepads" +export const NOTEPAD_BASE_PATH = `${BOULDER_DIR}/${NOTEPAD_DIR}` + +export const PROMETHEUS_PLANS_DIR = ".omo/plans" diff --git a/packages/boulder-state/src/index.ts b/packages/boulder-state/src/index.ts new file mode 100644 index 000000000..604c4a423 --- /dev/null +++ b/packages/boulder-state/src/index.ts @@ -0,0 +1,42 @@ +export { BOULDER_DIR, BOULDER_FILE, BOULDER_STATE_PATH, NOTEPAD_BASE_PATH, NOTEPAD_DIR, PROMETHEUS_PLANS_DIR } from "./constants" +export { readCurrentTopLevelTask } from "./top-level-task" +export { + addBoulderWork, + appendSessionId, + appendSessionIdForWork, + clearBoulderState, + completeBoulder, + createBoulderState, + endTaskTimer, + findPrometheusPlans, + generateWorkId, + getActiveWorks, + getBoulderFilePath, + getBoulderWorks, + getPlanName, + getPlanProgress, + getTaskSessionState, + getWorkById, + getWorkByPlanName, + getWorkForSession, + getWorkResumeOptions, + readBoulderState, + resolveBoulderPlanPath, + resolveBoulderPlanPathForWork, + selectActiveWork, + startTaskTimer, + upsertTaskSessionState, + upsertTaskSessionStateForWork, + writeBoulderState, +} from "./storage" +export type { + BoulderSessionOrigin, + BoulderState, + BoulderTaskStatus, + BoulderWorkResumeOption, + BoulderWorkState, + BoulderWorkStatus, + PlanProgress, + TaskSessionState, + TopLevelTaskRef, +} from "./types" diff --git a/packages/boulder-state/src/storage/index.ts b/packages/boulder-state/src/storage/index.ts new file mode 100644 index 000000000..c17fbe2d6 --- /dev/null +++ b/packages/boulder-state/src/storage/index.ts @@ -0,0 +1,15 @@ +export { getBoulderFilePath, resolveBoulderPlanPath, resolveBoulderPlanPathForWork } from "./path" +export { findPrometheusPlans, getPlanName, getPlanProgress } from "./plan-progress" +export { + getActiveWorks, + getBoulderWorks, + getTaskSessionState, + getWorkById, + getWorkByPlanName, + getWorkForSession, + getWorkResumeOptions, + readBoulderState, +} from "./read-state" +export { appendSessionId, appendSessionIdForWork } from "./session" +export { endTaskTimer, startTaskTimer, upsertTaskSessionState, upsertTaskSessionStateForWork } from "./task" +export { addBoulderWork, clearBoulderState, completeBoulder, createBoulderState, generateWorkId, selectActiveWork, writeBoulderState } from "./write-state" diff --git a/packages/boulder-state/src/storage/path.ts b/packages/boulder-state/src/storage/path.ts new file mode 100644 index 000000000..dfb3f0539 --- /dev/null +++ b/packages/boulder-state/src/storage/path.ts @@ -0,0 +1,41 @@ +import { existsSync } from "node:fs" +import { isAbsolute, join, relative, resolve } from "node:path" + +import { BOULDER_DIR, BOULDER_FILE } from "../constants" +import type { BoulderState, BoulderWorkState } from "../types" + +export function getBoulderFilePath(directory: string): string { + return join(directory, BOULDER_DIR, BOULDER_FILE) +} + +function resolveTrackedPath(baseDirectory: string, trackedPath: string): string { + return isAbsolute(trackedPath) ? resolve(trackedPath) : resolve(baseDirectory, trackedPath) +} + +export function resolveBoulderPlanPath( + directory: string, + state: Pick, +): string { + const absolutePlanPath = resolveTrackedPath(directory, state.active_plan) + const worktreePath = state.worktree_path?.trim() + if (!worktreePath) { + return absolutePlanPath + } + + const absoluteDirectory = resolve(directory) + const relativePlanPath = relative(absoluteDirectory, absolutePlanPath) + if (relativePlanPath.length === 0 || relativePlanPath.startsWith("..") || isAbsolute(relativePlanPath)) { + return absolutePlanPath + } + + const absoluteWorktreePath = resolveTrackedPath(directory, worktreePath) + const worktreePlanPath = resolve(absoluteWorktreePath, relativePlanPath) + return existsSync(worktreePlanPath) ? worktreePlanPath : absolutePlanPath +} + +export function resolveBoulderPlanPathForWork( + directory: string, + work: Pick, +): string { + return resolveBoulderPlanPath(directory, work) +} diff --git a/packages/boulder-state/src/storage/plan-progress.ts b/packages/boulder-state/src/storage/plan-progress.ts new file mode 100644 index 000000000..fb8f40b1e --- /dev/null +++ b/packages/boulder-state/src/storage/plan-progress.ts @@ -0,0 +1,105 @@ +import { existsSync, readFileSync, readdirSync, statSync } from "node:fs" +import { basename, join } from "node:path" + +import { PROMETHEUS_PLANS_DIR } from "../constants" +import type { PlanProgress } from "../types" + +const TODO_HEADING_PATTERN = /^##\s+TODOs\b/i +const FINAL_VERIFICATION_HEADING_PATTERN = /^##\s+Final Verification Wave\b/i +const SECOND_LEVEL_HEADING_PATTERN = /^##\s+/ +const UNCHECKED_CHECKBOX_PATTERN = /^(\s*)[-*]\s*\[\s*\]\s*(.+)$/ +const CHECKED_CHECKBOX_PATTERN = /^(\s*)[-*]\s*\[[xX]\]\s*(.+)$/ +const TODO_TASK_PATTERN = /^\d+\.\s+/ +const FINAL_WAVE_TASK_PATTERN = /^F\d+\.\s+/i + +type ProgressSection = "todo" | "final-wave" | "other" + +export function findPrometheusPlans(directory: string): string[] { + const plansDir = join(directory, PROMETHEUS_PLANS_DIR) + if (!existsSync(plansDir)) { + return [] + } + + try { + return readdirSync(plansDir) + .filter((file) => file.endsWith(".md")) + .map((file) => join(plansDir, file)) + .sort((left, right) => statSync(right).mtimeMs - statSync(left).mtimeMs) + } catch { + return [] + } +} + +export function getPlanName(planPath: string): string { + return basename(planPath, ".md") +} + +export function getPlanProgress(planPath: string): PlanProgress { + if (!existsSync(planPath)) { + return { total: 0, completed: 0, isComplete: false } + } + + try { + const content = readFileSync(planPath, "utf-8") + const lines = content.split(/\r?\n/) + const hasStructuredSections = lines.some( + (line) => TODO_HEADING_PATTERN.test(line) || FINAL_VERIFICATION_HEADING_PATTERN.test(line), + ) + if (hasStructuredSections) { + return getStructuredPlanProgress(lines) + } + + return getSimplePlanProgress(content) + } catch { + return { total: 0, completed: 0, isComplete: false } + } +} + +function getStructuredPlanProgress(lines: string[]): PlanProgress { + let section: ProgressSection = "other" + let total = 0 + let completed = 0 + + for (const line of lines) { + if (SECOND_LEVEL_HEADING_PATTERN.test(line)) { + section = TODO_HEADING_PATTERN.test(line) + ? "todo" + : FINAL_VERIFICATION_HEADING_PATTERN.test(line) + ? "final-wave" + : "other" + continue + } + + if (section !== "todo" && section !== "final-wave") { + continue + } + + const checkedMatch = line.match(CHECKED_CHECKBOX_PATTERN) + const uncheckedMatch = checkedMatch ? null : line.match(UNCHECKED_CHECKBOX_PATTERN) + const match = checkedMatch ?? uncheckedMatch + if (!match || match[1].length > 0) { + continue + } + + const taskBody = match[2].trim() + const labelPattern = section === "todo" ? TODO_TASK_PATTERN : FINAL_WAVE_TASK_PATTERN + if (!labelPattern.test(taskBody)) { + continue + } + + total += 1 + if (checkedMatch) { + completed += 1 + } + } + + return { total, completed, isComplete: total > 0 && completed === total } +} + +function getSimplePlanProgress(content: string): PlanProgress { + const uncheckedMatches = content.match(/^[-*]\s*\[\s*\]/gm) ?? [] + const checkedMatches = content.match(/^[-*]\s*\[[xX]\]/gm) ?? [] + const total = uncheckedMatches.length + checkedMatches.length + const completed = checkedMatches.length + return { total, completed, isComplete: total > 0 && completed === total } +} diff --git a/packages/boulder-state/src/storage/read-state.ts b/packages/boulder-state/src/storage/read-state.ts new file mode 100644 index 000000000..ee5d3f60d --- /dev/null +++ b/packages/boulder-state/src/storage/read-state.ts @@ -0,0 +1,169 @@ +import { existsSync, readFileSync } from "node:fs" + +import type { BoulderState, BoulderWorkResumeOption, BoulderWorkState, TaskSessionState } from "../types" +import { getBoulderFilePath, resolveBoulderPlanPathForWork } from "./path" +import { getPlanProgress } from "./plan-progress" +import { buildWorkFromMirror, isValidWorkStatus, parseIsoToMs, projectWorkToMirror, selectMirrorWork } from "./shared" + +export function readBoulderState(directory: string): BoulderState | null { + const filePath = getBoulderFilePath(directory) + if (!existsSync(filePath)) { + return null + } + + try { + const content = readFileSync(filePath, "utf-8") + const parsed = JSON.parse(content) + if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) { + return null + } + + normalizeState(parsed) + const state = parsed as BoulderState + const mirrorWork = selectMirrorWork(state) + if (mirrorWork) { + state.active_work_id = mirrorWork.work_id + projectWorkToMirror(state, mirrorWork) + } + + return state + } catch { + return null + } +} + +function normalizeState(state: Record): void { + const sessionIds = Array.isArray(state.session_ids) ? state.session_ids : [] + state.session_ids = sessionIds + + const sessionOrigins = state.session_origins && typeof state.session_origins === "object" && !Array.isArray(state.session_origins) + ? (state.session_origins as Record) + : {} + state.session_origins = sessionOrigins + + if (sessionIds.length === 1) { + const soleSessionId = sessionIds[0] + if ( + typeof soleSessionId === "string" + && sessionOrigins[soleSessionId] !== "appended" + && sessionOrigins[soleSessionId] !== "direct" + ) { + sessionOrigins[soleSessionId] = "direct" + } + } + + if (!state.task_sessions || typeof state.task_sessions !== "object" || Array.isArray(state.task_sessions)) { + state.task_sessions = {} + } +} + +export function getBoulderWorks(state: BoulderState): BoulderWorkState[] { + if (state.works && typeof state.works === "object") { + return Object.values(state.works) + } + + if (!state.active_plan || !state.plan_name || !state.started_at) { + return [] + } + + return [buildWorkFromMirror(state)] +} + +export function getActiveWorks(directory: string): BoulderWorkState[] { + const state = readBoulderState(directory) + if (!state) { + return [] + } + + return getBoulderWorks(state).filter((work) => work.status !== "completed" && work.status !== "abandoned") +} + +export function getWorkById(directory: string, workId: string): BoulderWorkState | null { + const state = readBoulderState(directory) + if (!state) { + return null + } + + return getBoulderWorks(state).find((work) => work.work_id === workId) ?? null +} + +export function getWorkByPlanName( + directory: string, + planName: string, + options?: { worktreePath?: string }, +): BoulderWorkState | null { + const state = readBoulderState(directory) + if (!state) { + return null + } + + const worktreePath = options?.worktreePath + return getBoulderWorks(state).find((work) => { + if (work.plan_name !== planName) { + return false + } + + return worktreePath ? work.worktree_path === worktreePath : true + }) ?? null +} + +export function getWorkForSession(directory: string, sessionId: string): BoulderWorkState | null { + const state = readBoulderState(directory) + if (!state) { + return null + } + + const works = getBoulderWorks(state) + .filter((work) => work.session_ids.includes(sessionId)) + .sort((left, right) => (parseIsoToMs(right.updated_at ?? right.started_at) ?? 0) - (parseIsoToMs(left.updated_at ?? left.started_at) ?? 0)) + + if (works.length > 0) { + return works[0] ?? null + } + + return state.session_ids.includes(sessionId) ? buildWorkFromMirror(state) : null +} + +export function getWorkResumeOptions(directory: string): BoulderWorkResumeOption[] { + const state = readBoulderState(directory) + if (!state) { + return [] + } + + return getBoulderWorks(state) + .filter((work) => work.status !== "completed" && work.status !== "abandoned") + .map((work) => { + const progress = getPlanProgress(resolveBoulderPlanPathForWork(directory, work)) + return { + work_id: work.work_id, + plan_name: work.plan_name, + active_plan: work.active_plan, + worktree_path: work.worktree_path, + status: work.status && isValidWorkStatus(work.status) ? work.status : "active", + started_at: work.started_at, + updated_at: work.updated_at ?? work.started_at, + ended_at: work.ended_at, + elapsed_ms: work.elapsed_ms, + session_count: work.session_ids.length, + progress, + is_current_mirror: state.active_work_id === work.work_id, + } + }) +} + +export function getTaskSessionState(directory: string, taskKey: string): TaskSessionState | null { + const state = readBoulderState(directory) + if (state?.active_work_id) { + const work = state.works?.[state.active_work_id] + const taskSession = work?.task_sessions?.[taskKey] + if (taskSession) { + return taskSession + } + } + + if (!state?.task_sessions) { + return null + } + + return state.task_sessions[taskKey] ?? null +} diff --git a/packages/boulder-state/src/storage/session.ts b/packages/boulder-state/src/storage/session.ts new file mode 100644 index 000000000..abecb8b21 --- /dev/null +++ b/packages/boulder-state/src/storage/session.ts @@ -0,0 +1,93 @@ +import type { BoulderSessionOrigin, BoulderState, BoulderWorkState } from "../types" +import { getBoulderWorks, readBoulderState } from "./read-state" +import { nowIsoString, projectWorkToMirror } from "./shared" +import { writeBoulderState } from "./write-state" + +export function appendSessionId( + directory: string, + sessionId: string, + origin: "direct" | "appended" = "direct", +): BoulderState | null { + const activeWorkId = readBoulderState(directory)?.active_work_id + if (activeWorkId) { + return appendSessionIdForWork(directory, activeWorkId, sessionId, origin) + } + + const state = readBoulderState(directory) + if (!state) { + return null + } + + if (!state.session_origins || typeof state.session_origins !== "object" || Array.isArray(state.session_origins)) { + state.session_origins = {} + } + + if (!state.session_ids?.includes(sessionId)) { + if (!Array.isArray(state.session_ids)) { + state.session_ids = [] + } + + const originalSessionIds = [...state.session_ids] + const originalSessionOrigins = { ...state.session_origins } + state.session_ids.push(sessionId) + state.session_origins[sessionId] = origin + if (writeBoulderState(directory, state)) { + return state + } + + state.session_ids = originalSessionIds + state.session_origins = originalSessionOrigins + return null + } + + if (!state.session_origins[sessionId]) { + state.session_origins[sessionId] = origin + if (!writeBoulderState(directory, state)) { + return null + } + } + + return state +} + +export function appendSessionIdForWork( + directory: string, + workId: string, + sessionId: string, + origin: BoulderSessionOrigin = "direct", +): BoulderState | null { + const state = readBoulderState(directory) + if (!state) { + return null + } + + const works = getBoulderWorks(state) + const targetWork = works.find((work) => work.work_id === workId) + if (!targetWork) { + return null + } + + const updatedWork: BoulderWorkState = { + ...targetWork, + session_ids: targetWork.session_ids.includes(sessionId) + ? [...targetWork.session_ids] + : [...targetWork.session_ids, sessionId], + session_origins: { ...(targetWork.session_origins ?? {}), [sessionId]: origin }, + updated_at: nowIsoString(), + } + + const nextState: BoulderState = { + ...state, + schema_version: 2, + works: { + ...Object.fromEntries(works.map((work) => [work.work_id, work])), + [workId]: updatedWork, + }, + } + + if (state.active_work_id === workId) { + projectWorkToMirror(nextState, updatedWork) + } + + return writeBoulderState(directory, nextState) ? nextState : null +} diff --git a/packages/boulder-state/src/storage/shared.ts b/packages/boulder-state/src/storage/shared.ts new file mode 100644 index 000000000..50fd89e7b --- /dev/null +++ b/packages/boulder-state/src/storage/shared.ts @@ -0,0 +1,86 @@ +import type { BoulderState, BoulderWorkState, BoulderWorkStatus } from "../types" + +export const RESERVED_KEYS = new Set(["__proto__", "prototype", "constructor"]) + +export function nowIsoString(): string { + return new Date().toISOString() +} + +export function parseIsoToMs(value: string | undefined): number | null { + if (!value) { + return null + } + + const parsed = Date.parse(value) + return Number.isNaN(parsed) ? null : parsed +} + +export function getElapsedMs(startedAt: string | undefined, endedAt: string | undefined): number | undefined { + const startedMs = parseIsoToMs(startedAt) + const endedMs = parseIsoToMs(endedAt) + if (startedMs === null || endedMs === null) { + return undefined + } + + return endedMs - startedMs +} + +export function isValidWorkStatus(status: unknown): status is BoulderWorkStatus { + return status === "active" || status === "completed" || status === "paused" || status === "abandoned" +} + +export function buildWorkFromMirror(state: BoulderState): BoulderWorkState { + const planName = state.plan_name ?? state.active_plan + const workId = `${planName}-legacy` + return { + work_id: workId, + active_plan: state.active_plan, + plan_name: planName, + status: state.status, + started_at: state.started_at, + ended_at: state.ended_at, + elapsed_ms: state.elapsed_ms, + updated_at: state.updated_at, + session_ids: Array.isArray(state.session_ids) ? [...state.session_ids] : [], + session_origins: state.session_origins, + agent: state.agent, + worktree_path: state.worktree_path, + task_sessions: state.task_sessions, + } +} + +export function projectWorkToMirror(state: BoulderState, work: BoulderWorkState): void { + state.active_plan = work.active_plan + state.plan_name = work.plan_name + state.status = work.status + state.started_at = work.started_at + state.ended_at = work.ended_at + state.elapsed_ms = work.elapsed_ms + state.updated_at = work.updated_at + state.session_ids = [...work.session_ids] + state.session_origins = work.session_origins ? { ...work.session_origins } : {} + state.agent = work.agent + state.worktree_path = work.worktree_path + state.task_sessions = work.task_sessions ? { ...work.task_sessions } : {} +} + +export function selectMirrorWork(state: BoulderState): BoulderWorkState | null { + const works = state.works ? Object.values(state.works) : [] + if (works.length === 0) { + return null + } + + if (state.active_work_id) { + const matched = works.find((work) => work.work_id === state.active_work_id) + if (matched) { + return matched + } + } + + const sorted = [...works].sort((left, right) => { + const leftMs = parseIsoToMs(left.updated_at ?? left.started_at) ?? 0 + const rightMs = parseIsoToMs(right.updated_at ?? right.started_at) ?? 0 + return rightMs - leftMs + }) + return sorted[0] ?? null +} diff --git a/packages/boulder-state/src/storage/task.ts b/packages/boulder-state/src/storage/task.ts new file mode 100644 index 000000000..c17fedd9b --- /dev/null +++ b/packages/boulder-state/src/storage/task.ts @@ -0,0 +1,167 @@ +import type { BoulderState, BoulderWorkState, TaskSessionState } from "../types" +import { getBoulderWorks, readBoulderState } from "./read-state" +import { getElapsedMs, nowIsoString, projectWorkToMirror, RESERVED_KEYS } from "./shared" +import { writeBoulderState } from "./write-state" + +export function upsertTaskSessionState( + directory: string, + input: { + taskKey: string + taskLabel: string + taskTitle: string + sessionId: string + agent?: string + category?: string + }, +): BoulderState | null { + const stateForWork = readBoulderState(directory) + if (stateForWork?.active_work_id) { + return upsertTaskSessionStateForWork(directory, stateForWork.active_work_id, input) + } + + const state = readBoulderState(directory) + if (!state || RESERVED_KEYS.has(input.taskKey)) { + return null + } + + const taskSessions = state.task_sessions ?? {} + taskSessions[input.taskKey] = { + task_key: input.taskKey, + task_label: input.taskLabel, + task_title: input.taskTitle, + session_id: input.sessionId, + ...(input.agent !== undefined ? { agent: input.agent } : {}), + ...(input.category !== undefined ? { category: input.category } : {}), + updated_at: nowIsoString(), + } + + state.task_sessions = taskSessions + return writeBoulderState(directory, state) ? state : null +} + +export function upsertTaskSessionStateForWork( + directory: string, + workId: string, + input: { + taskKey: string + taskLabel: string + taskTitle: string + sessionId: string + agent?: string + category?: string + }, +): BoulderState | null { + if (RESERVED_KEYS.has(input.taskKey)) { + return null + } + + const state = readBoulderState(directory) + if (!state) { + return null + } + + const works = getBoulderWorks(state) + const targetWork = works.find((work) => work.work_id === workId) + if (!targetWork) { + return null + } + + const previousTaskSession = targetWork.task_sessions?.[input.taskKey] + const nextTaskSession: TaskSessionState = { + task_key: input.taskKey, + task_label: input.taskLabel, + task_title: input.taskTitle, + session_id: input.sessionId, + ...(input.agent !== undefined ? { agent: input.agent } : {}), + ...(input.category !== undefined ? { category: input.category } : {}), + ...(previousTaskSession?.started_at !== undefined ? { started_at: previousTaskSession.started_at } : {}), + ...(previousTaskSession?.ended_at !== undefined ? { ended_at: previousTaskSession.ended_at } : {}), + ...(previousTaskSession?.elapsed_ms !== undefined ? { elapsed_ms: previousTaskSession.elapsed_ms } : {}), + ...(previousTaskSession?.status !== undefined ? { status: previousTaskSession.status } : {}), + updated_at: nowIsoString(), + } + + const nextWork: BoulderWorkState = { + ...targetWork, + task_sessions: { ...(targetWork.task_sessions ?? {}), [input.taskKey]: nextTaskSession }, + updated_at: nowIsoString(), + } + + const nextState: BoulderState = { + ...state, + schema_version: 2, + works: { + ...Object.fromEntries(works.map((work) => [work.work_id, work])), + [workId]: nextWork, + }, + } + + if (state.active_work_id === workId) { + projectWorkToMirror(nextState, nextWork) + } + + return writeBoulderState(directory, nextState) ? nextState : null +} + +export function startTaskTimer( + directory: string, + workId: string, + input: { + taskKey: string + taskLabel: string + taskTitle: string + sessionId: string + agent?: string + category?: string + startedAt?: string + }, +): BoulderState | null { + const nextState = upsertTaskSessionStateForWork(directory, workId, input) + if (!nextState) { + return null + } + + const work = nextState.works?.[workId] + const taskSession = work?.task_sessions?.[input.taskKey] + if (!work || !taskSession) { + return null + } + + const startedAt = taskSession.started_at ?? input.startedAt ?? nowIsoString() + taskSession.started_at = startedAt + taskSession.status = "running" + taskSession.updated_at = nowIsoString() + work.updated_at = nowIsoString() + return writeBoulderState(directory, nextState) ? nextState : null +} + +export function endTaskTimer( + directory: string, + workId: string, + taskKey: string, + endedAt?: string, +): BoulderState | null { + const state = readBoulderState(directory) + if (!state) { + return null + } + + const work = state.works?.[workId] ?? getBoulderWorks(state).find((candidate) => candidate.work_id === workId) + if (!work?.task_sessions?.[taskKey]) { + return null + } + + const taskSession = work.task_sessions[taskKey] + const endAt = endedAt ?? nowIsoString() + taskSession.ended_at = endAt + taskSession.elapsed_ms = getElapsedMs(taskSession.started_at, endAt) + taskSession.status = "completed" + taskSession.updated_at = nowIsoString() + work.updated_at = nowIsoString() + + if (state.active_work_id === workId) { + projectWorkToMirror(state, work) + } + + return writeBoulderState(directory, state) ? state : null +} diff --git a/packages/boulder-state/src/storage/write-state.ts b/packages/boulder-state/src/storage/write-state.ts new file mode 100644 index 000000000..1360b43ad --- /dev/null +++ b/packages/boulder-state/src/storage/write-state.ts @@ -0,0 +1,190 @@ +import { existsSync, mkdirSync, unlinkSync, writeFileSync } from "node:fs" +import { dirname } from "node:path" + +import type { BoulderState, BoulderWorkState } from "../types" +import { getBoulderFilePath } from "./path" +import { getPlanName } from "./plan-progress" +import { getBoulderWorks, readBoulderState } from "./read-state" +import { getElapsedMs, nowIsoString, projectWorkToMirror } from "./shared" + +export function writeBoulderState(directory: string, state: BoulderState): boolean { + const filePath = getBoulderFilePath(directory) + try { + const dir = dirname(filePath) + if (!existsSync(dir)) { + mkdirSync(dir, { recursive: true }) + } + + const stateToWrite: BoulderState = { ...state } + if (stateToWrite.works && stateToWrite.active_work_id) { + const activeWork = stateToWrite.works[stateToWrite.active_work_id] + if (activeWork) { + stateToWrite.works = { + ...stateToWrite.works, + [stateToWrite.active_work_id]: { + ...activeWork, + active_plan: stateToWrite.active_plan, + plan_name: stateToWrite.plan_name, + status: stateToWrite.status, + started_at: stateToWrite.started_at, + ended_at: stateToWrite.ended_at, + elapsed_ms: stateToWrite.elapsed_ms, + updated_at: stateToWrite.updated_at, + session_ids: [...stateToWrite.session_ids], + session_origins: stateToWrite.session_origins ? { ...stateToWrite.session_origins } : {}, + agent: stateToWrite.agent, + worktree_path: stateToWrite.worktree_path, + task_sessions: stateToWrite.task_sessions ? { ...stateToWrite.task_sessions } : {}, + }, + } + } + } + + writeFileSync(filePath, JSON.stringify(stateToWrite, null, 2), "utf-8") + return true + } catch { + return false + } +} + +export function clearBoulderState(directory: string): boolean { + const filePath = getBoulderFilePath(directory) + try { + if (existsSync(filePath)) { + unlinkSync(filePath) + } + return true + } catch { + return false + } +} + +export function generateWorkId(planName: string): string { + const slug = planName.trim().toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "") + const randomHex = Math.floor(Math.random() * 0xffffffff).toString(16).padStart(8, "0") + return `${slug.length > 0 ? slug : "work"}-${randomHex}` +} + +export function createBoulderState(planPath: string, sessionId: string, agent?: string, worktreePath?: string): BoulderState { + const startedAt = nowIsoString() + const workId = generateWorkId(getPlanName(planPath)) + const work: BoulderWorkState = { + work_id: workId, + active_plan: planPath, + plan_name: getPlanName(planPath), + status: "active", + started_at: startedAt, + updated_at: startedAt, + session_ids: [sessionId], + session_origins: { [sessionId]: "direct" }, + ...(agent !== undefined ? { agent } : {}), + ...(worktreePath !== undefined ? { worktree_path: worktreePath } : {}), + task_sessions: {}, + } + + return { + schema_version: 2, + active_work_id: workId, + works: { [workId]: work }, + active_plan: planPath, + started_at: startedAt, + status: "active", + updated_at: startedAt, + session_ids: [sessionId], + session_origins: { [sessionId]: "direct" }, + plan_name: getPlanName(planPath), + task_sessions: {}, + ...(agent !== undefined ? { agent } : {}), + ...(worktreePath !== undefined ? { worktree_path: worktreePath } : {}), + } +} + +export function selectActiveWork(directory: string, workId: string): BoulderState | null { + const state = readBoulderState(directory) + if (!state) { + return null + } + + const works = getBoulderWorks(state) + const nextWork = works.find((work) => work.work_id === workId) + if (!nextWork) { + return null + } + + const nextState: BoulderState = { + ...state, + schema_version: 2, + active_work_id: workId, + works: state.works ?? Object.fromEntries(works.map((work) => [work.work_id, work])), + } + projectWorkToMirror(nextState, nextWork) + return writeBoulderState(directory, nextState) ? nextState : null +} + +export function addBoulderWork( + directory: string, + input: { planPath: string; sessionId: string; agent?: string; worktreePath?: string; startedAt?: string }, +): BoulderState | null { + const state = readBoulderState(directory) + if (!state) { + return null + } + + const workId = generateWorkId(getPlanName(input.planPath)) + const startedAt = input.startedAt ?? nowIsoString() + const nextWork: BoulderWorkState = { + work_id: workId, + active_plan: input.planPath, + plan_name: getPlanName(input.planPath), + status: "active", + started_at: startedAt, + updated_at: startedAt, + session_ids: [input.sessionId], + session_origins: { [input.sessionId]: "direct" }, + ...(input.agent !== undefined ? { agent: input.agent } : {}), + ...(input.worktreePath !== undefined ? { worktree_path: input.worktreePath } : {}), + task_sessions: {}, + } + + const nextState: BoulderState = { + ...state, + schema_version: 2, + works: { ...Object.fromEntries(getBoulderWorks(state).map((work) => [work.work_id, work])), [workId]: nextWork }, + active_work_id: workId, + } + projectWorkToMirror(nextState, nextWork) + return writeBoulderState(directory, nextState) ? nextState : null +} + +export function completeBoulder(directory: string, workId?: string, endedAt?: string): BoulderState | null { + const state = readBoulderState(directory) + if (!state) { + return null + } + + const targetWorkId = workId ?? state.active_work_id + if (!targetWorkId) { + return null + } + + const work = state.works?.[targetWorkId] ?? getBoulderWorks(state).find((candidate) => candidate.work_id === targetWorkId) + if (!work) { + return null + } + + if (work.status === "completed" && work.ended_at !== undefined && work.elapsed_ms !== undefined) { + return state + } + + const endAt = endedAt ?? nowIsoString() + work.ended_at = endAt + work.elapsed_ms = getElapsedMs(work.started_at, endAt) + work.status = "completed" + work.updated_at = nowIsoString() + + if (state.active_work_id === targetWorkId) { + projectWorkToMirror(state, work) + } + + return writeBoulderState(directory, state) ? state : null +} diff --git a/packages/boulder-state/src/top-level-task.ts b/packages/boulder-state/src/top-level-task.ts new file mode 100644 index 000000000..faa831d44 --- /dev/null +++ b/packages/boulder-state/src/top-level-task.ts @@ -0,0 +1,69 @@ +import { existsSync, readFileSync } from "node:fs" + +import type { TopLevelTaskRef } from "./types" + +const TODO_HEADING_PATTERN = /^##\s+TODOs\b/i +const FINAL_VERIFICATION_HEADING_PATTERN = /^##\s+Final Verification Wave\b/i +const SECOND_LEVEL_HEADING_PATTERN = /^##\s+/ +const UNCHECKED_CHECKBOX_PATTERN = /^(\s*)[-*]\s*\[\s*\]\s*(.+)$/ +const TODO_TASK_PATTERN = /^(\d+)\.\s+(.+)$/ +const FINAL_WAVE_TASK_PATTERN = /^(F\d+)\.\s+(.+)$/i + +type PlanSection = "todo" | "final-wave" | "other" + +function buildTaskRef(section: "todo" | "final-wave", taskLabel: string): TopLevelTaskRef | null { + const pattern = section === "todo" ? TODO_TASK_PATTERN : FINAL_WAVE_TASK_PATTERN + const match = taskLabel.match(pattern) + if (!match) { + return null + } + + const rawLabel = match[1] + const title = match[2].trim() + return { + key: `${section}:${rawLabel.toLowerCase()}`, + section, + label: rawLabel, + title, + } +} + +export function readCurrentTopLevelTask(planPath: string): TopLevelTaskRef | null { + if (!existsSync(planPath)) { + return null + } + + try { + const content = readFileSync(planPath, "utf-8") + const lines = content.split(/\r?\n/) + let section: PlanSection = "other" + + for (const line of lines) { + if (SECOND_LEVEL_HEADING_PATTERN.test(line)) { + section = TODO_HEADING_PATTERN.test(line) + ? "todo" + : FINAL_VERIFICATION_HEADING_PATTERN.test(line) + ? "final-wave" + : "other" + } + + const uncheckedTaskMatch = line.match(UNCHECKED_CHECKBOX_PATTERN) + if (!uncheckedTaskMatch || uncheckedTaskMatch[1].length > 0) { + continue + } + + if (section !== "todo" && section !== "final-wave") { + continue + } + + const taskRef = buildTaskRef(section, uncheckedTaskMatch[2].trim()) + if (taskRef) { + return taskRef + } + } + + return null + } catch { + return null + } +} diff --git a/packages/boulder-state/src/types.ts b/packages/boulder-state/src/types.ts new file mode 100644 index 000000000..93be21c1f --- /dev/null +++ b/packages/boulder-state/src/types.ts @@ -0,0 +1,79 @@ +export interface BoulderState { + schema_version?: 2 + active_work_id?: string + works?: Record + active_plan: string + started_at: string + ended_at?: string + elapsed_ms?: number + status?: BoulderWorkStatus + updated_at?: string + session_ids: string[] + session_origins?: Record + plan_name: string + agent?: string + worktree_path?: string + task_sessions?: Record +} + +export type BoulderSessionOrigin = "direct" | "appended" +export type BoulderWorkStatus = "active" | "completed" | "paused" | "abandoned" +export type BoulderTaskStatus = "running" | "completed" | "cancelled" + +export interface BoulderWorkState { + work_id: string + active_plan: string + plan_name: string + status?: BoulderWorkStatus + started_at: string + ended_at?: string + elapsed_ms?: number + updated_at?: string + session_ids: string[] + session_origins?: Record + agent?: string + worktree_path?: string + task_sessions?: Record +} + +export interface PlanProgress { + total: number + completed: number + isComplete: boolean +} + +export interface TaskSessionState { + task_key: string + task_label: string + task_title: string + session_id: string + agent?: string + category?: string + started_at?: string + ended_at?: string + elapsed_ms?: number + status?: BoulderTaskStatus + updated_at: string +} + +export interface BoulderWorkResumeOption { + work_id: string + plan_name: string + active_plan: string + worktree_path?: string + status: BoulderWorkStatus + started_at: string + updated_at: string + ended_at?: string + elapsed_ms?: number + session_count: number + progress: PlanProgress + is_current_mirror: boolean +} + +export interface TopLevelTaskRef { + key: string + section: "todo" | "final-wave" + label: string + title: string +} diff --git a/packages/boulder-state/tsconfig.json b/packages/boulder-state/tsconfig.json new file mode 100644 index 000000000..7a69d1222 --- /dev/null +++ b/packages/boulder-state/tsconfig.json @@ -0,0 +1,14 @@ +{ + "compilerOptions": { + "target": "ESNext", + "module": "ESNext", + "moduleResolution": "bundler", + "strict": true, + "esModuleInterop": true, + "skipLibCheck": true, + "forceConsistentCasingInFileNames": true, + "lib": ["ESNext"], + "types": ["bun-types"] + }, + "include": ["src/**/*"] +} diff --git a/src/features/boulder-state/constants.ts b/src/features/boulder-state/constants.ts index 323d862d8..32cfad819 100644 --- a/src/features/boulder-state/constants.ts +++ b/src/features/boulder-state/constants.ts @@ -1,13 +1,8 @@ -/** - * Boulder State Constants - */ - -export const BOULDER_DIR = ".omo" -export const BOULDER_FILE = "boulder.json" -export const BOULDER_STATE_PATH = `${BOULDER_DIR}/${BOULDER_FILE}` - -export const NOTEPAD_DIR = "notepads" -export const NOTEPAD_BASE_PATH = `${BOULDER_DIR}/${NOTEPAD_DIR}` - -/** Prometheus plan directory pattern */ -export const PROMETHEUS_PLANS_DIR = ".omo/plans" +export { + BOULDER_DIR, + BOULDER_FILE, + BOULDER_STATE_PATH, + NOTEPAD_BASE_PATH, + NOTEPAD_DIR, + PROMETHEUS_PLANS_DIR, +} from "@oh-my-opencode/boulder-state" diff --git a/src/features/boulder-state/storage.ts b/src/features/boulder-state/storage.ts index 54517f239..c99e05098 100644 --- a/src/features/boulder-state/storage.ts +++ b/src/features/boulder-state/storage.ts @@ -1,977 +1,29 @@ -/** - * Boulder State Storage - * - * Handles reading/writing boulder.json for active plan tracking. - */ - -import { existsSync, readFileSync, writeFileSync, mkdirSync, readdirSync } from "node:fs" -import { basename, dirname, isAbsolute, join, relative, resolve } from "node:path" -import type { - BoulderSessionOrigin, - BoulderState, - BoulderWorkResumeOption, - BoulderWorkState, - BoulderWorkStatus, - PlanProgress, - TaskSessionState, -} from "./types" -import { BOULDER_DIR, BOULDER_FILE, PROMETHEUS_PLANS_DIR } from "./constants" - -const RESERVED_KEYS = new Set(["__proto__", "prototype", "constructor"]) - -function nowIsoString(): string { - return new Date().toISOString() -} - -function parseIsoToMs(value: string | undefined): number | null { - if (!value) { - return null - } - - const parsed = Date.parse(value) - return Number.isNaN(parsed) ? null : parsed -} - -function getElapsedMs(startedAt: string | undefined, endedAt: string | undefined): number | undefined { - const startedMs = parseIsoToMs(startedAt) - const endedMs = parseIsoToMs(endedAt) - if (startedMs === null || endedMs === null) { - return undefined - } - - return endedMs - startedMs -} - -function isValidWorkStatus(status: unknown): status is BoulderWorkStatus { - return status === "active" || status === "completed" || status === "paused" || status === "abandoned" -} - -function buildWorkFromMirror(state: BoulderState): BoulderWorkState { - const planName = state.plan_name ?? getPlanName(state.active_plan) - const workId = `${planName}-legacy` - return { - work_id: workId, - active_plan: state.active_plan, - plan_name: planName, - status: state.status, - started_at: state.started_at, - ended_at: state.ended_at, - elapsed_ms: state.elapsed_ms, - updated_at: state.updated_at, - session_ids: Array.isArray(state.session_ids) ? [...state.session_ids] : [], - session_origins: state.session_origins, - agent: state.agent, - worktree_path: state.worktree_path, - task_sessions: state.task_sessions, - } -} - -function projectWorkToMirror(state: BoulderState, work: BoulderWorkState): void { - state.active_plan = work.active_plan - state.plan_name = work.plan_name - state.status = work.status - state.started_at = work.started_at - state.ended_at = work.ended_at - state.elapsed_ms = work.elapsed_ms - state.updated_at = work.updated_at - state.session_ids = [...work.session_ids] - state.session_origins = work.session_origins ? { ...work.session_origins } : {} - state.agent = work.agent - state.worktree_path = work.worktree_path - state.task_sessions = work.task_sessions ? { ...work.task_sessions } : {} -} - -function selectMirrorWork(state: BoulderState): BoulderWorkState | null { - const works = getBoulderWorks(state) - if (works.length === 0) { - return null - } - - if (state.active_work_id) { - const matched = works.find((work) => work.work_id === state.active_work_id) - if (matched) { - return matched - } - } - - const sorted = [...works].sort((left, right) => { - const leftMs = parseIsoToMs(left.updated_at ?? left.started_at) ?? 0 - const rightMs = parseIsoToMs(right.updated_at ?? right.started_at) ?? 0 - return rightMs - leftMs - }) - - return sorted[0] ?? null -} - -export function getBoulderFilePath(directory: string): string { - return join(directory, BOULDER_DIR, BOULDER_FILE) -} - -function resolveTrackedPath(baseDirectory: string, trackedPath: string): string { - return isAbsolute(trackedPath) - ? resolve(trackedPath) - : resolve(baseDirectory, trackedPath) -} - -export function resolveBoulderPlanPath( - directory: string, - state: Pick, -): string { - const absolutePlanPath = resolveTrackedPath(directory, state.active_plan) - const worktreePath = state.worktree_path?.trim() - if (!worktreePath) { - return absolutePlanPath - } - - const absoluteDirectory = resolve(directory) - const relativePlanPath = relative(absoluteDirectory, absolutePlanPath) - if ( - relativePlanPath.length === 0 - || relativePlanPath.startsWith("..") - || isAbsolute(relativePlanPath) - ) { - return absolutePlanPath - } - - const absoluteWorktreePath = resolveTrackedPath(directory, worktreePath) - const worktreePlanPath = resolve(absoluteWorktreePath, relativePlanPath) - return existsSync(worktreePlanPath) - ? worktreePlanPath - : absolutePlanPath -} - -export function readBoulderState(directory: string): BoulderState | null { - const filePath = getBoulderFilePath(directory) - - if (!existsSync(filePath)) { - return null - } - - try { - const content = readFileSync(filePath, "utf-8") - const parsed = JSON.parse(content) - if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) { - return null - } - if (!Array.isArray(parsed.session_ids)) { - parsed.session_ids = [] - } - if (!parsed.session_origins || typeof parsed.session_origins !== "object" || Array.isArray(parsed.session_origins)) { - parsed.session_origins = {} - } - if (parsed.session_ids.length === 1) { - const soleSessionId = parsed.session_ids[0] - if ( - typeof soleSessionId === "string" - && parsed.session_origins[soleSessionId] !== "appended" - && parsed.session_origins[soleSessionId] !== "direct" - ) { - parsed.session_origins[soleSessionId] = "direct" - } - } - if (!parsed.task_sessions || typeof parsed.task_sessions !== "object" || Array.isArray(parsed.task_sessions)) { - parsed.task_sessions = {} - } - - const state = parsed as BoulderState - const mirrorWork = selectMirrorWork(state) - if (mirrorWork) { - state.active_work_id = mirrorWork.work_id - projectWorkToMirror(state, mirrorWork) - } - - return state - } catch { - return null - } -} - -export function writeBoulderState(directory: string, state: BoulderState): boolean { - const filePath = getBoulderFilePath(directory) - - try { - const dir = dirname(filePath) - if (!existsSync(dir)) { - mkdirSync(dir, { recursive: true }) - } - - const stateToWrite: BoulderState = { ...state } - if (stateToWrite.works && stateToWrite.active_work_id) { - const activeWork = stateToWrite.works[stateToWrite.active_work_id] - if (activeWork) { - const nextActiveWork: BoulderWorkState = { - ...activeWork, - active_plan: stateToWrite.active_plan, - plan_name: stateToWrite.plan_name, - status: stateToWrite.status, - started_at: stateToWrite.started_at, - ended_at: stateToWrite.ended_at, - elapsed_ms: stateToWrite.elapsed_ms, - updated_at: stateToWrite.updated_at, - session_ids: [...stateToWrite.session_ids], - session_origins: stateToWrite.session_origins ? { ...stateToWrite.session_origins } : {}, - agent: stateToWrite.agent, - worktree_path: stateToWrite.worktree_path, - task_sessions: stateToWrite.task_sessions ? { ...stateToWrite.task_sessions } : {}, - } - stateToWrite.works = { - ...stateToWrite.works, - [stateToWrite.active_work_id]: nextActiveWork, - } - } - } - - writeFileSync(filePath, JSON.stringify(stateToWrite, null, 2), "utf-8") - return true - } catch { - return false - } -} - -export function appendSessionId( - directory: string, - sessionId: string, - origin: "direct" | "appended" = "direct", -): BoulderState | null { - const activeWorkId = readBoulderState(directory)?.active_work_id - if (activeWorkId) { - return appendSessionIdForWork(directory, activeWorkId, sessionId, origin) - } - - const state = readBoulderState(directory) - if (!state) return null - - if (!state.session_origins || typeof state.session_origins !== "object" || Array.isArray(state.session_origins)) { - state.session_origins = {} - } - - if (!state.session_ids?.includes(sessionId)) { - if (!Array.isArray(state.session_ids)) { - state.session_ids = [] - } - const originalSessionIds = [...state.session_ids] - const originalSessionOrigins = { ...state.session_origins } - state.session_ids.push(sessionId) - state.session_origins[sessionId] = origin - if (writeBoulderState(directory, state)) { - return state - } - state.session_ids = originalSessionIds - state.session_origins = originalSessionOrigins - return null - } - - if (!state.session_origins[sessionId]) { - state.session_origins[sessionId] = origin - if (!writeBoulderState(directory, state)) { - return null - } - } - - return state -} - -export function clearBoulderState(directory: string): boolean { - const filePath = getBoulderFilePath(directory) - - try { - if (existsSync(filePath)) { - const { unlinkSync } = require("node:fs") - unlinkSync(filePath) - } - return true - } catch { - return false - } -} - -export function getTaskSessionState(directory: string, taskKey: string): TaskSessionState | null { - const state = readBoulderState(directory) - if (state?.active_work_id) { - const work = state.works?.[state.active_work_id] - const taskSession = work?.task_sessions?.[taskKey] - if (taskSession) { - return taskSession - } - } - - if (!state?.task_sessions) { - return null - } - - return state.task_sessions[taskKey] ?? null -} - -export function upsertTaskSessionState( - directory: string, - input: { - taskKey: string - taskLabel: string - taskTitle: string - sessionId: string - agent?: string - category?: string - }, -): BoulderState | null { - const stateForWork = readBoulderState(directory) - if (stateForWork?.active_work_id) { - return upsertTaskSessionStateForWork(directory, stateForWork.active_work_id, input) - } - - const state = readBoulderState(directory) - if (!state) { - return null - } - - if (RESERVED_KEYS.has(input.taskKey)) { - return null - } - - const taskSessions = state.task_sessions ?? {} - taskSessions[input.taskKey] = { - task_key: input.taskKey, - task_label: input.taskLabel, - task_title: input.taskTitle, - session_id: input.sessionId, - ...(input.agent !== undefined ? { agent: input.agent } : {}), - ...(input.category !== undefined ? { category: input.category } : {}), - updated_at: new Date().toISOString(), - } - - state.task_sessions = taskSessions - if (writeBoulderState(directory, state)) { - return state - } - - return null -} - -/** - * Find Prometheus plan files for this project. - * Prometheus stores plans at: {project}/.omo/plans/{name}.md - */ -export function findPrometheusPlans(directory: string): string[] { - const plansDir = join(directory, PROMETHEUS_PLANS_DIR) - - if (!existsSync(plansDir)) { - return [] - } - - try { - const files = readdirSync(plansDir) - return files - .filter((f) => f.endsWith(".md")) - .map((f) => join(plansDir, f)) - .sort((a, b) => { - // Sort by modification time, newest first - const aStat = require("node:fs").statSync(a) - const bStat = require("node:fs").statSync(b) - return bStat.mtimeMs - aStat.mtimeMs - }) - } catch { - return [] - } -} - -const TODO_HEADING_PATTERN = /^##\s+TODOs\b/i -const FINAL_VERIFICATION_HEADING_PATTERN = /^##\s+Final Verification Wave\b/i -const SECOND_LEVEL_HEADING_PATTERN = /^##\s+/ -const UNCHECKED_CHECKBOX_PATTERN = /^(\s*)[-*]\s*\[\s*\]\s*(.+)$/ -const CHECKED_CHECKBOX_PATTERN = /^(\s*)[-*]\s*\[[xX]\]\s*(.+)$/ -const TODO_TASK_PATTERN = /^\d+\.\s+/ -const FINAL_WAVE_TASK_PATTERN = /^F\d+\.\s+/i - -type ProgressSection = "todo" | "final-wave" | "other" - -/** - * Parse a plan file and count checkbox progress. - * - * Only top-level (zero-indent) checkboxes under `## TODOs` and - * `## Final Verification Wave` sections are counted. The checkbox - * body must carry a valid task label (`N.` for TODOs, `FN.` for - * Final Verification Wave). Nested acceptance-criteria checkboxes - * and checkboxes in other sections are intentionally ignored so - * that progress tracking stays aligned with `readCurrentTopLevelTask`. - */ -export function getPlanProgress(planPath: string): PlanProgress { - if (!existsSync(planPath)) { - return { total: 0, completed: 0, isComplete: false } - } - - try { - const content = readFileSync(planPath, "utf-8") - const lines = content.split(/\r?\n/) - - // Check if the plan has structured sections (## TODOs / ## Final Verification Wave) - const hasStructuredSections = lines.some( - (line) => TODO_HEADING_PATTERN.test(line) || FINAL_VERIFICATION_HEADING_PATTERN.test(line), - ) - - if (hasStructuredSections) { - // Structured plan: only count top-level checkboxes with numbered labels - // under ## TODOs and ## Final Verification Wave sections - return getStructuredPlanProgress(lines) - } - - // Simple plan: count all top-level checkboxes anywhere - return getSimplePlanProgress(content) - } catch { - return { total: 0, completed: 0, isComplete: false } - } -} - -function getStructuredPlanProgress(lines: string[]): PlanProgress { - let section: ProgressSection = "other" - let total = 0 - let completed = 0 - - for (const line of lines) { - if (SECOND_LEVEL_HEADING_PATTERN.test(line)) { - section = TODO_HEADING_PATTERN.test(line) - ? "todo" - : FINAL_VERIFICATION_HEADING_PATTERN.test(line) - ? "final-wave" - : "other" - continue - } - - if (section !== "todo" && section !== "final-wave") { - continue - } - - const checkedMatch = line.match(CHECKED_CHECKBOX_PATTERN) - const uncheckedMatch = checkedMatch ? null : line.match(UNCHECKED_CHECKBOX_PATTERN) - const match = checkedMatch ?? uncheckedMatch - if (!match) { - continue - } - - if (match[1].length > 0) { - continue - } - - const taskBody = match[2].trim() - const labelPattern = section === "todo" ? TODO_TASK_PATTERN : FINAL_WAVE_TASK_PATTERN - if (!labelPattern.test(taskBody)) { - continue - } - - total++ - if (checkedMatch) { - completed++ - } - } - - return { - total, - completed, - isComplete: total > 0 && completed === total, - } -} - -function getSimplePlanProgress(content: string): PlanProgress { - const uncheckedMatches = content.match(/^[-*]\s*\[\s*\]/gm) || [] - const checkedMatches = content.match(/^[-*]\s*\[[xX]\]/gm) || [] - - const total = uncheckedMatches.length + checkedMatches.length - const completed = checkedMatches.length - - return { - total, - completed, - isComplete: total > 0 && completed === total, - } -} - -/** - * Extract plan name from file path. - */ -export function getPlanName(planPath: string): string { - return basename(planPath, ".md") -} - -/** - * Create a new boulder state for a plan. - */ -export function createBoulderState( - planPath: string, - sessionId: string, - agent?: string, - worktreePath?: string, -): BoulderState { - const startedAt = nowIsoString() - const workId = generateWorkId(getPlanName(planPath)) - const work: BoulderWorkState = { - work_id: workId, - active_plan: planPath, - plan_name: getPlanName(planPath), - status: "active", - started_at: startedAt, - updated_at: startedAt, - session_ids: [sessionId], - session_origins: { - [sessionId]: "direct", - }, - ...(agent !== undefined ? { agent } : {}), - ...(worktreePath !== undefined ? { worktree_path: worktreePath } : {}), - task_sessions: {}, - } - - return { - schema_version: 2, - active_work_id: workId, - works: { - [workId]: work, - }, - active_plan: planPath, - started_at: startedAt, - status: "active", - updated_at: startedAt, - session_ids: [sessionId], - session_origins: { - [sessionId]: "direct", - }, - plan_name: getPlanName(planPath), - task_sessions: {}, - ...(agent !== undefined ? { agent } : {}), - ...(worktreePath !== undefined ? { worktree_path: worktreePath } : {}), - } -} - -export function generateWorkId(planName: string): string { - const slug = planName - .trim() - .toLowerCase() - .replace(/[^a-z0-9]+/g, "-") - .replace(/^-+|-+$/g, "") - const randomHex = Math.floor(Math.random() * 0xffffffff) - .toString(16) - .padStart(8, "0") - const safeSlug = slug.length > 0 ? slug : "work" - return `${safeSlug}-${randomHex}` -} - -export function getBoulderWorks(state: BoulderState): BoulderWorkState[] { - if (state.works && typeof state.works === "object") { - return Object.values(state.works) - } - - if (!state.active_plan || !state.plan_name || !state.started_at) { - return [] - } - - return [buildWorkFromMirror(state)] -} - -export function getActiveWorks(directory: string): BoulderWorkState[] { - const state = readBoulderState(directory) - if (!state) { - return [] - } - - return getBoulderWorks(state).filter((work) => work.status !== "completed" && work.status !== "abandoned") -} - -export function getWorkById(directory: string, workId: string): BoulderWorkState | null { - const state = readBoulderState(directory) - if (!state) { - return null - } - - return getBoulderWorks(state).find((work) => work.work_id === workId) ?? null -} - -export function getWorkByPlanName( - directory: string, - planName: string, - options?: { worktreePath?: string }, -): BoulderWorkState | null { - const state = readBoulderState(directory) - if (!state) { - return null - } - - const worktreePath = options?.worktreePath - return getBoulderWorks(state).find((work) => { - if (work.plan_name !== planName) { - return false - } - - if (!worktreePath) { - return true - } - - return work.worktree_path === worktreePath - }) ?? null -} - -export function getWorkForSession(directory: string, sessionId: string): BoulderWorkState | null { - const state = readBoulderState(directory) - if (!state) { - return null - } - - const works = getBoulderWorks(state) - .filter((work) => work.session_ids.includes(sessionId)) - .sort((left, right) => { - const leftMs = parseIsoToMs(left.updated_at ?? left.started_at) ?? 0 - const rightMs = parseIsoToMs(right.updated_at ?? right.started_at) ?? 0 - return rightMs - leftMs - }) - - if (works.length > 0) { - return works[0] ?? null - } - - if (state.session_ids.includes(sessionId)) { - return buildWorkFromMirror(state) - } - - return null -} - -export function resolveBoulderPlanPathForWork( - directory: string, - work: Pick, -): string { - return resolveBoulderPlanPath(directory, work) -} - -export function getWorkResumeOptions(directory: string): BoulderWorkResumeOption[] { - const state = readBoulderState(directory) - if (!state) { - return [] - } - - return getActiveWorks(directory).map((work) => { - const progress = getPlanProgress(resolveBoulderPlanPathForWork(directory, work)) - return { - work_id: work.work_id, - plan_name: work.plan_name, - active_plan: work.active_plan, - worktree_path: work.worktree_path, - status: work.status && isValidWorkStatus(work.status) ? work.status : "active", - started_at: work.started_at, - updated_at: work.updated_at ?? work.started_at, - ended_at: work.ended_at, - elapsed_ms: work.elapsed_ms, - session_count: work.session_ids.length, - progress, - is_current_mirror: state.active_work_id === work.work_id, - } - }) -} - -export function selectActiveWork(directory: string, workId: string): BoulderState | null { - const state = readBoulderState(directory) - if (!state) { - return null - } - - const works = getBoulderWorks(state) - const nextWork = works.find((work) => work.work_id === workId) - if (!nextWork) { - return null - } - - const nextState: BoulderState = { - ...state, - schema_version: 2, - active_work_id: workId, - works: state.works ?? Object.fromEntries(works.map((work) => [work.work_id, work])), - } - projectWorkToMirror(nextState, nextWork) - - if (!writeBoulderState(directory, nextState)) { - return null - } - - return nextState -} - -export function addBoulderWork( - directory: string, - input: { - planPath: string - sessionId: string - agent?: string - worktreePath?: string - startedAt?: string - }, -): BoulderState | null { - const state = readBoulderState(directory) - if (!state) { - return null - } - - const workId = generateWorkId(getPlanName(input.planPath)) - const startedAt = input.startedAt ?? nowIsoString() - const nextWork: BoulderWorkState = { - work_id: workId, - active_plan: input.planPath, - plan_name: getPlanName(input.planPath), - status: "active", - started_at: startedAt, - updated_at: startedAt, - session_ids: [input.sessionId], - session_origins: { - [input.sessionId]: "direct", - }, - ...(input.agent !== undefined ? { agent: input.agent } : {}), - ...(input.worktreePath !== undefined ? { worktree_path: input.worktreePath } : {}), - task_sessions: {}, - } - - const works = getBoulderWorks(state) - const nextWorks: Record = { - ...Object.fromEntries(works.map((work) => [work.work_id, work])), - [workId]: nextWork, - } - - const nextState: BoulderState = { - ...state, - schema_version: 2, - works: nextWorks, - active_work_id: workId, - } - projectWorkToMirror(nextState, nextWork) - - if (!writeBoulderState(directory, nextState)) { - return null - } - - return nextState -} - -export function appendSessionIdForWork( - directory: string, - workId: string, - sessionId: string, - origin: BoulderSessionOrigin = "direct", -): BoulderState | null { - const state = readBoulderState(directory) - if (!state) { - return null - } - - const works = getBoulderWorks(state) - const targetWork = works.find((work) => work.work_id === workId) - if (!targetWork) { - return null - } - - const sessionIds = targetWork.session_ids.includes(sessionId) - ? [...targetWork.session_ids] - : [...targetWork.session_ids, sessionId] - const sessionOrigins = { - ...(targetWork.session_origins ?? {}), - [sessionId]: origin, - } - - const updatedWork: BoulderWorkState = { - ...targetWork, - session_ids: sessionIds, - session_origins: sessionOrigins, - updated_at: nowIsoString(), - } - const nextWorks = { - ...Object.fromEntries(works.map((work) => [work.work_id, work])), - [workId]: updatedWork, - } - - const nextState: BoulderState = { - ...state, - schema_version: 2, - works: nextWorks, - } - if (state.active_work_id === workId) { - projectWorkToMirror(nextState, updatedWork) - } - - if (!writeBoulderState(directory, nextState)) { - return null - } - - return nextState -} - -export function upsertTaskSessionStateForWork( - directory: string, - workId: string, - input: { - taskKey: string - taskLabel: string - taskTitle: string - sessionId: string - agent?: string - category?: string - }, -): BoulderState | null { - if (RESERVED_KEYS.has(input.taskKey)) { - return null - } - - const state = readBoulderState(directory) - if (!state) { - return null - } - - const works = getBoulderWorks(state) - const targetWork = works.find((work) => work.work_id === workId) - if (!targetWork) { - return null - } - - const previousTaskSession = targetWork.task_sessions?.[input.taskKey] - const nextTaskSession: TaskSessionState = { - task_key: input.taskKey, - task_label: input.taskLabel, - task_title: input.taskTitle, - session_id: input.sessionId, - ...(input.agent !== undefined ? { agent: input.agent } : {}), - ...(input.category !== undefined ? { category: input.category } : {}), - ...(previousTaskSession?.started_at !== undefined ? { started_at: previousTaskSession.started_at } : {}), - ...(previousTaskSession?.ended_at !== undefined ? { ended_at: previousTaskSession.ended_at } : {}), - ...(previousTaskSession?.elapsed_ms !== undefined ? { elapsed_ms: previousTaskSession.elapsed_ms } : {}), - ...(previousTaskSession?.status !== undefined ? { status: previousTaskSession.status } : {}), - updated_at: nowIsoString(), - } - - const nextWork: BoulderWorkState = { - ...targetWork, - task_sessions: { - ...(targetWork.task_sessions ?? {}), - [input.taskKey]: nextTaskSession, - }, - updated_at: nowIsoString(), - } - - const nextWorks = { - ...Object.fromEntries(works.map((work) => [work.work_id, work])), - [workId]: nextWork, - } - - const nextState: BoulderState = { - ...state, - schema_version: 2, - works: nextWorks, - } - if (state.active_work_id === workId) { - projectWorkToMirror(nextState, nextWork) - } - - if (!writeBoulderState(directory, nextState)) { - return null - } - - return nextState -} - -export function startTaskTimer( - directory: string, - workId: string, - input: { - taskKey: string - taskLabel: string - taskTitle: string - sessionId: string - agent?: string - category?: string - startedAt?: string - }, -): BoulderState | null { - const nextState = upsertTaskSessionStateForWork(directory, workId, input) - if (!nextState) { - return null - } - - const work = nextState.works?.[workId] - const taskSession = work?.task_sessions?.[input.taskKey] - if (!work || !taskSession) { - return null - } - - const startedAt = taskSession.started_at ?? input.startedAt ?? nowIsoString() - taskSession.started_at = startedAt - taskSession.status = "running" - taskSession.updated_at = nowIsoString() - work.updated_at = nowIsoString() - - if (!writeBoulderState(directory, nextState)) { - return null - } - - return nextState -} - -export function endTaskTimer( - directory: string, - workId: string, - taskKey: string, - endedAt?: string, -): BoulderState | null { - const state = readBoulderState(directory) - if (!state) { - return null - } - - const work = state.works?.[workId] ?? getBoulderWorks(state).find((candidate) => candidate.work_id === workId) - if (!work?.task_sessions?.[taskKey]) { - return null - } - - const taskSession = work.task_sessions[taskKey] - const endAt = endedAt ?? nowIsoString() - taskSession.ended_at = endAt - taskSession.elapsed_ms = getElapsedMs(taskSession.started_at, endAt) - taskSession.status = "completed" - taskSession.updated_at = nowIsoString() - work.updated_at = nowIsoString() - - if (state.active_work_id === workId) { - projectWorkToMirror(state, work) - } - - if (!writeBoulderState(directory, state)) { - return null - } - - return state -} - -export function completeBoulder(directory: string, workId?: string, endedAt?: string): BoulderState | null { - const state = readBoulderState(directory) - if (!state) { - return null - } - - const targetWorkId = workId ?? state.active_work_id - if (!targetWorkId) { - return null - } - - const work = state.works?.[targetWorkId] ?? getBoulderWorks(state).find((candidate) => candidate.work_id === targetWorkId) - if (!work) { - return null - } - - if (work.status === "completed" && work.ended_at !== undefined && work.elapsed_ms !== undefined) { - return state - } - - const endAt = endedAt ?? nowIsoString() - work.ended_at = endAt - work.elapsed_ms = getElapsedMs(work.started_at, endAt) - work.status = "completed" - work.updated_at = nowIsoString() - - if (state.active_work_id === targetWorkId) { - projectWorkToMirror(state, work) - } - - if (!writeBoulderState(directory, state)) { - return null - } - - return state -} +export { + addBoulderWork, + appendSessionId, + appendSessionIdForWork, + clearBoulderState, + completeBoulder, + createBoulderState, + endTaskTimer, + findPrometheusPlans, + generateWorkId, + getActiveWorks, + getBoulderFilePath, + getBoulderWorks, + getPlanName, + getPlanProgress, + getTaskSessionState, + getWorkById, + getWorkByPlanName, + getWorkForSession, + getWorkResumeOptions, + readBoulderState, + resolveBoulderPlanPath, + resolveBoulderPlanPathForWork, + selectActiveWork, + startTaskTimer, + upsertTaskSessionState, + upsertTaskSessionStateForWork, + writeBoulderState, +} from "@oh-my-opencode/boulder-state" diff --git a/src/features/boulder-state/top-level-task.ts b/src/features/boulder-state/top-level-task.ts index feff10f0c..7ec0ab36a 100644 --- a/src/features/boulder-state/top-level-task.ts +++ b/src/features/boulder-state/top-level-task.ts @@ -1,78 +1 @@ -import { existsSync, readFileSync } from "node:fs" - -import type { TopLevelTaskRef } from "./types" - -const TODO_HEADING_PATTERN = /^##\s+TODOs\b/i -const FINAL_VERIFICATION_HEADING_PATTERN = /^##\s+Final Verification Wave\b/i -const SECOND_LEVEL_HEADING_PATTERN = /^##\s+/ -const UNCHECKED_CHECKBOX_PATTERN = /^(\s*)[-*]\s*\[\s*\]\s*(.+)$/ -const CHECKED_CHECKBOX_PATTERN = /^(\s*)[-*]\s*\[[xX]\]\s*(.+)$/ -const TODO_TASK_PATTERN = /^(\d+)\.\s+(.+)$/ -const FINAL_WAVE_TASK_PATTERN = /^(F\d+)\.\s+(.+)$/i - -type PlanSection = "todo" | "final-wave" | "other" - -function buildTaskRef( - section: "todo" | "final-wave", - taskLabel: string, -): TopLevelTaskRef | null { - const pattern = section === "todo" ? TODO_TASK_PATTERN : FINAL_WAVE_TASK_PATTERN - const match = taskLabel.match(pattern) - if (!match) { - return null - } - - const rawLabel = match[1] - const title = match[2].trim() - - return { - key: `${section}:${rawLabel.toLowerCase()}`, - section, - label: rawLabel, - title, - } -} - -export function readCurrentTopLevelTask(planPath: string): TopLevelTaskRef | null { - if (!existsSync(planPath)) { - return null - } - - try { - const content = readFileSync(planPath, "utf-8") - const lines = content.split(/\r?\n/) - let section: PlanSection = "other" - - for (const line of lines) { - if (SECOND_LEVEL_HEADING_PATTERN.test(line)) { - section = TODO_HEADING_PATTERN.test(line) - ? "todo" - : FINAL_VERIFICATION_HEADING_PATTERN.test(line) - ? "final-wave" - : "other" - } - - const uncheckedTaskMatch = line.match(UNCHECKED_CHECKBOX_PATTERN) - if (!uncheckedTaskMatch) { - continue - } - - if (uncheckedTaskMatch[1].length > 0) { - continue - } - - if (section !== "todo" && section !== "final-wave") { - continue - } - - const taskRef = buildTaskRef(section, uncheckedTaskMatch[2].trim()) - if (taskRef) { - return taskRef - } - } - - return null - } catch { - return null - } -} +export { readCurrentTopLevelTask } from "@oh-my-opencode/boulder-state" diff --git a/src/features/boulder-state/types.ts b/src/features/boulder-state/types.ts index 15ac41ab5..6599dd262 100644 --- a/src/features/boulder-state/types.ts +++ b/src/features/boulder-state/types.ts @@ -1,107 +1,11 @@ -/** - * Boulder State Types - * - * Manages the active work plan state for Sisyphus orchestrator. - * Named after Sisyphus's boulder - the eternal task that must be rolled. - */ - -export interface BoulderState { - schema_version?: 2 - active_work_id?: string - works?: Record - /** Absolute path to the active plan file */ - active_plan: string - /** ISO timestamp when work started */ - started_at: string - ended_at?: string - elapsed_ms?: number - status?: BoulderWorkStatus - updated_at?: string - /** Session IDs that have worked on this plan */ - session_ids: string[] - session_origins?: Record - /** Plan name derived from filename */ - plan_name: string - /** Agent type to use when resuming (e.g., 'atlas') */ - agent?: string - /** Absolute path to the git worktree root where work happens */ - worktree_path?: string - /** Preferred reusable subagent sessions keyed by current top-level plan task */ - task_sessions?: Record -} - -export type BoulderSessionOrigin = "direct" | "appended" -export type BoulderWorkStatus = "active" | "completed" | "paused" | "abandoned" -export type BoulderTaskStatus = "running" | "completed" | "cancelled" - -export interface BoulderWorkState { - work_id: string - active_plan: string - plan_name: string - status?: BoulderWorkStatus - started_at: string - ended_at?: string - elapsed_ms?: number - updated_at?: string - session_ids: string[] - session_origins?: Record - agent?: string - worktree_path?: string - task_sessions?: Record -} - -export interface PlanProgress { - /** Total number of checkboxes */ - total: number - /** Number of completed checkboxes */ - completed: number - /** Whether all tasks are done */ - isComplete: boolean -} - -export interface TaskSessionState { - /** Stable identifier for the current top-level plan task (e.g. todo:1 / final-wave:F1) */ - task_key: string - /** Original task label from the plan file */ - task_label: string - /** Full task title from the plan file */ - task_title: string - /** Preferred reusable subagent session */ - session_id: string - /** Agent associated with the task session, when known */ - agent?: string - /** Category associated with the task session, when known */ - category?: string - started_at?: string - ended_at?: string - elapsed_ms?: number - status?: BoulderTaskStatus - /** Last update timestamp */ - updated_at: string -} - -export interface BoulderWorkResumeOption { - work_id: string - plan_name: string - active_plan: string - worktree_path?: string - status: BoulderWorkStatus - started_at: string - updated_at: string - ended_at?: string - elapsed_ms?: number - session_count: number - progress: PlanProgress - is_current_mirror: boolean -} - -export interface TopLevelTaskRef { - /** Stable identifier for the current top-level plan task */ - key: string - /** Task section in the Prometheus plan */ - section: "todo" | "final-wave" - /** Original label token (e.g. 1 / F1) */ - label: string - /** Full task title extracted from the checkbox line */ - title: string -} +export type { + BoulderSessionOrigin, + BoulderState, + BoulderTaskStatus, + BoulderWorkResumeOption, + BoulderWorkState, + BoulderWorkStatus, + PlanProgress, + TaskSessionState, + TopLevelTaskRef, +} from "@oh-my-opencode/boulder-state"