mirror of
https://github.com/J3vb/OwnCord.git
synced 2026-09-03 03:50:00 +03:00
Remove obsolete test files for agent-diff, agent-queue, backlog-parser, briefing-and-normalization, cache-mode, module-naming, and server-auth. These tests are no longer relevant to the current codebase and have been deleted to maintain a clean and efficient testing environment.
This commit is contained in:
J3vb
@@ -1,290 +0,0 @@
|
||||
# Phase B + C — Local Follow-up TODO
|
||||
|
||||
This file enumerates everything from `phase-b-acceleration.md` and
|
||||
`phase-c-differentiation.md` that **could not be completed inside the
|
||||
sandboxed Claude session** because the work requires:
|
||||
|
||||
- network access to fetch new modules / npm packages,
|
||||
- a Go toolchain matching `go.mod`'s `go 1.25.0` directive,
|
||||
- a WASM toolchain (TinyGo / Rust / AssemblyScript),
|
||||
- a real machine that can run `npm install`, `cargo`, `tauri`, etc.
|
||||
|
||||
The session **branch is `claude/plan-phases-b-c-bGpoS`**. Everything below
|
||||
must be run on a developer machine (or CI) before the branch is mergeable.
|
||||
|
||||
The session-resident plan that was actually executed lives in
|
||||
`/root/.claude/plans/woolly-wiggling-wolf.md` (not in this repo).
|
||||
|
||||
---
|
||||
|
||||
## Verification (do first — confirms the in-session work compiles)
|
||||
|
||||
- [x] `cd Server && go build ./...` — passes on the dev machine with Go 1.24.x.
|
||||
- [x] `cd Server && go test ./store/... ./ws/... ./plugin/... ./telemetry/...`
|
||||
— all pass; full suite `go test ./...` green.
|
||||
- [x] `cd Server && go vet ./...` — clean.
|
||||
- [x] `cd Client/tauri-client && npm install && npm run lint && npm run build`
|
||||
— Pulls in `solid-js`, `vite-plugin-solid`, and
|
||||
`@solidjs/testing-library` (added to `package.json`); confirms the
|
||||
Solid pipeline compiles inside the existing Vite + TS setup.
|
||||
- [x] `cd Client/tauri-client && npm run test` — runs the new
|
||||
`Badge.test.tsx` smoke test. All 111 test files / 3186 tests pass.
|
||||
|
||||
---
|
||||
|
||||
## Phase B Step 6 — Solid.js migration (rest of the components)
|
||||
|
||||
The session landed:
|
||||
- Vite + TS toolchain wiring (`vite.config.ts`, `tsconfig.json`)
|
||||
- `solid-js` + `vite-plugin-solid` + `@solidjs/testing-library` in
|
||||
`package.json`
|
||||
- `src/lib/solidAdapter.ts` (wraps custom stores as Solid signals)
|
||||
- `src/lib/solidMount.ts` (`{mount, destroy}` adapter for Solid roots)
|
||||
- `src/components/solid/Badge.tsx` — first leaf
|
||||
- `src/components/solid/ChannelListItem.tsx` — store-subscribed leaf
|
||||
- `src/components/solid/Badge.test.tsx` — pipeline smoke test
|
||||
- `src/components/solid/README.md` — migration recipe
|
||||
|
||||
Still TODO locally:
|
||||
|
||||
- [x] Run `npm install` and verify the build passes (sandbox had no
|
||||
network).
|
||||
- [ ] Migrate the remaining leaf components in
|
||||
`src/components/` one PR at a time, following the recipe in
|
||||
`src/components/solid/README.md`. Suggested order: presence pills,
|
||||
typing indicators, message attachments, voice volume meters, then
|
||||
containers (channel list, member list, message list).
|
||||
- [ ] Once every leaf is migrated, replace the manual `mountSolid` calls
|
||||
in containers with native Solid components and delete the old
|
||||
vanilla DOM utilities (`createComponent`, factory shells) referenced
|
||||
from `src/components/`.
|
||||
- [x] Add Vitest config preset: vite-plugin-solid added to vitest.config.ts,
|
||||
include expanded to pick up src/components/solid/**/*.test.tsx.
|
||||
Badge.test.tsx now runs automatically (112 files, 3188 tests pass).
|
||||
|
||||
---
|
||||
|
||||
## Phase B Step 7 — Event persistence
|
||||
|
||||
The session landed:
|
||||
- `Server/migrations/014_events_table.sql` (SQLite)
|
||||
- `events` table appended to `Server/migrations/postgres/001_initial_schema.sql`
|
||||
- `Server/db/queries/sqlite/events.sql`, `Server/db/queries/postgres/events.sql`
|
||||
- `Server/db/persisted_event.go` — domain type
|
||||
- `EventStore` sub-interface added to `Server/store/store.go`
|
||||
- SQLite implementation in `Server/store/sqlite_events.go` (raw SQL via
|
||||
`*sql.DB`, no `dbgen` dependency)
|
||||
- MemStore implementation in `Server/store/memstore_events.go`
|
||||
- Postgres stubs returning `ErrPostgresNotImplemented`
|
||||
- `Server/ws/event_persister.go` — batched async writer
|
||||
- `Server/ws/event_pruner.go` — retention pruner goroutine
|
||||
- Three `replayBuf.Push` call sites in `Server/ws/hub.go` now also call
|
||||
`h.persistEvent(...)`
|
||||
- Tiered reconnect replay in `Server/ws/serve.go` (buffer → DB → full)
|
||||
- Reconnect-tier metrics in the hub + telemetry counter
|
||||
- `EventPersistenceConfig` added to `Server/config/config.go` with
|
||||
defaults `{enabled: true, retention_hours: 24, batch_size: 50,
|
||||
batch_flush_ms: 100, pruner_interval_minutes: 60}`
|
||||
- `Server/main.go` wires the persister + pruner
|
||||
- `Server/ws/event_persister_test.go` — batching, drop, drain tests
|
||||
|
||||
Still TODO locally:
|
||||
|
||||
- [x] Run `make sqlc-generate` — done; `db/pgdbgen/events.sql.go` and
|
||||
`db/pgdbgen/plugins.sql.go` generated; `//go:build postgres` tag
|
||||
prepended to all 19 pgdbgen files to gate pgx/v5 import.
|
||||
- [x] Replace the postgres EventStore stubs in `Server/store/postgres.go`
|
||||
with real implementations using PostgreSQL SQL syntax
|
||||
(`$1/$2` params, `RETURNING id`, native `bool`/`time.Time`).
|
||||
- [x] Add an integration test that pushes more than 1000 events through a
|
||||
real hub with a 1000-slot buffer, disconnects at seq=500, and asserts
|
||||
the DB tier returns the missing events. Landed in
|
||||
`Server/ws/reconnect_db_test.go` (`TestReconnect_BufferMiss_FallsBackToDBTier`).
|
||||
- [x] Add a `replay_source` field to the auth_ok payload — landed in
|
||||
Pass 4. `buildAuthOK` takes the tier as a parameter, "none" on
|
||||
fresh connect, "buffer" or "db" on resume.
|
||||
- [x] Document the new `event_persistence` block in `defaultYAML` inside
|
||||
`Server/config/config.go` — landed in Pass 3.
|
||||
|
||||
---
|
||||
|
||||
## Phase B Step 8 — OpenTelemetry
|
||||
|
||||
The session landed:
|
||||
- `Server/telemetry/telemetry.go` — public API + no-op provider
|
||||
- `Server/telemetry/telemetry_default.go` — default-build `Init`
|
||||
- `Server/telemetry/telemetry_otel.go` — wazero/postgres-style build-tag
|
||||
skeleton (build with `-tags otel`); compiles only when the OTel modules
|
||||
are in `go.mod` and is currently a structural placeholder
|
||||
- `Server/telemetry/metrics.go` — `AppMetrics` bundle
|
||||
- `Server/telemetry/middleware.go` — `HTTPMiddleware` + `PrometheusHandler`
|
||||
- `Server/telemetry/telemetry_test.go`
|
||||
- `Server/api/router.go` mounts `telemetry.HTTPMiddleware()`
|
||||
unconditionally and the Prometheus exporter when non-nil
|
||||
- `Server/main.go` calls `telemetry.Init` early and defers `Shutdown`
|
||||
- `TelemetryConfig` added to `Server/config/config.go`
|
||||
- Spans added to `MessageService.SendMessage`,
|
||||
`PermissionService.HasChannelPerm`,
|
||||
`ChannelService.ListVisibleChannels`
|
||||
- Reconnect-tier counter wired into `WSReconnectTierTotal` from
|
||||
`Server/ws/serve.go`
|
||||
|
||||
Still TODO locally:
|
||||
|
||||
- [x] Add the OTel modules to `go.mod`: otel v1.43.0, sdk v1.43.0,
|
||||
exporters/prometheus v0.65.0,
|
||||
exporters/otlp/otlptrace/otlptracegrpc v1.43.0, and
|
||||
`go.opentelemetry.io/contrib/instrumentation/net/http/otelhttp`
|
||||
v0.67.0 (otelhttp replaces the unmaintained otelchi wrapper
|
||||
referenced by the original plan; otelhttp is upstream-supported
|
||||
and wraps any `http.Handler` including a Chi router).
|
||||
- [x] Replace the placeholder body of `telemetry/telemetry_otel.go`'s
|
||||
`Init` with the real tracer + meter provider construction. The
|
||||
tagged build wires an OTel Prometheus exporter (pull), an OTLP/gRPC
|
||||
trace exporter when `exporter=otlp` (with `OTLPInsecure` opt-in for
|
||||
plaintext gRPC), `otelhttp.NewHandler` as the HTTP middleware, and
|
||||
a real provider that re-binds `AppMetrics` instruments via
|
||||
`resetAppMetricsForInit`. Tests in
|
||||
`Server/telemetry/telemetry_otel_test.go`
|
||||
(`TestOtelInitPrometheusExporter`, `TestOtelTracerRecordsSpan`,
|
||||
`TestOtelHistogramRecordsSeconds`, `TestOtelShutdownIdempotent`,
|
||||
`TestOtelConvertAttrsHandlesUnsignedInts`,
|
||||
`TestOtelConvertAttrsUint64OverflowFallsBackToString`,
|
||||
`TestOtelAppMetricsRebindsAfterInit`) run under
|
||||
`go test -tags otel ./telemetry/...`.
|
||||
- [x] Build with `-tags otel` — passes. Full 4-tag matrix green
|
||||
(default, otel, wazero, otel+wazero) against Go 1.25.1.
|
||||
- [ ] Add a CI job that exercises `go build -tags otel ./...` and
|
||||
`go test -tags otel ./telemetry/...`.
|
||||
- [x] Add spans to the remaining service-layer entry points
|
||||
(`DMService`, `VoiceService`, `InviteService`, `ModerationService`,
|
||||
`BlockService`, `UserService`) — landed in Pass 3, one entrypoint
|
||||
per service. Add additional spans on demand.
|
||||
- [x] Document the new `telemetry` block in `defaultYAML` inside
|
||||
`Server/config/config.go` — landed in Pass 3.
|
||||
- [x] Add a `make otel-up` target that spins up Jaeger via
|
||||
docker-compose for local tracing development. Landed in
|
||||
`Server/Makefile` (`otel-up` / `otel-down`); overlay file at
|
||||
`Server/docker-compose.otel.yml`; Prometheus config at
|
||||
`Server/prometheus.dev.yml`.
|
||||
|
||||
---
|
||||
|
||||
## Phase C Step 9 — Wazero plugin runtime
|
||||
|
||||
The session landed:
|
||||
- `Server/plugin/manifest.go` — JSON manifest parser + capability checks
|
||||
- `Server/plugin/loader.go` — directory scan + entrypoint validation
|
||||
- `Server/plugin/registry.go` — registry + lifecycle (install/enable/uninstall)
|
||||
- `Server/plugin/host_commands.go`, `host_storage.go`, `host_events.go`,
|
||||
`host_http.go`, `host_ui.go` — capability surfaces
|
||||
- `Server/plugin/sandbox_default.go` — no-op runtime (default build)
|
||||
- `Server/plugin/sandbox_wazero.go` — `-tags wazero` skeleton
|
||||
- `Server/plugin/errors.go`
|
||||
- `Server/plugin/plugin_test.go`
|
||||
- `Server/plugin/examples/hello/plugin.json` + `README.md`
|
||||
- `Server/migrations/015_plugins.sql` (SQLite)
|
||||
- `plugins` + `plugin_kv` tables appended to the postgres schema
|
||||
- `Server/db/queries/sqlite/plugins.sql`,
|
||||
`Server/db/queries/postgres/plugins.sql`
|
||||
- `PluginStore` sub-interface in `Server/store/store.go` with SQLite,
|
||||
MemStore, and postgres-stub implementations
|
||||
- `Server/api/plugins_handler.go` — admin REST surface
|
||||
- `Server/api/router.go` mounts the admin plugin handler
|
||||
- `Server/main.go` constructs and starts the registry when
|
||||
`cfg.Plugins.Enabled`
|
||||
- `PluginsConfig` added to `Server/config/config.go`
|
||||
- `Client/tauri-client/src/lib/pluginBridge.ts` — iframe + postMessage host
|
||||
- `Client/tauri-client/src/components/solid/PluginContainer.tsx` — Solid
|
||||
host component for plugin tabs
|
||||
|
||||
Still TODO locally:
|
||||
|
||||
- [x] Add `github.com/tetratelabs/wazero v1.11.0` to `go.mod`.
|
||||
- [x] Replace the placeholder body in `Server/plugin/sandbox_wazero.go`
|
||||
with real wazero runtime construction. The tagged build owns a
|
||||
shared `wazero.Runtime` created in `platformInit` (with the
|
||||
configured `MaxMemoryMB` translated to `WithMemoryLimitPages` and
|
||||
WASI preview-1 imports pre-instantiated), compiles + instantiates
|
||||
each plugin's `.wasm` entrypoint in `activateWithRuntime`, and
|
||||
tears modules + runtime down in `platformDeactivate` / `Close`.
|
||||
The host-guest command ABI is JSON-over-linear-memory:
|
||||
`allocate(size)` / `command_dispatch(ptr,len) → (ptr,len)` /
|
||||
`deallocate(ptr,len)`, with optional `list_commands` for command
|
||||
auto-registration. Tests in `Server/plugin/sandbox_wazero_test.go`
|
||||
(`TestWazeroRegistryCreatesRuntime`,
|
||||
`TestWazeroActivateCompilesModule`,
|
||||
`TestWazeroDispatchCommandMissingExport`,
|
||||
`TestWazeroCloseTearsDownRuntime`,
|
||||
`TestWazeroInvalidWASMFailsActivation`,
|
||||
`TestWazeroDisablePluginFreesModule`) run under
|
||||
`go test -tags wazero ./plugin/...` using a 41-byte embedded WASM
|
||||
fixture for the smoke tests.
|
||||
- [x] Add a precompiled `Server/plugin/examples/hello/hello.wasm`
|
||||
(925 KiB) built with TinyGo 0.40.1 + Go 1.25.3 + Binaryen
|
||||
wasm-opt 129. Source in `examples/hello/main.go`; exports:
|
||||
`allocate`, `deallocate`, `list_commands`, `command_dispatch`,
|
||||
`on_event`.
|
||||
- [x] Replace JSON-only manifest parsing with TOML support behind the
|
||||
`wazero` build tag. Added `github.com/BurntSushi/toml` v1.6.0,
|
||||
`manifest_toml.go` (wazero) + `manifest_nottoml.go` (!wazero);
|
||||
`loader.go` prefers `plugin.toml` and falls back to
|
||||
`plugin.json`.
|
||||
- [x] Wire `Server/plugin/host_events.go` into the WS pub/sub hub.
|
||||
Landed: `EventSink.SetBroadcaster`/`Emit` added; hub gains
|
||||
`SetPluginEventSink`; `deliverBroadcast` calls `sink.Dispatch`
|
||||
on each sequenced broadcast; wired in `api/router.go`.
|
||||
- [x] Wire `Server/plugin/host_commands.go` into the WS slash-command
|
||||
dispatcher. Landed: `chat_command` V1 handler in
|
||||
`Server/ws/handlers_command.go`; hub gains `SetPluginRegistry`;
|
||||
wired in `api/router.go`. Tests in `handlers_command_test.go`.
|
||||
- [x] Pass the live `*plugin.Registry` from `Server/main.go` into
|
||||
`NewPluginAdminHandler` — landed in Pass 2. The router now accepts
|
||||
a `*plugin.Registry` parameter and the handler is also wrapped in
|
||||
`admin.RequireAdminAuth` (Pass 2 closed the auth bypass too).
|
||||
- [x] Add precompiled `Server/plugin/examples/hello/hello.wasm` (925 KiB).
|
||||
Built with TinyGo 0.40.1 + Go 1.25.3 + Binaryen wasm-opt 129.
|
||||
Source in main.go; exports: allocate, deallocate, list_commands,
|
||||
command_dispatch, on_event.
|
||||
- [x] Implement plugin marketplace install path
|
||||
(`POST /api/v1/admin/plugins/install` with multipart zip) — landed
|
||||
in Pass 4. `Registry.InstallFromZip` does zip-slip validation, no
|
||||
symlinks, 16 MiB compressed cap, 64 MiB uncompressed cap, then
|
||||
atomic rename into the plugin directory.
|
||||
- [x] Replace plugin postgres stubs in `Server/store/postgres.go` with
|
||||
real SQL implementations (same session as EventStore stubs).
|
||||
- [ ] Build the first real plugin: game detection. Pulls Steam API,
|
||||
tracks playtime, exposes `/playtime` slash command. This is the
|
||||
acceptance criterion in `phase-c-differentiation.md`.
|
||||
|
||||
---
|
||||
|
||||
## Build-tag matrix the user should set up in CI
|
||||
|
||||
| Tag set | What it builds | Why |
|
||||
|---|---|---|
|
||||
| (none) | Default sqlite-only server, no OTel SDK, no wazero | Existing path |
|
||||
| `otel` | Above + OpenTelemetry SDK + Prometheus exporter | Phase B Step 8 |
|
||||
| `wazero` | Above + plugin runtime executes WASM modules | Phase C Step 9 |
|
||||
| `postgres` | Replaces sqlite with postgres backend | Phase A pending |
|
||||
| `otel,wazero,postgres` | Full community-hub build | Production target |
|
||||
|
||||
Each tag is independently selectable; CI should test every combination at
|
||||
least minimally so the build-tag boundaries don't drift.
|
||||
|
||||
---
|
||||
|
||||
## Things explicitly **out of scope** for this branch
|
||||
|
||||
(Documenting so reviewers don't expect them.)
|
||||
|
||||
- Migration of the entire vanilla TypeScript component tree to Solid. Two
|
||||
proof-of-concept components landed; the rest is mechanical PRs.
|
||||
- Full OTel SDK wiring (only the public API + no-op default + structural
|
||||
build-tag skeleton landed).
|
||||
- Real Wazero `.wasm` execution (only the registry, host APIs, and a
|
||||
build-tag skeleton landed).
|
||||
- Real game-detection plugin (the manifest fields and host APIs needed to
|
||||
build it are in place).
|
||||
- A reverse postgres → sqlite migration (Phase A documented this is
|
||||
deliberately unavailable; nothing changed here).
|
||||
@@ -1,148 +0,0 @@
|
||||
# OwnCord — Phase B: Acceleration
|
||||
|
||||
**Steps 6–8 | Weeks 6–14 | Community Scale Edition**
|
||||
|
||||
*Solid.js Frontend • Event Persistence • OpenTelemetry*
|
||||
|
||||
---
|
||||
|
||||
## Phase Overview
|
||||
|
||||
Phase B runs after the server foundation is in place. It tackles the three remaining infrastructure gaps: a proper frontend framework to accelerate UI development, event persistence for reliable reconnection at scale, and pluggable observability for community hub operators. These steps overlap with the tail end of Phase A since Step 6 is entirely client-side work.
|
||||
|
||||
The Solid.js migration (Step 6) is the highest-effort, highest-payoff change in the entire plan. Event persistence (Step 7) and OpenTelemetry (Step 8) are shorter server-side tasks that run in parallel. All three are required before the community hub milestone can ship.
|
||||
|
||||
### Timeline
|
||||
|
||||
| Step | Task | Duration | Depends On | Parallel? |
|
||||
|------|------|----------|------------|-----------|
|
||||
| 6 | Adopt Solid.js (incremental) | 4–6 weeks | — | Yes (client-side) |
|
||||
| 7 | Event persistence layer | 1–2 weeks | Steps 1+3 | Yes (with 6, 8) |
|
||||
| 8 | Add OpenTelemetry | 1–2 weeks | Step 1 | Yes (with 6, 7) |
|
||||
|
||||
### Milestone Gate
|
||||
|
||||
**After Phase B:** The client has a proper framework, reconnection is reliable at scale, and operators have pluggable monitoring. The community hub milestone (Milestone 2 from the parity plan) is shippable.
|
||||
|
||||
---
|
||||
|
||||
## Step 6: Adopt Solid.js Frontend Framework
|
||||
|
||||
**Effort:** High (4–6 weeks incremental) | **Impact:** Critical | **Phase:** B — Acceleration
|
||||
|
||||
### Problem
|
||||
|
||||
The vanilla TypeScript frontend has effectively become a custom framework: reactive stores, a component model, a dispatcher, virtual scrolling, manual DOM lifecycle management. Every new UI feature requires hand-wiring DOM creation, updates, and teardown. Community-scale features (role permission editors with tri-state per-channel overrides, audit log viewers with filtering, moderation dashboards, member lists grouped by role with presence indicators) are complex stateful UIs that are painful to build and maintain without a framework.
|
||||
|
||||
### Options
|
||||
|
||||
| Framework | Reactivity Model | Migration Path | Tauri Ecosystem | Verdict |
|
||||
|-----------|-----------------|----------------|-----------------|---------|
|
||||
| **Solid.js** | Signals, effects, memos — maps directly to existing store pattern | Incremental: wrap stores as signals, convert components one by one | Growing. Solid + Tauri examples available. Vite integration native. | **RECOMMENDED** |
|
||||
| Svelte 5 | Runes (compile-time reactivity). Simple component model, no virtual DOM. | Requires rewriting components in .svelte files. Larger upfront cost. | Good. Tauri + Svelte is well-documented. | VIABLE |
|
||||
| React | Virtual DOM reconciliation. useState/useEffect hooks. Largest ecosystem. | Full rewrite into JSX components. Hooks model differs from current stores. | Excellent. Most Tauri projects use React. Huge community. | VIABLE |
|
||||
| Vue 3 | Composition API with ref/reactive. Template-based. Good DX. | Moderate. Composition API maps reasonably to stores. | Good. Tauri + Vue works well. | VIABLE |
|
||||
| Stay vanilla | Custom reactive stores + manual DOM. Full control, full burden. | No migration. But every new feature carries the full cost. | N/A | AVOID |
|
||||
|
||||
### Why Solid.js
|
||||
|
||||
Solid is the recommended choice because it has the lowest migration cost and the closest philosophical match to what OwnCord already has. Your existing reactive stores are conceptually identical to Solid signals. Solid compiles to direct DOM operations with no virtual DOM overhead, so performance stays where it is now. The migration is incremental: wrap existing stores as Solid signals, convert one component at a time, keep the WebSocket dispatcher and LiveKit facade untouched since they are framework-agnostic.
|
||||
|
||||
### Pros & Cons (Solid.js)
|
||||
|
||||
| Pros | Cons |
|
||||
|------|------|
|
||||
| Signals map 1:1 to existing store pattern | Smaller community than React or Vue |
|
||||
| No virtual DOM — same performance as vanilla | Fewer off-the-shelf UI component libraries |
|
||||
| Incremental migration (component by component) | Team must learn Solid's reactivity rules |
|
||||
| Proper component lifecycle and error boundaries | Some vanilla patterns don't translate directly |
|
||||
| Strong TypeScript support (first-class) | Migration is still weeks of work even incrementally |
|
||||
| Small bundle size (~7KB gzipped) | |
|
||||
| Vite integration is native (no config changes) | |
|
||||
|
||||
### Migration Strategy
|
||||
|
||||
1. Install Solid.js and configure Vite for JSX/TSX. Keep all existing code working — Solid and vanilla coexist.
|
||||
2. Wrap existing stores as Solid signals using a thin adapter. This lets new Solid components read from existing state immediately.
|
||||
3. Convert one leaf component (a simple, self-contained UI element) to Solid as a proof of concept. Validate that it works in the Tauri WebView.
|
||||
4. Migrate components bottom-up: leaf components first, then containers. Each converted component is a self-contained PR.
|
||||
5. Leave framework-agnostic code (dispatcher, LiveKit facade, API client, crypto) untouched. These don't need to change.
|
||||
6. Once all components are migrated, remove the old DOM manipulation utilities and the custom component model.
|
||||
|
||||
---
|
||||
|
||||
## Step 7: Event Persistence Layer
|
||||
|
||||
> **NEW IN V2** — This step was a deferred TODO in v1. At community scale the 1000-event ring buffer is insufficient — 100 active users can burn through it in minutes.
|
||||
|
||||
**Effort:** Medium (1–2 weeks) | **Impact:** High | **Phase:** B — Acceleration
|
||||
|
||||
### Problem
|
||||
|
||||
The current reconnection protocol uses a 1000-event in-memory ring buffer. When a client reconnects, the server replays missed events from the buffer. At 100+ active users, a busy server generates 1000 events in minutes. Any user who goes offline for 10–15 minutes will find their last_seq is no longer in the buffer, forcing a full ready re-sync. That re-sync serializes all channels, permissions, member lists, and presence state — an expensive operation that gets more expensive with more users and channels.
|
||||
|
||||
### Solution
|
||||
|
||||
Implement a tiered event persistence model. Keep the in-memory ring buffer for hot events (last ~60 seconds). Write events to the database (via the Store interface from Step 3) for cold replay. On reconnect, the server first checks the ring buffer. If last_seq is too old, it queries the database for events since last_seq up to a reasonable limit. Only if both are exhausted does it fall back to a full ready re-sync. Events in the database are pruned after a configurable retention period (default: 24 hours).
|
||||
|
||||
### Options
|
||||
|
||||
| Option | Details | Verdict |
|
||||
|--------|---------|---------|
|
||||
| **Tiered (buffer + DB)** | Ring buffer for hot path, database for cold replay. Best balance of performance and reliability. Uses existing Store interface. | **RECOMMENDED** |
|
||||
| Larger ring buffer | Increase from 1000 to 50000 events in memory. Simple but uses significant RAM and is still lossy. | VIABLE |
|
||||
| External event log | Use NATS JetStream or Redis Streams. Robust but adds an external dependency to self-hosted deployments. | AVOID |
|
||||
| Status quo | Keep 1000-event buffer. Works for friend groups, fails at community scale. | AVOID |
|
||||
|
||||
### Pros & Cons (Tiered)
|
||||
|
||||
| Pros | Cons |
|
||||
|------|------|
|
||||
| Hot path stays fast (in-memory ring buffer) | Event writes add DB load (mitigated by batching) |
|
||||
| Cold replay from DB handles longer disconnections | Must handle event serialization/deserialization |
|
||||
| Full re-sync becomes rare instead of common | Retention pruning adds a background job |
|
||||
| Uses existing Store interface — no new dependencies | Query performance matters — needs indexed seq column |
|
||||
| Configurable retention (24h default) keeps DB size bounded | Two code paths for replay (buffer vs DB) add complexity |
|
||||
| Architecture was already designed to be persistence-ready | |
|
||||
|
||||
### Implementation Plan
|
||||
|
||||
1. Add an events table to the schema (both SQLite and PostgreSQL migrations): seq INTEGER PRIMARY KEY, event_type TEXT, payload BLOB, channel_id TEXT, created_at TIMESTAMP. Index on (channel_id, seq).
|
||||
2. Add PersistEvent and GetEventsSince methods to the Store interface. The SQLite implementation uses INSERT with write batching (flush every 100ms or 50 events, whichever comes first).
|
||||
3. Modify the reconnection handler: check ring buffer first, then query DB, then fall back to full re-sync. Each tier returns the events it can plus a "complete" flag.
|
||||
4. Add a background goroutine that prunes events older than the retention period (configurable, default 24h). Runs every hour.
|
||||
5. Add metrics for reconnection tier hits (buffer/db/full) to feed into OpenTelemetry (Step 8).
|
||||
|
||||
---
|
||||
|
||||
## Step 8: Add OpenTelemetry for Observability
|
||||
|
||||
> **MOVED UP FROM PHASE C** — This step was Phase C in v1. Community hub operators expect pluggable monitoring from day one.
|
||||
|
||||
**Effort:** Medium (1–2 weeks) | **Impact:** High | **Phase:** B — Acceleration
|
||||
|
||||
### Problem
|
||||
|
||||
The current observability is custom: a /metrics endpoint with hand-picked counters, structured logging across two libraries, and client-side JSONL logs. Community hub operators running servers for 100+ people need plug-and-play compatibility with their existing monitoring stack (Prometheus, Grafana, Datadog). They also need distributed tracing to diagnose slow requests when users report latency.
|
||||
|
||||
### Solution
|
||||
|
||||
Integrate the OpenTelemetry Go SDK. Instrument the Chi router middleware for automatic HTTP tracing, add spans to service layer methods, and export metrics in Prometheus format via OTLP. Self-hosters get plug-and-play compatibility with whatever monitoring they already run. This replaces the custom /metrics endpoint with an industry-standard exporter.
|
||||
|
||||
### What to Instrument
|
||||
|
||||
- **HTTP layer:** Chi middleware for automatic request tracing — method, path, status code, duration. This is a single middleware addition.
|
||||
- **Service layer:** Spans around key service methods (CreateMessage, EditMessage, CheckPermission, etc.). This shows where time is spent in business logic.
|
||||
- **Database layer:** Query timing and connection pool metrics. Shows when the DB is the bottleneck.
|
||||
- **WebSocket layer:** Custom metrics for messages/second, active connections, broadcast latency, reconnection rates (by tier from Step 7).
|
||||
- **LiveKit:** Voice session metrics — active sessions, participant count, connection quality distribution.
|
||||
|
||||
### Pros & Cons
|
||||
|
||||
| Pros | Cons |
|
||||
|------|------|
|
||||
| Self-hosters plug into existing monitoring (Grafana, Datadog, etc.) | OTel SDK adds ~5MB to binary size |
|
||||
| Distributed tracing across REST → Service → DB | Tracing overhead (small but nonzero) on every request |
|
||||
| Replaces custom /metrics with industry-standard export | Configuration complexity for exporters |
|
||||
| Chi and database drivers have OTel middleware available | Additional Docker Compose services (collector) for full setup |
|
||||
| Essential for community hub operators to diagnose issues | |
|
||||
@@ -1,139 +0,0 @@
|
||||
# OwnCord — Phase C: Differentiation
|
||||
|
||||
**Step 9 | When Phase 6 Features Start | Community Scale Edition**
|
||||
|
||||
*Wazero Plugin Runtime • Game Detection • Server Browser • Stats*
|
||||
|
||||
---
|
||||
|
||||
## Phase Overview
|
||||
|
||||
Phase C is about what makes OwnCord different from every other Discord alternative. The plugin system is the core differentiator — game detection, server browser, stats, leaderboards, screenshots. All of these are implemented as plugins, not core features, which keeps the server lean while enabling an ecosystem.
|
||||
|
||||
This phase has a single step: implementing the plugin runtime using Wazero. It waits until the plugin features from the product roadmap (Phase 6) are actively being built. There is no urgency to implement the runtime before the features that use it are in scope. The server foundation from Phase A and the client framework from Phase B must be in place first.
|
||||
|
||||
### Timeline
|
||||
|
||||
| Step | Task | Duration | Depends On | Parallel? |
|
||||
|------|------|----------|------------|-----------|
|
||||
| 9 | Wazero plugin runtime | 4–6 weeks | Step 1 | When Phase 6 starts |
|
||||
|
||||
### Milestone Gate
|
||||
|
||||
**After Phase C:** The plugin runtime enables the gaming features that differentiate OwnCord from every other Discord alternative. Game detection, rich presence, playtime tracking, server browser, stats, and leaderboards all run as sandboxed WASM plugins. Third-party developers can build and distribute plugins through the plugin marketplace.
|
||||
|
||||
### Prerequisites
|
||||
|
||||
- **Phase A complete:** The service layer (Step 1) provides the host API surface that plugins call into. The Store interface (Step 3) provides plugin-scoped storage. The pub/sub hub (Step 5) enables plugins to emit events to subscribed clients.
|
||||
- **Phase B complete:** The Solid.js frontend (Step 6) enables plugin UI tabs and widgets. OpenTelemetry (Step 8) provides plugin performance monitoring.
|
||||
|
||||
---
|
||||
|
||||
## Step 9: Use Wazero for Plugin Runtime
|
||||
|
||||
**Effort:** High (4–6 weeks) | **Impact:** High | **Phase:** C — Differentiation
|
||||
|
||||
### Problem
|
||||
|
||||
The plugin system is OwnCord's core differentiator — game detection, server browser, stats, leaderboards — but the runtime is only designed, not implemented. The design mentions WASM or shared library loading. Shared libraries (.so/.dll) offer no sandboxing, crash the host process on failure, and are platform-specific. At community scale, a misbehaving plugin taking down a 100-user server is unacceptable.
|
||||
|
||||
### Options
|
||||
|
||||
| Option | Details | Verdict |
|
||||
|--------|---------|---------|
|
||||
| **Wazero** | Pure-Go WebAssembly runtime. No CGO. Memory-sandboxed, resource-limited, language-agnostic plugin authoring (Rust, Go, C, AssemblyScript). | **RECOMMENDED** |
|
||||
| Extism | Plugin framework built on Wazero. Higher-level API, easier plugin development. Adds a dependency layer on top of Wazero. | VIABLE |
|
||||
| Shared libs | Native .so/.dll loading via Go plugin package. No sandboxing, platform-specific, crashes take down the server. | AVOID |
|
||||
| gRPC sidecar | Plugins as separate processes communicating via gRPC. Strong isolation but heavy: each plugin is a full process with its own lifecycle. | VIABLE |
|
||||
|
||||
### Why Wazero
|
||||
|
||||
Wazero is the recommended choice because it is pure Go (no CGO, matching the existing constraint), provides real memory sandboxing, supports resource limits per plugin (CPU and memory caps), and enables language-agnostic plugin development. Plugins compile to WASM from Rust, Go, C, or AssemblyScript. A crashing plugin cannot take down the server. At community scale this isolation is non-negotiable — you cannot allow a third-party plugin to crash a server serving 100+ users.
|
||||
|
||||
Extism is a viable alternative if you want a higher-level abstraction over Wazero. It simplifies plugin authoring with PDKs (Plugin Development Kits) for multiple languages and handles memory management between host and guest. The tradeoff is an additional dependency and less control over the low-level WASM runtime. For OwnCord's plugin use cases (game detection, server queries, stats computation), the raw Wazero API is sufficient and more transparent.
|
||||
|
||||
### Pros & Cons (Wazero)
|
||||
|
||||
| Pros | Cons |
|
||||
|------|------|
|
||||
| Pure Go — no CGO, matches existing constraint | WASM has limited I/O capabilities by design |
|
||||
| Real memory sandboxing (plugins can't crash server) | Plugin performance is slower than native (~2–5x) |
|
||||
| Resource limits per plugin (CPU, memory) | Debugging WASM plugins is harder than native code |
|
||||
| Language-agnostic: Rust, Go, C, AssemblyScript → WASM | Plugin authors must learn WASM toolchain |
|
||||
| Well-defined host API for plugin ↔ server communication | Complex host API design for game detection, UI tabs, etc. |
|
||||
| Critical for community scale — isolation is non-negotiable | |
|
||||
|
||||
---
|
||||
|
||||
## Architecture
|
||||
|
||||
The plugin runtime has four components: the loader, the host API, the sandbox, and the client bridge.
|
||||
|
||||
### Plugin Loader
|
||||
|
||||
Reads plugin.toml manifests, validates declared permissions, loads the .wasm binary into a Wazero runtime instance. Each plugin gets its own isolated module with a dedicated memory space. The loader handles plugin lifecycle: install, enable, disable, uninstall, update.
|
||||
|
||||
### Host API
|
||||
|
||||
The server exposes functions that plugins can call through WASM imports. These are the capabilities a plugin requests in its manifest:
|
||||
|
||||
- **commands:** Register slash commands (/playtime, /serverstatus, /stats). The command dispatcher routes user input to the owning plugin.
|
||||
- **events:** Subscribe to server events (message_send, user_join, voice_join). The pub/sub hub (Step 5) delivers subscribed events to the plugin.
|
||||
- **storage:** Plugin-scoped key-value storage via the Store interface (Step 3). Each plugin gets its own namespace. No cross-plugin data access.
|
||||
- **http:** Outbound HTTP requests (for querying game servers, APIs). Proxied through the server with configurable allowlists per plugin.
|
||||
- **ui:** Register UI tabs and widgets that render in the Solid.js client (Step 6). Plugin declares HTML/JS assets, client renders them in an iframe sandbox.
|
||||
|
||||
### Sandbox
|
||||
|
||||
Each plugin instance runs with enforced limits: maximum memory allocation (default 64MB), CPU time budget per invocation (default 100ms), and no direct filesystem or network access. The server monitors resource usage and kills plugins that exceed their budget. A crashed or killed plugin is automatically disabled and the admin is notified via the mod log channel.
|
||||
|
||||
### Client Bridge
|
||||
|
||||
Plugins that declare UI capabilities get a rendering surface in the Solid.js client. Plugin UI runs in a sandboxed iframe with postMessage communication to the host client. The host provides a theme-aware CSS injection so plugin UIs match OwnCord's look and feel. The client bridge also handles plugin-specific settings panels.
|
||||
|
||||
---
|
||||
|
||||
## Implementation Plan
|
||||
|
||||
1. Define the plugin.toml manifest format: name, version, author, permissions (commands, events, storage, http, ui), resource limits. Validate against a JSON schema.
|
||||
2. Implement the Wazero runtime wrapper: module loading, memory allocation, function imports/exports, lifecycle management (start, stop, restart).
|
||||
3. Implement the host API functions one capability at a time. Start with commands (simplest — input/output only), then events (requires pub/sub integration), then storage, then HTTP.
|
||||
4. Build the first plugin: game detection. This exercises commands (user queries playtime), events (presence updates), storage (playtime database), and HTTP (Steam API queries). If game detection works, the architecture is validated.
|
||||
5. Add the UI capability: client-side iframe sandbox, postMessage bridge, theme injection. Build the server browser plugin to validate the UI integration.
|
||||
6. Implement plugin marketplace: browse available plugins, install/update/remove from within the admin panel. Plugin packages are .wasm + assets in a zip archive hosted on a registry (GitHub Releases initially).
|
||||
|
||||
---
|
||||
|
||||
## Complete Timeline — All Phases
|
||||
|
||||
For reference, here is the complete execution timeline across all three phases.
|
||||
|
||||
### Phase A: Foundation (Weeks 1–7)
|
||||
|
||||
| Step | Task | Duration | Depends On | Parallel? |
|
||||
|------|------|----------|------------|-----------|
|
||||
| 1 | Extract service/domain layer + permission cache | 2–3 weeks | — | No |
|
||||
| 2 | Adopt sqlc | 1 week | — | Yes (with 1) |
|
||||
| 3 | Abstract DB + PostgreSQL target | 2–3 weeks | Steps 1+2 | No |
|
||||
| 4 | Consolidate logging | 1–2 days | — | Yes (anytime) |
|
||||
| 5 | Refactor hub to pub/sub + global rate limits | 2–3 weeks | Step 1 | After Step 1 |
|
||||
|
||||
### Phase B: Acceleration (Weeks 6–14)
|
||||
|
||||
| Step | Task | Duration | Depends On | Parallel? |
|
||||
|------|------|----------|------------|-----------|
|
||||
| 6 | Adopt Solid.js (incremental) | 4–6 weeks | — | Yes (client-side) |
|
||||
| 7 | Event persistence layer | 1–2 weeks | Steps 1+3 | Yes (with 6, 8) |
|
||||
| 8 | Add OpenTelemetry | 1–2 weeks | Step 1 | Yes (with 6, 7) |
|
||||
|
||||
### Phase C: Differentiation (When Phase 6 Features Start)
|
||||
|
||||
| Step | Task | Duration | Depends On | Parallel? |
|
||||
|------|------|----------|------------|-----------|
|
||||
| 9 | Wazero plugin runtime | 4–6 weeks | Step 1 | When ready |
|
||||
|
||||
### Total
|
||||
|
||||
**14–18 weeks** for Steps 1–8. Step 9 is deferred until plugin features are in scope. Phases overlap, so calendar time is shorter than the sum of estimates.
|
||||
|
||||
The central principle: stop building infrastructure, start using infrastructure. Every hour spent maintaining a custom query layer, a custom component model, a custom broadcast loop, or a custom event buffer is an hour not spent on the 146 features that make OwnCord compete with Discord.
|
||||
@@ -1 +0,0 @@
|
||||
.cache/
|
||||
File diff suppressed because it is too large
Load Diff
@@ -1,100 +0,0 @@
|
||||
#!/usr/bin/env node
|
||||
/**
|
||||
* OwnCord Project Map Generator
|
||||
*
|
||||
* Scans the repository, collects test coverage, parses the backlog,
|
||||
* scores priorities, and outputs a markdown report + terminal summary.
|
||||
*
|
||||
* Usage:
|
||||
* node index.mjs # full run (runs tests for coverage)
|
||||
* node index.mjs --quick # skip test runs, use cached coverage
|
||||
* node index.mjs --research # interactive research launcher
|
||||
* node index.mjs --serve # launch web dashboard
|
||||
*/
|
||||
|
||||
import { scanModules } from './lib/scanner.mjs';
|
||||
import { collectGoCoverage } from './lib/go-coverage.mjs';
|
||||
import { collectVitestCoverage } from './lib/vitest-coverage.mjs';
|
||||
import { parseBacklog } from './lib/backlog-parser.mjs';
|
||||
import { scorePriorities } from './lib/priority-engine.mjs';
|
||||
import { generateReport } from './lib/report-generator.mjs';
|
||||
import { printTerminalSummary } from './lib/terminal-summary.mjs';
|
||||
import { launchResearchAgent } from './lib/research-agent.mjs';
|
||||
import { scanGitHistory } from './lib/git-scanner.mjs';
|
||||
import { parseSessionHistory } from './lib/session-parser.mjs';
|
||||
import { scanTechnicalDebt } from './lib/debt-scanner.mjs';
|
||||
import { buildImportGraph } from './lib/import-graph.mjs';
|
||||
import { generateSuggestions } from './lib/suggestion-engine.mjs';
|
||||
import { resolve, dirname } from 'node:path';
|
||||
import { fileURLToPath } from 'node:url';
|
||||
import { existsSync, mkdirSync } from 'node:fs';
|
||||
|
||||
const __dirname = dirname(fileURLToPath(import.meta.url));
|
||||
const ROOT = resolve(__dirname, '../..');
|
||||
const CACHE_DIR = resolve(__dirname, '.cache');
|
||||
const REPORT_PATH = resolve(ROOT, 'docs/brain/00-Overview/Project-Map.md');
|
||||
|
||||
const args = process.argv.slice(2);
|
||||
const quick = args.includes('--quick');
|
||||
const research = args.includes('--research');
|
||||
const serve = args.includes('--serve');
|
||||
|
||||
if (!existsSync(CACHE_DIR)) mkdirSync(CACHE_DIR, { recursive: true });
|
||||
|
||||
async function main() {
|
||||
if (research) {
|
||||
await launchResearchAgent(ROOT);
|
||||
return;
|
||||
}
|
||||
|
||||
if (serve) {
|
||||
// Dynamic import to launch the server
|
||||
await import('./server.mjs');
|
||||
return;
|
||||
}
|
||||
|
||||
console.log(quick
|
||||
? '\n Project Map (quick mode — using cached data)\n'
|
||||
: '\n Project Map (full mode — running tests for coverage)\n');
|
||||
|
||||
// Core data
|
||||
const modules = await scanModules(ROOT);
|
||||
const goCoverage = await collectGoCoverage(ROOT, CACHE_DIR, quick);
|
||||
const vitestCoverage = await collectVitestCoverage(ROOT, CACHE_DIR, quick);
|
||||
const backlog = await parseBacklog(ROOT);
|
||||
const priorities = scorePriorities(modules, goCoverage, vitestCoverage, backlog);
|
||||
|
||||
// Enhanced data (graceful failures)
|
||||
let gitData = null, sessionData = null, debtData = null, importGraph = null, suggestions = null;
|
||||
try { gitData = await scanGitHistory(ROOT, CACHE_DIR, quick); } catch (e) { console.error(` [Git] ${e.message}`); }
|
||||
try { sessionData = await parseSessionHistory(ROOT, CACHE_DIR, quick); } catch (e) { console.error(` [Session] ${e.message}`); }
|
||||
try { debtData = await scanTechnicalDebt(ROOT, CACHE_DIR, quick); } catch (e) { console.error(` [Debt] ${e.message}`); }
|
||||
try { importGraph = await buildImportGraph(ROOT, CACHE_DIR, quick); } catch (e) { console.error(` [Graph] ${e.message}`); }
|
||||
try {
|
||||
suggestions = await generateSuggestions(CACHE_DIR, {
|
||||
priorities, goCoverage, vitestCoverage, backlog, gitData, debtData, importGraph, sessionData,
|
||||
});
|
||||
} catch (e) { console.error(` [Suggestions] ${e.message}`); }
|
||||
|
||||
// Generate markdown report
|
||||
await generateReport(REPORT_PATH, modules, goCoverage, vitestCoverage, backlog, priorities);
|
||||
|
||||
// Print terminal summary
|
||||
printTerminalSummary(modules, goCoverage, vitestCoverage, backlog, priorities);
|
||||
|
||||
// Print top suggestions
|
||||
if (suggestions?.suggestions?.length) {
|
||||
const CYAN = '\x1b[36m', BOLD = '\x1b[1m', DIM = '\x1b[2m', RESET = '\x1b[0m';
|
||||
console.log(`\n ${CYAN}${BOLD}SMART SUGGESTIONS (${suggestions.strategy})${RESET}`);
|
||||
console.log(` ${DIM}${'─'.repeat(60)}${RESET}`);
|
||||
for (const s of suggestions.suggestions.slice(0, 5)) {
|
||||
console.log(` ${CYAN}${s.rank}.${RESET} ${BOLD}${s.module}${RESET} (score: ${s.score}) — ${DIM}${s.rationale}${RESET}`);
|
||||
}
|
||||
console.log('');
|
||||
}
|
||||
}
|
||||
|
||||
main().catch(err => {
|
||||
console.error('Project map failed:', err.message);
|
||||
process.exit(1);
|
||||
});
|
||||
@@ -1,988 +0,0 @@
|
||||
/**
|
||||
* Fleet Agent Manager — concurrent job queue with worktree isolation.
|
||||
*
|
||||
* Reworked from single-job queue to support parallel agent execution.
|
||||
* Each agent runs in its own git worktree via worktree-manager.
|
||||
*
|
||||
* Key changes from v1:
|
||||
* - activeAgents Map replaces queueLocked boolean
|
||||
* - QueueStore provides atomic read-modify-write for queue file
|
||||
* - Ring buffer caps live output at 500KB per agent
|
||||
* - Provisioning state for worktree creation phase
|
||||
* - MAX_CONCURRENT configurable parallel limit
|
||||
* - Timeout escalation: 80% warning → SIGTERM → 5s → SIGKILL
|
||||
*/
|
||||
import { execFileSync, spawn } from 'node:child_process';
|
||||
import { randomBytes } from 'node:crypto';
|
||||
import {
|
||||
existsSync,
|
||||
mkdirSync,
|
||||
readFileSync,
|
||||
writeFileSync,
|
||||
readdirSync,
|
||||
statSync,
|
||||
unlinkSync,
|
||||
} from 'node:fs';
|
||||
import { resolve, join } from 'node:path';
|
||||
|
||||
import {
|
||||
createWorktree,
|
||||
destroyWorktree,
|
||||
cleanupStaleWorktrees,
|
||||
} from './worktree-manager.mjs';
|
||||
|
||||
// ---------------------------------------------------------------------------
|
||||
// Constants
|
||||
// ---------------------------------------------------------------------------
|
||||
|
||||
const QUEUE_FILE = 'agent-queue.json';
|
||||
const RESULTS_DIR = 'agent-results';
|
||||
const PROMPTS_DIR = 'agent-prompts';
|
||||
|
||||
const ALLOWED_TYPES = new Set([
|
||||
'research',
|
||||
'write-tests',
|
||||
'code-review',
|
||||
'security-audit',
|
||||
'fix-debt',
|
||||
'custom',
|
||||
]);
|
||||
|
||||
const TIMEOUTS = {
|
||||
research: 600_000,
|
||||
'write-tests': 1_200_000,
|
||||
'code-review': 900_000,
|
||||
'security-audit': 1_200_000,
|
||||
'fix-debt': 900_000,
|
||||
custom: 1_800_000,
|
||||
};
|
||||
|
||||
/** Default max concurrent agents */
|
||||
let MAX_CONCURRENT = 4;
|
||||
|
||||
/** Ring buffer cap per agent (bytes) */
|
||||
const RING_BUFFER_MAX = 512_000; // 500KB
|
||||
|
||||
// ---------------------------------------------------------------------------
|
||||
// QueueStore — centralized queue I/O with atomic updates
|
||||
// ---------------------------------------------------------------------------
|
||||
|
||||
class QueueStore {
|
||||
#cacheDir;
|
||||
#updateLock = false;
|
||||
|
||||
constructor(cacheDir) {
|
||||
this.#cacheDir = cacheDir;
|
||||
}
|
||||
|
||||
/** Read current queue state */
|
||||
get() {
|
||||
const file = resolve(this.#cacheDir, QUEUE_FILE);
|
||||
if (!existsSync(file)) return [];
|
||||
try {
|
||||
const raw = readFileSync(file, 'utf8');
|
||||
const parsed = JSON.parse(raw);
|
||||
return Array.isArray(parsed) ? parsed : [];
|
||||
} catch {
|
||||
return [];
|
||||
}
|
||||
}
|
||||
|
||||
/** Get a single job by ID */
|
||||
getJob(jobId) {
|
||||
return this.get().find(j => j.id === jobId) ?? null;
|
||||
}
|
||||
|
||||
/**
|
||||
* Atomic read-modify-write. The updater function receives the current
|
||||
* jobs array and must return the new jobs array.
|
||||
* Prevents concurrent reads from overwriting each other's changes.
|
||||
*/
|
||||
update(updaterFn) {
|
||||
if (this.#updateLock) {
|
||||
throw new Error('QueueStore: concurrent update detected');
|
||||
}
|
||||
this.#updateLock = true;
|
||||
try {
|
||||
const jobs = this.get();
|
||||
const updated = updaterFn(jobs);
|
||||
writeFileSync(
|
||||
resolve(this.#cacheDir, QUEUE_FILE),
|
||||
JSON.stringify(updated, null, 2),
|
||||
);
|
||||
return updated;
|
||||
} finally {
|
||||
this.#updateLock = false;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/** Module-level store instance — set via init() or createJob() */
|
||||
let store = null;
|
||||
|
||||
function ensureStore(cacheDir) {
|
||||
if (!store || store._dir !== cacheDir) {
|
||||
store = new QueueStore(cacheDir);
|
||||
store._dir = cacheDir;
|
||||
}
|
||||
return store;
|
||||
}
|
||||
|
||||
// ---------------------------------------------------------------------------
|
||||
// Helpers — directory setup
|
||||
// ---------------------------------------------------------------------------
|
||||
|
||||
function ensureDirs(cacheDir) {
|
||||
mkdirSync(resolve(cacheDir, RESULTS_DIR), { recursive: true });
|
||||
mkdirSync(resolve(cacheDir, PROMPTS_DIR), { recursive: true });
|
||||
}
|
||||
|
||||
// ---------------------------------------------------------------------------
|
||||
// Helpers — scope path resolution
|
||||
// ---------------------------------------------------------------------------
|
||||
|
||||
const GO_PACKAGES = new Set([
|
||||
'api', 'ws', 'db', 'auth', 'config', 'admin', 'migrations', 'scripts',
|
||||
]);
|
||||
|
||||
const TS_AREAS = new Set([
|
||||
'lib', 'stores', 'components', 'pages',
|
||||
]);
|
||||
|
||||
function resolveScopePath(target) {
|
||||
if (GO_PACKAGES.has(target)) return `Server/${target}/`;
|
||||
if (TS_AREAS.has(target)) return `Client/tauri-client/src/${target}/`;
|
||||
if (target === 'tauri-rust') return 'Client/tauri-client/src-tauri/src/';
|
||||
return target;
|
||||
}
|
||||
|
||||
// ---------------------------------------------------------------------------
|
||||
// Helpers — process checking
|
||||
// ---------------------------------------------------------------------------
|
||||
|
||||
function isProcessAlive(pid) {
|
||||
const safePid = parseInt(pid, 10);
|
||||
if (!Number.isInteger(safePid) || safePid <= 0) return false;
|
||||
try {
|
||||
process.kill(safePid, 0);
|
||||
return true;
|
||||
} catch {
|
||||
return false;
|
||||
}
|
||||
}
|
||||
|
||||
function isClaudeProcess(pid) {
|
||||
const safePid = parseInt(pid, 10);
|
||||
if (!Number.isInteger(safePid) || safePid <= 0) return false;
|
||||
try {
|
||||
if (process.platform === 'win32') {
|
||||
const out = execFileSync(
|
||||
'tasklist',
|
||||
['/FI', `PID eq ${safePid}`, '/FO', 'CSV', '/NH'],
|
||||
{ stdio: 'pipe', timeout: 5_000 },
|
||||
).toString();
|
||||
const lower = out.toLowerCase();
|
||||
return lower.includes('claude') || lower.includes('node');
|
||||
}
|
||||
const out = execFileSync('ps', ['-p', String(safePid), '-o', 'comm='], {
|
||||
stdio: 'pipe',
|
||||
timeout: 5_000,
|
||||
}).toString().trim().toLowerCase();
|
||||
return out.includes('claude') || out.includes('node');
|
||||
} catch {
|
||||
return false;
|
||||
}
|
||||
}
|
||||
|
||||
function killProcess(pid) {
|
||||
const safePid = parseInt(pid, 10);
|
||||
if (!Number.isInteger(safePid) || safePid <= 0) return;
|
||||
try {
|
||||
process.kill(safePid, 'SIGTERM');
|
||||
setTimeout(() => {
|
||||
try {
|
||||
process.kill(safePid, 0);
|
||||
process.kill(safePid, 'SIGKILL');
|
||||
} catch { /* already dead */ }
|
||||
}, 5_000);
|
||||
} catch { /* already dead */ }
|
||||
}
|
||||
|
||||
// ---------------------------------------------------------------------------
|
||||
// Active agents — tracks running processes
|
||||
// ---------------------------------------------------------------------------
|
||||
|
||||
/** Map<jobId, { pid, worktreePath, branchName, child, timer, warningTimer }> */
|
||||
const activeAgents = new Map();
|
||||
|
||||
/** Processing flag — guards the auto-process interval from double-spawn */
|
||||
let isProcessing = false;
|
||||
|
||||
// ---------------------------------------------------------------------------
|
||||
// Ring buffer for live output
|
||||
// ---------------------------------------------------------------------------
|
||||
|
||||
const liveOutputBuffers = new Map();
|
||||
|
||||
function appendToRingBuffer(jobId, text) {
|
||||
const current = liveOutputBuffers.get(jobId) || '';
|
||||
let updated = current + text;
|
||||
|
||||
if (updated.length > RING_BUFFER_MAX) {
|
||||
const truncateMarker = '\n[... output truncated — showing last 500KB ...]\n';
|
||||
updated = truncateMarker + updated.slice(updated.length - RING_BUFFER_MAX + truncateMarker.length);
|
||||
}
|
||||
|
||||
liveOutputBuffers.set(jobId, updated);
|
||||
}
|
||||
|
||||
export function getLiveOutput(jobId) {
|
||||
return liveOutputBuffers.get(jobId) || '';
|
||||
}
|
||||
|
||||
export function clearLiveOutput(jobId) {
|
||||
liveOutputBuffers.delete(jobId);
|
||||
}
|
||||
|
||||
// ---------------------------------------------------------------------------
|
||||
// Prompt templates
|
||||
// ---------------------------------------------------------------------------
|
||||
|
||||
function buildPrompt(job, _root) {
|
||||
const { type, target, customPrompt } = job;
|
||||
const scopePath = resolveScopePath(target);
|
||||
|
||||
switch (type) {
|
||||
case 'research':
|
||||
return [
|
||||
`You are a research agent for OwnCord. Investigate the ${target} module.`,
|
||||
'Focus on: coverage gaps, potential bugs, edge cases, security concerns, missing functionality.',
|
||||
`Scope: ${scopePath}`,
|
||||
'Read relevant source and test files. Prioritize findings as CRITICAL/HIGH/MEDIUM/LOW.',
|
||||
'Output a structured markdown report.',
|
||||
].join('\n');
|
||||
|
||||
case 'write-tests':
|
||||
return [
|
||||
'You are a test-writing agent for OwnCord.',
|
||||
`Module: ${target}`,
|
||||
`Read the source files in ${scopePath}.`,
|
||||
'Read docs/brain/06-Specs/TESTING-STRATEGY.md for test patterns.',
|
||||
'Write tests targeting untested functions and branches. Aim for 80%+ coverage.',
|
||||
'Save tests to the appropriate test directory.',
|
||||
].join('\n');
|
||||
|
||||
case 'code-review':
|
||||
return [
|
||||
'You are a code review agent for OwnCord.',
|
||||
`Review recent changes in the ${target} module for bugs, security issues, code quality.`,
|
||||
`Scope: ${scopePath}`,
|
||||
'Output findings with file:line references and severity ratings.',
|
||||
].join('\n');
|
||||
|
||||
case 'security-audit':
|
||||
return [
|
||||
'You are a security audit agent for OwnCord.',
|
||||
`Perform an OWASP Top 10 review of the ${target} module.`,
|
||||
`Scope: ${scopePath}`,
|
||||
'Check for: injection, auth bypass, XSS, CSRF, path traversal, hardcoded secrets.',
|
||||
'Output findings with severity, file:line, and remediation steps.',
|
||||
].join('\n');
|
||||
|
||||
case 'fix-debt':
|
||||
return [
|
||||
'You are a technical debt agent for OwnCord.',
|
||||
`Address TODO/FIXME/HACK items in the ${target} module.`,
|
||||
`Scope: ${scopePath}`,
|
||||
'For each debt marker, either fix it or explain why it should remain.',
|
||||
].join('\n');
|
||||
|
||||
case 'custom':
|
||||
return customPrompt;
|
||||
|
||||
default:
|
||||
return `Investigate ${target} in OwnCord.`;
|
||||
}
|
||||
}
|
||||
|
||||
// ---------------------------------------------------------------------------
|
||||
// Activity hint parsing — extract file paths from agent stdout
|
||||
// ---------------------------------------------------------------------------
|
||||
|
||||
const FILE_PATH_PATTERNS = [
|
||||
/Server\/[\w/.-]+\.go/g,
|
||||
/Client\/[\w/.-]+\.tsx?/g,
|
||||
/(?<!\/)src\/[\w/.-]+\.tsx?/g,
|
||||
/src-tauri\/[\w/.-]+\.rs/g,
|
||||
/docs\/[\w/.-]+\.md/g,
|
||||
];
|
||||
|
||||
export function parseActivityHints(chunk) {
|
||||
if (!chunk || typeof chunk !== 'string') return [];
|
||||
|
||||
const seen = new Set();
|
||||
const results = [];
|
||||
|
||||
for (const pattern of FILE_PATH_PATTERNS) {
|
||||
pattern.lastIndex = 0;
|
||||
let match;
|
||||
while ((match = pattern.exec(chunk)) !== null) {
|
||||
const file = match[0];
|
||||
if (!seen.has(file)) {
|
||||
seen.add(file);
|
||||
results.push({ hint: `Accessing ${file}`, file });
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
return results;
|
||||
}
|
||||
|
||||
// ---------------------------------------------------------------------------
|
||||
// Git diff for running jobs
|
||||
// ---------------------------------------------------------------------------
|
||||
|
||||
function gitArgs(args, root) {
|
||||
return execFileSync('git', args, {
|
||||
cwd: root,
|
||||
encoding: 'utf8',
|
||||
maxBuffer: 10 * 1024 * 1024,
|
||||
stdio: ['pipe', 'pipe', 'pipe'],
|
||||
}).trim();
|
||||
}
|
||||
|
||||
/**
|
||||
* Get the current git diff for a job.
|
||||
* For fleet jobs, reads diff from the worktree directory.
|
||||
*/
|
||||
export function getJobDiff(root, baselineSha, preExistingDirtyFiles, worktreePath) {
|
||||
const diffRoot = worktreePath || root;
|
||||
const excludeSet = new Set(preExistingDirtyFiles || []);
|
||||
const freshness = new Date().toISOString();
|
||||
|
||||
let numstatRaw = '';
|
||||
try {
|
||||
const args = baselineSha
|
||||
? ['diff', baselineSha, '--numstat']
|
||||
: ['diff', '--numstat'];
|
||||
numstatRaw = gitArgs(args, diffRoot);
|
||||
} catch { /* empty diff */ }
|
||||
|
||||
let untrackedRaw = '';
|
||||
try {
|
||||
untrackedRaw = gitArgs(['ls-files', '--others', '--exclude-standard'], diffRoot);
|
||||
} catch { /* ignore */ }
|
||||
|
||||
const files = [];
|
||||
const trackedPaths = new Set();
|
||||
|
||||
for (const line of numstatRaw.split('\n').filter(Boolean)) {
|
||||
const parts = line.split('\t');
|
||||
if (parts.length < 3) continue;
|
||||
const additions = parseInt(parts[0], 10) || 0;
|
||||
const deletions = parseInt(parts[1], 10) || 0;
|
||||
const path = parts[2];
|
||||
if (excludeSet.has(path)) continue;
|
||||
trackedPaths.add(path);
|
||||
files.push({ path, status: 'M', additions, deletions });
|
||||
}
|
||||
|
||||
for (const path of untrackedRaw.split('\n').filter(Boolean)) {
|
||||
if (excludeSet.has(path)) continue;
|
||||
if (trackedPaths.has(path)) continue;
|
||||
files.push({ path, status: 'A', additions: 0, deletions: 0 });
|
||||
}
|
||||
|
||||
const diffs = {};
|
||||
for (const f of files) {
|
||||
try {
|
||||
if (f.status === 'A') {
|
||||
const fullPath = resolve(diffRoot, f.path);
|
||||
const content = readFileSync(fullPath, 'utf8');
|
||||
const lines = content.split('\n');
|
||||
f.additions = lines.length;
|
||||
diffs[f.path] = lines.map(l => '+' + l).join('\n');
|
||||
} else {
|
||||
const args = baselineSha
|
||||
? ['diff', baselineSha, '--', f.path]
|
||||
: ['diff', '--', f.path];
|
||||
const content = gitArgs(args, diffRoot);
|
||||
diffs[f.path] = content;
|
||||
}
|
||||
} catch {
|
||||
diffs[f.path] = '';
|
||||
}
|
||||
}
|
||||
|
||||
return { files, diffs, freshness };
|
||||
}
|
||||
|
||||
// ---------------------------------------------------------------------------
|
||||
// Public API — configuration
|
||||
// ---------------------------------------------------------------------------
|
||||
|
||||
export function setMaxConcurrent(n) {
|
||||
const val = parseInt(n, 10);
|
||||
if (Number.isInteger(val) && val >= 1 && val <= 8) {
|
||||
MAX_CONCURRENT = val;
|
||||
}
|
||||
}
|
||||
|
||||
export function getMaxConcurrent() {
|
||||
return MAX_CONCURRENT;
|
||||
}
|
||||
|
||||
export function getActiveCount() {
|
||||
return activeAgents.size;
|
||||
}
|
||||
|
||||
export function getActiveAgentIds() {
|
||||
return [...activeAgents.keys()];
|
||||
}
|
||||
|
||||
// ---------------------------------------------------------------------------
|
||||
// Public API — health check
|
||||
// ---------------------------------------------------------------------------
|
||||
|
||||
export function healthCheck() {
|
||||
try {
|
||||
const version = execFileSync('claude', ['--version'], { stdio: 'pipe' })
|
||||
.toString()
|
||||
.trim();
|
||||
return { available: true, version };
|
||||
} catch (err) {
|
||||
return { available: false, error: err.message || 'Claude CLI not found' };
|
||||
}
|
||||
}
|
||||
|
||||
// ---------------------------------------------------------------------------
|
||||
// Public API — job CRUD
|
||||
// ---------------------------------------------------------------------------
|
||||
|
||||
export function getJobs(cacheDir) {
|
||||
const s = ensureStore(cacheDir);
|
||||
const jobs = s.get();
|
||||
const sorted = [...jobs].sort((a, b) => {
|
||||
const priDiff = (b.priority ?? 1) - (a.priority ?? 1);
|
||||
if (priDiff !== 0) return priDiff;
|
||||
return new Date(a.createdAt).getTime() - new Date(b.createdAt).getTime();
|
||||
});
|
||||
return { jobs: sorted };
|
||||
}
|
||||
|
||||
export function createJob(cacheDir, { type, target, priority, customPrompt }) {
|
||||
if (!ALLOWED_TYPES.has(type)) {
|
||||
throw new Error(`Invalid job type "${type}". Allowed: ${[...ALLOWED_TYPES].join(', ')}`);
|
||||
}
|
||||
if (!target || typeof target !== 'string' || target.trim().length === 0) {
|
||||
throw new Error('Job target must be a non-empty string');
|
||||
}
|
||||
if (type === 'custom' && (!customPrompt || typeof customPrompt !== 'string' || customPrompt.trim().length === 0)) {
|
||||
throw new Error('Custom jobs require a non-empty customPrompt');
|
||||
}
|
||||
|
||||
ensureDirs(cacheDir);
|
||||
const s = ensureStore(cacheDir);
|
||||
|
||||
const job = {
|
||||
id: `job-${Date.now()}-${randomBytes(4).toString('hex')}`,
|
||||
type,
|
||||
target: target.trim(),
|
||||
status: 'queued',
|
||||
createdAt: new Date().toISOString(),
|
||||
startedAt: null,
|
||||
completedAt: null,
|
||||
resultPath: null,
|
||||
error: null,
|
||||
priority: typeof priority === 'number' ? priority : 1,
|
||||
retryCount: 0,
|
||||
maxRetries: 2,
|
||||
pid: null,
|
||||
customPrompt: customPrompt ?? null,
|
||||
// Fleet fields
|
||||
worktreePath: null,
|
||||
branchName: null,
|
||||
configMethod: null,
|
||||
};
|
||||
|
||||
s.update(jobs => [...jobs, job]);
|
||||
return job;
|
||||
}
|
||||
|
||||
export function cancelJob(cacheDir, jobId) {
|
||||
const s = ensureStore(cacheDir);
|
||||
const job = s.getJob(jobId);
|
||||
if (!job) throw new Error(`Job "${jobId}" not found`);
|
||||
|
||||
if (job.status === 'queued') {
|
||||
s.update(jobs => jobs.filter(j => j.id !== jobId));
|
||||
return { ok: true };
|
||||
}
|
||||
|
||||
if (job.status === 'provisioning' || job.status === 'running') {
|
||||
// Kill process if running
|
||||
const agent = activeAgents.get(jobId);
|
||||
if (agent?.pid) killProcess(agent.pid);
|
||||
if (agent?.timer) clearTimeout(agent.timer);
|
||||
if (agent?.warningTimer) clearTimeout(agent.warningTimer);
|
||||
activeAgents.delete(jobId);
|
||||
|
||||
// Destroy worktree
|
||||
if (job.worktreePath) {
|
||||
try {
|
||||
const root = resolve(job.worktreePath, '..', '..');
|
||||
destroyWorktree(root, jobId);
|
||||
} catch (err) {
|
||||
console.error(` [Agent] Worktree cleanup failed for ${jobId}: ${err.message}`);
|
||||
}
|
||||
}
|
||||
|
||||
s.update(jobs => jobs.map(j =>
|
||||
j.id === jobId
|
||||
? { ...j, status: 'cancelled', completedAt: new Date().toISOString(), pid: null }
|
||||
: j,
|
||||
));
|
||||
setTimeout(() => clearLiveOutput(jobId), 5000);
|
||||
return { ok: true };
|
||||
}
|
||||
|
||||
// Terminal statuses (review, done, failed, cancelled) — just remove from list
|
||||
if (['review', 'dead', 'cancelled'].includes(job.status)) {
|
||||
if (job.worktreePath) {
|
||||
try {
|
||||
const root = resolve(job.worktreePath, '..', '..');
|
||||
destroyWorktree(root, jobId);
|
||||
} catch (err) {
|
||||
console.error(` [Agent] Worktree cleanup failed for ${jobId}: ${err.message}`);
|
||||
}
|
||||
}
|
||||
s.update(jobs => jobs.filter(j => j.id !== jobId));
|
||||
return { ok: true };
|
||||
}
|
||||
|
||||
throw new Error(`Cannot cancel job "${jobId}" with status "${job.status}"`);
|
||||
}
|
||||
|
||||
export function getJobResult(cacheDir, jobId) {
|
||||
const resultFile = resolve(cacheDir, RESULTS_DIR, `${jobId}.md`);
|
||||
if (!existsSync(resultFile)) return { content: null };
|
||||
return { content: readFileSync(resultFile, 'utf8') };
|
||||
}
|
||||
|
||||
// ---------------------------------------------------------------------------
|
||||
// Public API — fleet queue processing
|
||||
// ---------------------------------------------------------------------------
|
||||
|
||||
/** Override CLI command for testing */
|
||||
let _spawnCommand = 'claude';
|
||||
export function setSpawnCommand(cmd) {
|
||||
if (process.env.NODE_ENV !== 'test') {
|
||||
throw new Error('setSpawnCommand is only available in test environments');
|
||||
}
|
||||
if (typeof cmd !== 'string' || cmd.length === 0 || cmd.includes('/') || cmd.includes('\\')) {
|
||||
throw new Error('setSpawnCommand: cmd must be a simple command name');
|
||||
}
|
||||
_spawnCommand = cmd;
|
||||
}
|
||||
|
||||
/** Check processing state (for diagnostics) */
|
||||
export function getIsProcessing() { return isProcessing; }
|
||||
|
||||
/**
|
||||
* Process the queue — spawn agents up to MAX_CONCURRENT.
|
||||
* Returns after spawning; agents run asynchronously.
|
||||
*
|
||||
* @param {string} root — project root
|
||||
* @param {string} cacheDir — cache directory
|
||||
* @param {function} [onOutput] — callback (jobId, chunk) for streaming
|
||||
* @param {function} [onWarning] — callback (jobId, message) for timeout warnings
|
||||
* @returns {Promise<{ launched: number, skipped: string[] }>}
|
||||
*/
|
||||
export async function processQueue(root, cacheDir, onOutput, onWarning) {
|
||||
if (isProcessing) return { launched: 0, skipped: ['locked'] };
|
||||
isProcessing = true;
|
||||
|
||||
try {
|
||||
ensureDirs(cacheDir);
|
||||
const s = ensureStore(cacheDir);
|
||||
const jobs = s.get();
|
||||
|
||||
// How many slots available?
|
||||
const slotsAvailable = MAX_CONCURRENT - activeAgents.size;
|
||||
if (slotsAvailable <= 0) {
|
||||
return { launched: 0, skipped: ['at_capacity'] };
|
||||
}
|
||||
|
||||
// Pick highest-priority queued jobs
|
||||
const queued = jobs
|
||||
.filter(j => j.status === 'queued')
|
||||
.sort((a, b) => {
|
||||
const priDiff = (b.priority ?? 1) - (a.priority ?? 1);
|
||||
if (priDiff !== 0) return priDiff;
|
||||
return new Date(a.createdAt).getTime() - new Date(b.createdAt).getTime();
|
||||
})
|
||||
.slice(0, slotsAvailable);
|
||||
|
||||
if (queued.length === 0) {
|
||||
return { launched: 0, skipped: [] };
|
||||
}
|
||||
|
||||
let launched = 0;
|
||||
const skipped = [];
|
||||
|
||||
for (const job of queued) {
|
||||
try {
|
||||
// Mark provisioning
|
||||
s.update(jobs => jobs.map(j =>
|
||||
j.id === job.id ? { ...j, status: 'provisioning' } : j,
|
||||
));
|
||||
|
||||
// Create worktree
|
||||
let worktreeInfo;
|
||||
try {
|
||||
worktreeInfo = createWorktree(root, job.id);
|
||||
} catch (wtErr) {
|
||||
console.error(` [Agent] Worktree creation failed for ${job.id}: ${wtErr.message}`);
|
||||
// Re-queue or mark dead
|
||||
const newRetry = (job.retryCount ?? 0) + 1;
|
||||
const nextStatus = newRetry < (job.maxRetries ?? 2) ? 'queued' : 'dead';
|
||||
s.update(jobs => jobs.map(j =>
|
||||
j.id === job.id
|
||||
? { ...j, status: nextStatus, error: `Worktree failed: ${wtErr.message}`, retryCount: newRetry, pid: null }
|
||||
: j,
|
||||
));
|
||||
skipped.push(job.id);
|
||||
continue;
|
||||
}
|
||||
|
||||
// Build prompt and spawn agent
|
||||
const prompt = buildPrompt(job, root);
|
||||
const timeout = TIMEOUTS[job.type] ?? TIMEOUTS.custom;
|
||||
const resultPath = resolve(cacheDir, RESULTS_DIR, `${job.id}.md`);
|
||||
|
||||
// Save prompt for debugging
|
||||
const promptFile = resolve(cacheDir, PROMPTS_DIR, `${job.id}.txt`);
|
||||
try { writeFileSync(promptFile, prompt, 'utf8'); } catch { /* non-critical */ }
|
||||
|
||||
// Spawn claude in the worktree
|
||||
const child = spawn(_spawnCommand, [
|
||||
'-p', prompt,
|
||||
'--dangerously-skip-permissions',
|
||||
'--output-format', 'text',
|
||||
], {
|
||||
cwd: worktreeInfo.worktreePath,
|
||||
shell: false,
|
||||
stdio: ['pipe', 'pipe', 'pipe'],
|
||||
});
|
||||
|
||||
const pid = child.pid ?? null;
|
||||
if (pid === null) {
|
||||
console.error(` [Agent] Failed to get PID for ${job.id}`);
|
||||
destroyWorktree(root, job.id);
|
||||
const newRetry = (job.retryCount ?? 0) + 1;
|
||||
const nextStatus = newRetry < (job.maxRetries ?? 2) ? 'queued' : 'dead';
|
||||
s.update(jobs => jobs.map(j =>
|
||||
j.id === job.id
|
||||
? { ...j, status: nextStatus, error: 'Failed to start process', retryCount: newRetry, pid: null, worktreePath: null }
|
||||
: j,
|
||||
));
|
||||
skipped.push(job.id);
|
||||
continue;
|
||||
}
|
||||
|
||||
// Capture baseline SHA for diff tracking
|
||||
let baselineSha = null;
|
||||
try {
|
||||
baselineSha = gitArgs(['rev-parse', 'HEAD'], worktreeInfo.worktreePath);
|
||||
} catch { /* non-critical */ }
|
||||
|
||||
// Mark running
|
||||
s.update(jobs => jobs.map(j =>
|
||||
j.id === job.id
|
||||
? {
|
||||
...j,
|
||||
status: 'running',
|
||||
startedAt: new Date().toISOString(),
|
||||
pid,
|
||||
worktreePath: worktreeInfo.worktreePath,
|
||||
branchName: worktreeInfo.branchName,
|
||||
configMethod: worktreeInfo.configMethod,
|
||||
baselineSha,
|
||||
preExistingDirtyFiles: [],
|
||||
}
|
||||
: j,
|
||||
));
|
||||
|
||||
// Initialize live output
|
||||
liveOutputBuffers.set(job.id, '');
|
||||
let stdout = '';
|
||||
|
||||
child.stdout.on('data', (chunk) => {
|
||||
const text = chunk.toString();
|
||||
stdout += text;
|
||||
appendToRingBuffer(job.id, text);
|
||||
if (typeof onOutput === 'function') {
|
||||
try { onOutput(job.id, text); } catch { /* non-critical */ }
|
||||
}
|
||||
});
|
||||
|
||||
child.stderr.on('data', (chunk) => {
|
||||
const text = chunk.toString();
|
||||
appendToRingBuffer(job.id, `[stderr] ${text}`);
|
||||
});
|
||||
|
||||
// Timeout warning at 80%
|
||||
const warningTimer = setTimeout(() => {
|
||||
if (typeof onWarning === 'function') {
|
||||
try { onWarning(job.id, `Agent approaching timeout (80% of ${timeout / 1000}s)`); } catch { /* */ }
|
||||
}
|
||||
}, timeout * 0.8);
|
||||
|
||||
// Hard timeout — SIGTERM then SIGKILL
|
||||
const timer = setTimeout(() => {
|
||||
killProcess(pid);
|
||||
}, timeout);
|
||||
|
||||
// Track active agent
|
||||
activeAgents.set(job.id, {
|
||||
pid,
|
||||
worktreePath: worktreeInfo.worktreePath,
|
||||
branchName: worktreeInfo.branchName,
|
||||
child,
|
||||
timer,
|
||||
warningTimer,
|
||||
});
|
||||
|
||||
// Handle completion
|
||||
child.on('close', (code) => {
|
||||
clearTimeout(timer);
|
||||
clearTimeout(warningTimer);
|
||||
activeAgents.delete(job.id);
|
||||
|
||||
const currentJob = ensureStore(cacheDir).getJob(job.id);
|
||||
if (!currentJob) return;
|
||||
|
||||
// If cancelled while running, don't overwrite
|
||||
if (currentJob.status === 'cancelled') {
|
||||
setTimeout(() => clearLiveOutput(job.id), 5000);
|
||||
return;
|
||||
}
|
||||
|
||||
const timedOut = !isProcessAlive(pid) && code !== 0;
|
||||
|
||||
if (code === 0) {
|
||||
// Success — save result, mark as review (worktree kept for merge)
|
||||
writeFileSync(resultPath, stdout, 'utf8');
|
||||
s.update(jobs => jobs.map(j =>
|
||||
j.id === job.id
|
||||
? { ...j, status: 'review', completedAt: new Date().toISOString(), resultPath, pid: null }
|
||||
: j,
|
||||
));
|
||||
} else {
|
||||
// Failure
|
||||
const newRetry = (currentJob.retryCount ?? 0) + 1;
|
||||
const maxRetries = currentJob.maxRetries ?? 2;
|
||||
const errorMsg = code === null
|
||||
? `Timed out after ${timeout / 1000}s`
|
||||
: `Exited with code ${code}`;
|
||||
const nextStatus = newRetry < maxRetries ? 'queued' : 'dead';
|
||||
|
||||
// Save partial output
|
||||
if (stdout.length > 0) {
|
||||
writeFileSync(resultPath, stdout, 'utf8');
|
||||
}
|
||||
|
||||
// Destroy worktree on failure
|
||||
try { destroyWorktree(root, job.id); } catch { /* best effort */ }
|
||||
|
||||
s.update(jobs => jobs.map(j =>
|
||||
j.id === job.id
|
||||
? {
|
||||
...j,
|
||||
status: nextStatus,
|
||||
completedAt: nextStatus === 'dead' ? new Date().toISOString() : null,
|
||||
startedAt: nextStatus === 'queued' ? null : currentJob.startedAt,
|
||||
error: errorMsg,
|
||||
retryCount: newRetry,
|
||||
pid: null,
|
||||
resultPath: stdout.length > 0 ? resultPath : null,
|
||||
worktreePath: null,
|
||||
branchName: nextStatus === 'queued' ? null : currentJob.branchName,
|
||||
}
|
||||
: j,
|
||||
));
|
||||
}
|
||||
|
||||
setTimeout(() => clearLiveOutput(job.id), 5000);
|
||||
});
|
||||
|
||||
child.on('error', (err) => {
|
||||
clearTimeout(timer);
|
||||
clearTimeout(warningTimer);
|
||||
activeAgents.delete(job.id);
|
||||
|
||||
try { destroyWorktree(root, job.id); } catch { /* best effort */ }
|
||||
|
||||
const newRetry = (job.retryCount ?? 0) + 1;
|
||||
const maxRetries = job.maxRetries ?? 2;
|
||||
const nextStatus = newRetry < maxRetries ? 'queued' : 'dead';
|
||||
|
||||
s.update(jobs => jobs.map(j =>
|
||||
j.id === job.id
|
||||
? {
|
||||
...j,
|
||||
status: nextStatus,
|
||||
completedAt: nextStatus === 'dead' ? new Date().toISOString() : null,
|
||||
error: err.message,
|
||||
retryCount: newRetry,
|
||||
pid: null,
|
||||
worktreePath: null,
|
||||
}
|
||||
: j,
|
||||
));
|
||||
|
||||
setTimeout(() => clearLiveOutput(job.id), 5000);
|
||||
});
|
||||
|
||||
launched += 1;
|
||||
} catch (err) {
|
||||
console.error(` [Agent] Unexpected error launching ${job.id}: ${err.message}`);
|
||||
skipped.push(job.id);
|
||||
}
|
||||
}
|
||||
|
||||
return { launched, skipped };
|
||||
} finally {
|
||||
isProcessing = false;
|
||||
}
|
||||
}
|
||||
|
||||
// ---------------------------------------------------------------------------
|
||||
// Public API — orphan recovery
|
||||
// ---------------------------------------------------------------------------
|
||||
|
||||
export function recoverOrphans(cacheDir, root) {
|
||||
const s = ensureStore(cacheDir);
|
||||
const jobs = s.get();
|
||||
let recovered = 0;
|
||||
|
||||
const updated = jobs.map((job) => {
|
||||
if (job.status !== 'running' && job.status !== 'provisioning') return job;
|
||||
|
||||
const pid = job.pid;
|
||||
const alive = pid && isProcessAlive(pid);
|
||||
const isClaude = alive && isClaudeProcess(pid);
|
||||
|
||||
if (alive && isClaude) return job;
|
||||
|
||||
// Orphan detected
|
||||
recovered += 1;
|
||||
|
||||
// Destroy worktree if it exists
|
||||
if (job.worktreePath && root) {
|
||||
try { destroyWorktree(root, job.id); } catch { /* best effort */ }
|
||||
}
|
||||
|
||||
const newRetry = (job.retryCount ?? 0) + 1;
|
||||
const maxRetries = job.maxRetries ?? 2;
|
||||
|
||||
if (newRetry < maxRetries) {
|
||||
return {
|
||||
...job,
|
||||
status: 'queued',
|
||||
startedAt: null,
|
||||
error: 'Orphaned process — re-queued',
|
||||
retryCount: newRetry,
|
||||
pid: null,
|
||||
worktreePath: null,
|
||||
branchName: null,
|
||||
};
|
||||
}
|
||||
|
||||
return {
|
||||
...job,
|
||||
status: 'dead',
|
||||
completedAt: new Date().toISOString(),
|
||||
error: 'Orphaned process — max retries exceeded',
|
||||
retryCount: newRetry,
|
||||
pid: null,
|
||||
worktreePath: null,
|
||||
branchName: null,
|
||||
};
|
||||
});
|
||||
|
||||
if (recovered > 0) {
|
||||
s.update(() => updated);
|
||||
}
|
||||
|
||||
// Also clean stale worktree directories
|
||||
if (root) {
|
||||
try {
|
||||
cleanupStaleWorktrees(root, (jobId) => {
|
||||
const job = jobs.find(j => j.id === jobId);
|
||||
return job?.status === 'running' && job?.pid && isProcessAlive(job.pid);
|
||||
});
|
||||
} catch { /* best effort */ }
|
||||
}
|
||||
|
||||
return { recovered };
|
||||
}
|
||||
|
||||
// ---------------------------------------------------------------------------
|
||||
// Public API — result pruning
|
||||
// ---------------------------------------------------------------------------
|
||||
|
||||
export function pruneResults(cacheDir) {
|
||||
const dir = resolve(cacheDir, RESULTS_DIR);
|
||||
if (!existsSync(dir)) return { pruned: 0 };
|
||||
|
||||
let entries;
|
||||
try {
|
||||
entries = readdirSync(dir)
|
||||
.map((name) => {
|
||||
const full = join(dir, name);
|
||||
try {
|
||||
const stat = statSync(full);
|
||||
return { name, path: full, mtime: stat.mtimeMs };
|
||||
} catch {
|
||||
return null;
|
||||
}
|
||||
})
|
||||
.filter(Boolean);
|
||||
} catch {
|
||||
return { pruned: 0 };
|
||||
}
|
||||
|
||||
const thirtyDaysMs = 30 * 24 * 60 * 60 * 1000;
|
||||
const cutoff = Date.now() - thirtyDaysMs;
|
||||
let pruned = 0;
|
||||
|
||||
const remaining = [];
|
||||
for (const entry of entries) {
|
||||
if (entry.mtime < cutoff) {
|
||||
try { unlinkSync(entry.path); pruned += 1; } catch { /* skip */ }
|
||||
} else {
|
||||
remaining.push(entry);
|
||||
}
|
||||
}
|
||||
|
||||
if (remaining.length > 50) {
|
||||
remaining.sort((a, b) => a.mtime - b.mtime);
|
||||
const excess = remaining.slice(0, remaining.length - 50);
|
||||
for (const entry of excess) {
|
||||
try { unlinkSync(entry.path); pruned += 1; } catch { /* skip */ }
|
||||
}
|
||||
}
|
||||
|
||||
return { pruned };
|
||||
}
|
||||
|
||||
// ---------------------------------------------------------------------------
|
||||
// Legacy exports for backward compatibility (used by existing tests)
|
||||
// ---------------------------------------------------------------------------
|
||||
|
||||
/** @deprecated Use getIsProcessing() instead */
|
||||
export function isQueueLocked() { return isProcessing; }
|
||||
|
||||
/** @deprecated Use internal reset instead */
|
||||
export function resetQueueLock() { isProcessing = false; }
|
||||
@@ -1,124 +0,0 @@
|
||||
/**
|
||||
* Backlog parser — reads Backlog.md and extracts open tasks,
|
||||
* mapping them to project modules by keyword matching.
|
||||
*/
|
||||
import { readFileSync, existsSync } from 'node:fs';
|
||||
import { resolve } from 'node:path';
|
||||
|
||||
// Keywords that map tasks to modules
|
||||
const MODULE_KEYWORDS = {
|
||||
// Server Go packages
|
||||
'admin': ['admin', 'admin panel', 'admin api'],
|
||||
'api': ['api', 'REST', 'endpoint', 'handler', 'middleware'],
|
||||
'auth': ['auth', '2FA', 'TOTP', 'login', 'register', 'password', 'session', 'token'],
|
||||
'db': ['database', 'SQLite', 'migration', 'schema', 'query', 'db'],
|
||||
'ws': ['websocket', 'WS', 'hub', 'voice', 'broadcast', 'ringbuffer', 'reconnect'],
|
||||
'permissions': ['permission', 'role', 'RBAC'],
|
||||
'storage': ['upload', 'file storage', 'attachment'],
|
||||
'config': ['config', 'settings'],
|
||||
// Client areas
|
||||
'lib': ['livekitSession', 'audioPipeline', 'dispatcher', 'tenor', 'ptt', 'notification', 'theme'],
|
||||
'stores': ['store', 'state management'],
|
||||
'components': ['component', 'UI', 'sidebar', 'overlay', 'widget', 'picker', 'modal'],
|
||||
'pages': ['page', 'ConnectPage', 'MainPage', 'ChatArea', 'SidebarArea'],
|
||||
// Rust
|
||||
'tauri-rust': ['Rust', 'Tauri', 'tray', 'hotkey', 'credential', 'proxy', 'updater', 'ptt.rs'],
|
||||
// Cross-cutting
|
||||
'protocol': ['protocol', 'message type', 'payload'],
|
||||
'e2e': ['E2E', 'Playwright', 'end-to-end'],
|
||||
'livekit': ['LiveKit', 'voice', 'video', 'spatial audio', 'whisper', 'screen sharing', 'streaming'],
|
||||
// Feature areas
|
||||
'gaming': ['game detection', 'game time', 'LAN', 'tournament', 'leaderboard', 'seat map', 'Xfire'],
|
||||
'community': ['poll', 'gallery', 'scheduler', 'activity feed', 'pinned notes'],
|
||||
'platform': ['theme engine', 'webhook', 'bot', 'plugin', 'backup', 'monitoring'],
|
||||
'ai': ['AI', 'noise cancellation', 'translation', 'summarization', 'overlay'],
|
||||
};
|
||||
|
||||
function matchModule(description) {
|
||||
const lower = description.toLowerCase();
|
||||
const matches = [];
|
||||
|
||||
for (const [mod, keywords] of Object.entries(MODULE_KEYWORDS)) {
|
||||
for (const kw of keywords) {
|
||||
const kwLower = kw.toLowerCase();
|
||||
const re = new RegExp(`\\b${kwLower}\\b`);
|
||||
if (re.test(lower)) {
|
||||
matches.push(mod);
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
return matches.length > 0 ? matches : ['unclassified'];
|
||||
}
|
||||
|
||||
function extractPhase(sectionHeader) {
|
||||
if (sectionHeader.includes('Bug')) return 'bug';
|
||||
if (sectionHeader.includes('Code Review')) return 'code-review';
|
||||
if (sectionHeader.includes('Medium Priority') || sectionHeader.includes('P2')) return 'medium';
|
||||
if (sectionHeader.includes('High Priority') || sectionHeader.includes('P0') || sectionHeader.includes('P1')) return 'high';
|
||||
if (sectionHeader.includes('Deferred')) return 'deferred';
|
||||
if (/\bR1\b/.test(sectionHeader)) return 'roadmap-r1';
|
||||
if (/\bR2\b/.test(sectionHeader)) return 'roadmap-r2';
|
||||
if (/\bR3\b/.test(sectionHeader)) return 'roadmap-r3';
|
||||
if (/\bR4\b/.test(sectionHeader)) return 'roadmap-r4';
|
||||
if (/\bR5\b/.test(sectionHeader)) return 'roadmap-r5';
|
||||
if (/\bR6\b/.test(sectionHeader)) return 'roadmap-r6';
|
||||
return 'other';
|
||||
}
|
||||
|
||||
export async function parseBacklog(root) {
|
||||
const backlogPath = resolve(root, 'docs/brain/02-Tasks/Backlog.md');
|
||||
if (!existsSync(backlogPath)) {
|
||||
console.log(' [Backlog] File not found');
|
||||
return { tasks: [], openCount: 0, doneCount: 0, byModule: {}, byPhase: {} };
|
||||
}
|
||||
|
||||
const content = readFileSync(backlogPath, 'utf8');
|
||||
const lines = content.split('\n');
|
||||
|
||||
const tasks = [];
|
||||
let currentSection = '';
|
||||
|
||||
for (const line of lines) {
|
||||
// Track section headers
|
||||
if (line.startsWith('## ') || line.startsWith('### ')) {
|
||||
currentSection = line.replace(/^#+\s*/, '');
|
||||
}
|
||||
|
||||
// Match task lines in two formats:
|
||||
// - [ ] **T-XXX:** description (colon inside bold)
|
||||
// - [ ] **T-XXX**: description (colon after bold)
|
||||
const taskMatch = line.match(/^- \[([ x])\] \*\*T-(\d+)(?::\*\*|\*\*:)\s*(.+)/);
|
||||
if (taskMatch) {
|
||||
const done = taskMatch[1] === 'x';
|
||||
const id = `T-${taskMatch[2]}`;
|
||||
const description = taskMatch[3].replace(/\s*—\s*\d{4}-\d{2}-\d{2}$/, '').trim();
|
||||
const modules = matchModule(description);
|
||||
const phase = extractPhase(currentSection);
|
||||
|
||||
tasks.push({ id, description, done, modules, phase, section: currentSection });
|
||||
}
|
||||
}
|
||||
|
||||
// Aggregate
|
||||
const openTasks = tasks.filter(t => !t.done);
|
||||
const doneTasks = tasks.filter(t => t.done);
|
||||
|
||||
const byModule = {};
|
||||
for (const task of openTasks) {
|
||||
for (const mod of task.modules) {
|
||||
if (!byModule[mod]) byModule[mod] = [];
|
||||
byModule[mod].push(task);
|
||||
}
|
||||
}
|
||||
|
||||
const byPhase = {};
|
||||
for (const task of openTasks) {
|
||||
if (!byPhase[task.phase]) byPhase[task.phase] = [];
|
||||
byPhase[task.phase].push(task);
|
||||
}
|
||||
|
||||
console.log(` [Backlog] ${openTasks.length} open tasks, ${doneTasks.length} done`);
|
||||
return { tasks, openCount: openTasks.length, doneCount: doneTasks.length, byModule, byPhase };
|
||||
}
|
||||
@@ -1,311 +0,0 @@
|
||||
import { readdir, readFile, stat, mkdir, writeFile } from 'node:fs/promises';
|
||||
import { join, relative, sep, posix } from 'node:path';
|
||||
|
||||
const MARKER_RE = /\b(TODO|FIXME|HACK|XXX)\b[:\s]*(.*)/i;
|
||||
|
||||
const SCAN_DIRS = [
|
||||
{ dir: 'Server', ext: '.go', skipFile: '_test.go', skipDirs: ['vendor'] },
|
||||
{ dir: 'Client/tauri-client/src', ext: '.ts', skipFile: null, skipDirs: ['node_modules', 'dist'] },
|
||||
{ dir: 'Client/tauri-client/src-tauri/src', ext: '.rs', skipFile: null, skipDirs: ['target'] },
|
||||
];
|
||||
|
||||
const LARGE_FILE_WARNING = 400;
|
||||
const LARGE_FILE_CRITICAL = 800;
|
||||
const LONG_FUNCTION_LINES = 50;
|
||||
const DEEP_NESTING_THRESHOLD = 4;
|
||||
|
||||
/**
|
||||
* Recursively collect files matching an extension, skipping specified directories.
|
||||
*/
|
||||
async function collectFiles(base, ext, skipFile, skipDirs) {
|
||||
const results = [];
|
||||
|
||||
async function walk(dir) {
|
||||
let entries;
|
||||
try {
|
||||
entries = await readdir(dir, { withFileTypes: true });
|
||||
} catch {
|
||||
return;
|
||||
}
|
||||
for (const entry of entries) {
|
||||
if (entry.isDirectory()) {
|
||||
if (skipDirs.includes(entry.name)) continue;
|
||||
await walk(join(dir, entry.name));
|
||||
} else if (entry.isFile() && entry.name.endsWith(ext)) {
|
||||
if (skipFile && entry.name.endsWith(skipFile)) continue;
|
||||
results.push(join(dir, entry.name));
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
await walk(base);
|
||||
return results;
|
||||
}
|
||||
|
||||
/**
|
||||
* Derive the module name from a file path relative to root.
|
||||
*/
|
||||
function getModule(relPath) {
|
||||
const parts = relPath.split(/[/\\]/);
|
||||
|
||||
// Server/{package}/file.go -> package name
|
||||
if (parts[0] === 'Server' && parts.length >= 2) {
|
||||
return parts.length >= 3 ? parts[1] : 'server-root';
|
||||
}
|
||||
|
||||
// Client/tauri-client/src-tauri/src/file.rs -> "tauri-rust"
|
||||
if (
|
||||
parts[0] === 'Client' &&
|
||||
parts[1] === 'tauri-client' &&
|
||||
parts[2] === 'src-tauri'
|
||||
) {
|
||||
return 'tauri-rust';
|
||||
}
|
||||
|
||||
// Client/tauri-client/src/{area}/file.ts -> area name
|
||||
if (
|
||||
parts[0] === 'Client' &&
|
||||
parts[1] === 'tauri-client' &&
|
||||
parts[2] === 'src'
|
||||
) {
|
||||
return parts.length >= 5 ? parts[3] : 'client-root';
|
||||
}
|
||||
|
||||
return 'unknown';
|
||||
}
|
||||
|
||||
/**
|
||||
* Normalize path to forward slashes for consistent output.
|
||||
*/
|
||||
function normalizePath(p) {
|
||||
return p.split(sep).join(posix.sep);
|
||||
}
|
||||
|
||||
/**
|
||||
* Detect long functions via brace-depth tracking.
|
||||
* Returns array of { line, name, lines }.
|
||||
*/
|
||||
function detectLongFunctions(content, ext) {
|
||||
const lines = content.split('\n');
|
||||
const functions = [];
|
||||
|
||||
// Stack: { name, startLine, depth }
|
||||
let current = null;
|
||||
let braceDepth = 0;
|
||||
|
||||
for (let i = 0; i < lines.length; i++) {
|
||||
const line = lines[i];
|
||||
const trimmed = line.trimStart();
|
||||
|
||||
// Detect function start
|
||||
let funcName = null;
|
||||
|
||||
if (ext === '.go') {
|
||||
const match = trimmed.match(/^func\s+(?:\([^)]*\)\s*)?(\w+)/);
|
||||
if (match) funcName = match[1];
|
||||
} else if (ext === '.ts') {
|
||||
// Named function declaration
|
||||
const fnMatch = trimmed.match(/^(?:export\s+)?(?:async\s+)?function\s+(\w+)/);
|
||||
if (fnMatch) {
|
||||
funcName = fnMatch[1];
|
||||
} else {
|
||||
// Arrow function: const name = (...) => {
|
||||
const arrowMatch = trimmed.match(/^(?:export\s+)?(?:const|let|var)\s+(\w+)\s*=\s*(?:async\s+)?(?:\([^)]*\)|[^=])*=>\s*\{/);
|
||||
if (arrowMatch) {
|
||||
funcName = arrowMatch[1];
|
||||
}
|
||||
}
|
||||
} else if (ext === '.rs') {
|
||||
const match = trimmed.match(/^(?:pub\s+)?(?:async\s+)?fn\s+(\w+)/);
|
||||
if (match) funcName = match[1];
|
||||
}
|
||||
|
||||
if (funcName && current === null) {
|
||||
current = { name: funcName, startLine: i + 1, depth: braceDepth };
|
||||
}
|
||||
|
||||
// Track braces
|
||||
for (const ch of line) {
|
||||
if (ch === '{') braceDepth++;
|
||||
if (ch === '}') braceDepth--;
|
||||
}
|
||||
if (braceDepth < 0) braceDepth = 0;
|
||||
|
||||
// Check if current function has ended
|
||||
if (current !== null && braceDepth <= current.depth) {
|
||||
const funcLines = (i + 1) - current.startLine + 1;
|
||||
if (funcLines > LONG_FUNCTION_LINES) {
|
||||
functions.push({
|
||||
line: current.startLine,
|
||||
name: current.name,
|
||||
lines: funcLines,
|
||||
});
|
||||
}
|
||||
current = null;
|
||||
}
|
||||
}
|
||||
|
||||
return functions;
|
||||
}
|
||||
|
||||
/**
|
||||
* Scan a single file for all debt indicators.
|
||||
*/
|
||||
function scanFile(content, relPath, ext) {
|
||||
const lines = content.split('\n');
|
||||
const mod = getModule(relPath);
|
||||
const file = normalizePath(relPath);
|
||||
|
||||
const markers = [];
|
||||
const deepNesting = [];
|
||||
|
||||
for (let i = 0; i < lines.length; i++) {
|
||||
const line = lines[i];
|
||||
|
||||
// Marker detection
|
||||
const markerMatch = line.match(MARKER_RE);
|
||||
if (markerMatch) {
|
||||
markers.push({
|
||||
type: markerMatch[1].toUpperCase(),
|
||||
file,
|
||||
line: i + 1,
|
||||
text: markerMatch[2].trim(),
|
||||
module: mod,
|
||||
});
|
||||
}
|
||||
|
||||
// Deep nesting detection
|
||||
const leadingSpaces = line.match(/^(\s*)/)[1];
|
||||
const tabCount = (leadingSpaces.match(/\t/g) || []).length;
|
||||
const spaceCount = leadingSpaces.replace(/\t/g, '').length;
|
||||
const depth = tabCount + Math.floor(spaceCount / 4);
|
||||
|
||||
if (depth >= DEEP_NESTING_THRESHOLD && line.trim().length > 0) {
|
||||
deepNesting.push({
|
||||
file,
|
||||
line: i + 1,
|
||||
depth,
|
||||
module: mod,
|
||||
});
|
||||
}
|
||||
}
|
||||
|
||||
// Large file detection
|
||||
let largeFile = null;
|
||||
if (lines.length > LARGE_FILE_WARNING) {
|
||||
largeFile = {
|
||||
file,
|
||||
lines: lines.length,
|
||||
module: mod,
|
||||
severity: lines.length > LARGE_FILE_CRITICAL ? 'critical' : 'warning',
|
||||
};
|
||||
}
|
||||
|
||||
// Long function detection
|
||||
const longFunctions = detectLongFunctions(content, ext).map((f) => ({
|
||||
file,
|
||||
line: f.line,
|
||||
name: f.name,
|
||||
lines: f.lines,
|
||||
module: mod,
|
||||
}));
|
||||
|
||||
return { markers, largeFile, longFunctions, deepNesting };
|
||||
}
|
||||
|
||||
/**
|
||||
* Scan the codebase for technical debt indicators.
|
||||
*
|
||||
* @param {string} root - Absolute path to the repository root
|
||||
* @param {string} cacheDir - Directory to store cached results
|
||||
* @param {boolean} quick - If true and cache exists, return cached data
|
||||
* @returns {Promise<object>} Technical debt report
|
||||
*/
|
||||
export async function scanTechnicalDebt(root, cacheDir, quick) {
|
||||
const cachePath = join(cacheDir, 'debt-data.json');
|
||||
|
||||
if (quick) {
|
||||
try {
|
||||
const cached = await readFile(cachePath, 'utf-8');
|
||||
return JSON.parse(cached);
|
||||
} catch {
|
||||
// Cache miss, proceed with full scan
|
||||
}
|
||||
}
|
||||
|
||||
const allMarkers = [];
|
||||
const allLargeFiles = [];
|
||||
const allLongFunctions = [];
|
||||
let allDeepNesting = [];
|
||||
|
||||
for (const { dir, ext, skipFile, skipDirs } of SCAN_DIRS) {
|
||||
const baseDir = join(root, ...dir.split('/'));
|
||||
const files = await collectFiles(baseDir, ext, skipFile, skipDirs);
|
||||
|
||||
for (const filePath of files) {
|
||||
let content;
|
||||
try {
|
||||
content = await readFile(filePath, 'utf-8');
|
||||
} catch {
|
||||
continue;
|
||||
}
|
||||
|
||||
const relPath = relative(root, filePath);
|
||||
const result = scanFile(content, relPath, ext);
|
||||
|
||||
allMarkers.push(...result.markers);
|
||||
if (result.largeFile) allLargeFiles.push(result.largeFile);
|
||||
allLongFunctions.push(...result.longFunctions);
|
||||
allDeepNesting.push(...result.deepNesting);
|
||||
}
|
||||
}
|
||||
|
||||
// Keep only top 20 deepest nesting instances
|
||||
allDeepNesting.sort((a, b) => b.depth - a.depth);
|
||||
allDeepNesting = allDeepNesting.slice(0, 20);
|
||||
|
||||
// Build per-module summary
|
||||
const byModule = {};
|
||||
const ensureModule = (mod) => {
|
||||
if (!byModule[mod]) {
|
||||
byModule[mod] = { markers: 0, largeFiles: 0, longFunctions: 0 };
|
||||
}
|
||||
};
|
||||
|
||||
for (const m of allMarkers) {
|
||||
ensureModule(m.module);
|
||||
byModule[m.module].markers++;
|
||||
}
|
||||
for (const f of allLargeFiles) {
|
||||
ensureModule(f.module);
|
||||
byModule[f.module].largeFiles++;
|
||||
}
|
||||
for (const f of allLongFunctions) {
|
||||
ensureModule(f.module);
|
||||
byModule[f.module].longFunctions++;
|
||||
}
|
||||
|
||||
const report = {
|
||||
timestamp: new Date().toISOString(),
|
||||
markers: allMarkers,
|
||||
largeFiles: allLargeFiles,
|
||||
longFunctions: allLongFunctions,
|
||||
deepNesting: allDeepNesting,
|
||||
summary: {
|
||||
totalMarkers: allMarkers.length,
|
||||
totalLargeFiles: allLargeFiles.length,
|
||||
totalLongFunctions: allLongFunctions.length,
|
||||
byModule,
|
||||
},
|
||||
};
|
||||
|
||||
// Write cache
|
||||
try {
|
||||
await mkdir(cacheDir, { recursive: true });
|
||||
await writeFile(cachePath, JSON.stringify(report, null, 2), 'utf-8');
|
||||
} catch {
|
||||
// Non-fatal: cache write failure is acceptable
|
||||
}
|
||||
|
||||
return report;
|
||||
}
|
||||
@@ -1,115 +0,0 @@
|
||||
/**
|
||||
* File watcher + SSE auto-refresh.
|
||||
* Watches key directories and notifies connected SSE clients on changes.
|
||||
*/
|
||||
import { watch } from 'node:fs';
|
||||
import { resolve } from 'node:path';
|
||||
|
||||
export function createFileWatcher(root, onChangeCallback) {
|
||||
const watchDirs = [
|
||||
resolve(root, 'Server'),
|
||||
resolve(root, 'Client/tauri-client/src'),
|
||||
resolve(root, 'Client/tauri-client/src-tauri/src'),
|
||||
resolve(root, 'docs/brain'),
|
||||
];
|
||||
|
||||
// Debounce: only fire callback once per 2 seconds
|
||||
let debounceTimer = null;
|
||||
let destroyed = false;
|
||||
const debounceMs = 2000;
|
||||
|
||||
function handleChange(eventType, filename) {
|
||||
if (destroyed) return;
|
||||
|
||||
// Ignore non-source files
|
||||
if (filename && (
|
||||
filename.includes('node_modules') ||
|
||||
filename.includes('.git') ||
|
||||
filename.includes('dist') ||
|
||||
filename.includes('target') ||
|
||||
filename.endsWith('.swp') ||
|
||||
filename.endsWith('~')
|
||||
)) return;
|
||||
|
||||
if (debounceTimer) clearTimeout(debounceTimer);
|
||||
debounceTimer = setTimeout(() => {
|
||||
if (destroyed) return;
|
||||
try {
|
||||
onChangeCallback({ eventType, filename, timestamp: new Date().toISOString() });
|
||||
} catch (err) {
|
||||
console.error('[Watch] callback error:', err.message);
|
||||
}
|
||||
}, debounceMs);
|
||||
}
|
||||
|
||||
const watchers = [];
|
||||
for (const dir of watchDirs) {
|
||||
try {
|
||||
const w = watch(dir, { recursive: true }, handleChange);
|
||||
watchers.push(w);
|
||||
} catch {
|
||||
// Directory might not exist — skip silently
|
||||
}
|
||||
}
|
||||
|
||||
return {
|
||||
close() {
|
||||
destroyed = true;
|
||||
if (debounceTimer) { clearTimeout(debounceTimer); debounceTimer = null; }
|
||||
for (const w of watchers) {
|
||||
try { w.close(); } catch { /* ignore */ }
|
||||
}
|
||||
},
|
||||
};
|
||||
}
|
||||
|
||||
/**
|
||||
* SSE (Server-Sent Events) manager.
|
||||
* Maintains a list of connected clients and broadcasts events to all.
|
||||
*/
|
||||
export function createSSEManager() {
|
||||
const clients = new Set();
|
||||
|
||||
const heartbeatInterval = setInterval(() => {
|
||||
for (const client of clients) {
|
||||
try { client.write(': ping\n\n'); } catch { clients.delete(client); }
|
||||
}
|
||||
}, 30000);
|
||||
|
||||
function handleConnection(req, res) {
|
||||
res.writeHead(200, {
|
||||
'Content-Type': 'text/event-stream',
|
||||
'Cache-Control': 'no-cache',
|
||||
'Connection': 'keep-alive',
|
||||
});
|
||||
|
||||
// Send initial connected event
|
||||
res.write(`data: ${JSON.stringify({ type: 'connected', timestamp: new Date().toISOString() })}\n\n`);
|
||||
|
||||
clients.add(res);
|
||||
|
||||
req.on('close', () => {
|
||||
clients.delete(res);
|
||||
});
|
||||
}
|
||||
|
||||
function broadcast(event) {
|
||||
const data = `data: ${JSON.stringify(event)}\n\n`;
|
||||
for (const client of clients) {
|
||||
try { client.write(data); } catch { clients.delete(client); }
|
||||
}
|
||||
}
|
||||
|
||||
function close() {
|
||||
clearInterval(heartbeatInterval);
|
||||
for (const client of clients) {
|
||||
try { client.end(); } catch { /* ignore */ }
|
||||
}
|
||||
clients.clear();
|
||||
}
|
||||
|
||||
// Safety net: clean up on process exit to prevent leaked intervals
|
||||
process.on('exit', () => { clearInterval(heartbeatInterval); });
|
||||
|
||||
return { handleConnection, broadcast, close, get clientCount() { return clients.size; } };
|
||||
}
|
||||
@@ -1,341 +0,0 @@
|
||||
/**
|
||||
* Git history scanner — analyzes recent commits to provide per-module
|
||||
* activity, file churn, staleness, velocity, and commit-type breakdown.
|
||||
*
|
||||
* Zero external dependencies — Node built-ins only.
|
||||
*/
|
||||
import { execFileSync } from 'node:child_process';
|
||||
import { readFileSync, writeFileSync, mkdirSync, existsSync } from 'node:fs';
|
||||
import { join } from 'node:path';
|
||||
|
||||
const WINDOW_DAYS = 30;
|
||||
const TOP_CHURN = 20;
|
||||
const RECENT_LIMIT = 15;
|
||||
|
||||
const COMMIT_TYPES = ['feat', 'fix', 'test', 'refactor', 'docs', 'chore', 'perf'];
|
||||
|
||||
/**
|
||||
* Map a file path to its logical module name.
|
||||
* Server/{package}/ → package name (e.g. "ws", "db", "auth")
|
||||
* Client/tauri-client/src/{area}/ → area name (e.g. "components", "lib")
|
||||
* Client/tauri-client/src-tauri/src/ → "tauri-rust"
|
||||
*
|
||||
* NOTE: names are unprefixed to match scanner.mjs, backlog-parser.mjs,
|
||||
* debt-scanner.mjs, and suggestion-engine.mjs canonical keys.
|
||||
*/
|
||||
function resolveModule(filePath) {
|
||||
const normalized = filePath.replace(/\\/g, '/');
|
||||
|
||||
if (normalized.startsWith('Server/')) {
|
||||
const parts = normalized.split('/');
|
||||
// parts[1] is a subdirectory only when there are 3+ segments
|
||||
// e.g. Server/ws/handler.go → 'ws', Server/main.go → 'server-root'
|
||||
return parts.length >= 3 ? parts[1] : 'server-root';
|
||||
}
|
||||
|
||||
if (normalized.startsWith('Client/tauri-client/src-tauri/src/')) {
|
||||
return 'tauri-rust';
|
||||
}
|
||||
|
||||
if (normalized.startsWith('Client/tauri-client/src/')) {
|
||||
const parts = normalized.replace('Client/tauri-client/src/', '').split('/');
|
||||
return parts.length >= 1 && parts[0] !== '' ? parts[0] : 'client-root';
|
||||
}
|
||||
|
||||
if (normalized.startsWith('Client/tauri-client/')) {
|
||||
return 'client-config';
|
||||
}
|
||||
|
||||
if (normalized.startsWith('Client/')) {
|
||||
return 'client-other';
|
||||
}
|
||||
|
||||
// Root-level files (README, .gitignore, etc.)
|
||||
return 'root';
|
||||
}
|
||||
|
||||
/**
|
||||
* Parse a conventional-commit prefix from a message.
|
||||
* Returns one of the known types or "other".
|
||||
*/
|
||||
function parseCommitType(message) {
|
||||
const match = message.match(/^(\w+)(?:\(.+?\))?[!]?:/);
|
||||
if (!match) return 'other';
|
||||
const prefix = match[1].toLowerCase();
|
||||
return COMMIT_TYPES.includes(prefix) ? prefix : 'other';
|
||||
}
|
||||
|
||||
/**
|
||||
* Run a git command and return stdout as a string.
|
||||
* Uses execFileSync with argument arrays to avoid shell injection.
|
||||
*/
|
||||
function git(args, root) {
|
||||
return execFileSync('git', args, {
|
||||
cwd: root,
|
||||
encoding: 'utf8',
|
||||
maxBuffer: 10 * 1024 * 1024,
|
||||
stdio: ['pipe', 'pipe', 'pipe'],
|
||||
});
|
||||
}
|
||||
|
||||
/**
|
||||
* Parse the raw git log output into structured commit objects.
|
||||
*
|
||||
* git log --format="%H|%ai|%s" --name-only produces:
|
||||
* HASH|DATE|SUBJECT
|
||||
* (blank line)
|
||||
* file1
|
||||
* file2
|
||||
* HASH|DATE|SUBJECT
|
||||
* (blank line)
|
||||
* file1
|
||||
* ...
|
||||
*
|
||||
* We detect header lines by the HASH|DATE|SUBJECT pattern and
|
||||
* accumulate file lines until the next header.
|
||||
*/
|
||||
function parseGitLog(raw) {
|
||||
const commits = [];
|
||||
const lines = raw.trim().split('\n');
|
||||
|
||||
let current = null;
|
||||
|
||||
for (const line of lines) {
|
||||
const trimmed = line.trim();
|
||||
if (trimmed === '') continue;
|
||||
|
||||
// Detect header: 40-char hex hash, then pipe, then date, then pipe, then subject
|
||||
const pipeIdx1 = trimmed.indexOf('|');
|
||||
const pipeIdx2 = pipeIdx1 !== -1 ? trimmed.indexOf('|', pipeIdx1 + 1) : -1;
|
||||
const isHeader = pipeIdx1 === 40 && pipeIdx2 !== -1;
|
||||
|
||||
if (isHeader) {
|
||||
// Finalize previous commit
|
||||
if (current) {
|
||||
current.modules = [...new Set(current.files.map(resolveModule))];
|
||||
commits.push(current);
|
||||
}
|
||||
|
||||
const hash = trimmed.slice(0, pipeIdx1);
|
||||
const date = trimmed.slice(pipeIdx1 + 1, pipeIdx2);
|
||||
const message = trimmed.slice(pipeIdx2 + 1);
|
||||
const type = parseCommitType(message);
|
||||
|
||||
current = { hash, date, message, type, files: [], modules: [] };
|
||||
} else if (current) {
|
||||
current.files.push(trimmed);
|
||||
}
|
||||
}
|
||||
|
||||
// Finalize last commit
|
||||
if (current) {
|
||||
current.modules = [...new Set(current.files.map(resolveModule))];
|
||||
commits.push(current);
|
||||
}
|
||||
|
||||
return commits;
|
||||
}
|
||||
|
||||
/**
|
||||
* Build per-module commit data from the parsed commits.
|
||||
*/
|
||||
function buildCommitsByModule(commits) {
|
||||
const byModule = {};
|
||||
|
||||
for (const commit of commits) {
|
||||
for (const mod of commit.modules) {
|
||||
if (!byModule[mod]) {
|
||||
byModule[mod] = { count: 0, lastCommit: commit.date, commits: [] };
|
||||
}
|
||||
byModule[mod].count += 1;
|
||||
byModule[mod].commits.push({
|
||||
hash: commit.hash,
|
||||
date: commit.date,
|
||||
message: commit.message,
|
||||
type: commit.type,
|
||||
});
|
||||
// Keep the most recent date
|
||||
if (commit.date > byModule[mod].lastCommit) {
|
||||
byModule[mod].lastCommit = commit.date;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
return byModule;
|
||||
}
|
||||
|
||||
/**
|
||||
* Compute file churn — number of commits touching each file.
|
||||
* Returns top N most churned files.
|
||||
*/
|
||||
function buildFileChurn(commits) {
|
||||
const churnMap = {};
|
||||
|
||||
for (const commit of commits) {
|
||||
for (const file of commit.files) {
|
||||
if (!churnMap[file]) {
|
||||
churnMap[file] = { file, commits: 0, module: resolveModule(file) };
|
||||
}
|
||||
churnMap[file].commits += 1;
|
||||
}
|
||||
}
|
||||
|
||||
return Object.values(churnMap)
|
||||
.sort((a, b) => b.commits - a.commits)
|
||||
.slice(0, TOP_CHURN);
|
||||
}
|
||||
|
||||
/**
|
||||
* Calculate staleness — days since last commit per module.
|
||||
*/
|
||||
function buildStaleness(commitsByModule) {
|
||||
const now = Date.now();
|
||||
const staleness = {};
|
||||
|
||||
for (const [mod, data] of Object.entries(commitsByModule)) {
|
||||
const lastDate = new Date(data.lastCommit);
|
||||
const daysSince = Math.floor((now - lastDate.getTime()) / (1000 * 60 * 60 * 24));
|
||||
staleness[mod] = {
|
||||
daysSinceLastCommit: daysSince,
|
||||
lastCommitDate: data.lastCommit,
|
||||
};
|
||||
}
|
||||
|
||||
return staleness;
|
||||
}
|
||||
|
||||
/**
|
||||
* Build daily velocity and rolling 7-day average.
|
||||
*/
|
||||
function buildVelocity(commits) {
|
||||
// Build a map of date → commit count
|
||||
const dailyMap = {};
|
||||
const now = new Date();
|
||||
|
||||
for (let i = 0; i < WINDOW_DAYS; i++) {
|
||||
const d = new Date(now);
|
||||
d.setDate(d.getDate() - i);
|
||||
const key = d.toISOString().slice(0, 10);
|
||||
dailyMap[key] = 0;
|
||||
}
|
||||
|
||||
for (const commit of commits) {
|
||||
const key = commit.date.slice(0, 10);
|
||||
if (key in dailyMap) {
|
||||
dailyMap[key] += 1;
|
||||
}
|
||||
}
|
||||
|
||||
const daily = Object.entries(dailyMap)
|
||||
.sort(([a], [b]) => a.localeCompare(b))
|
||||
.map(([date, count]) => ({ date, count }));
|
||||
|
||||
// Rolling 7-day average (use last 7 days)
|
||||
const last7 = daily.slice(-7);
|
||||
const weeklyAvg = last7.length > 0
|
||||
? Math.round((last7.reduce((s, d) => s + d.count, 0) / last7.length) * 100) / 100
|
||||
: 0;
|
||||
|
||||
// Trend: compare first half vs second half of the window
|
||||
const mid = Math.floor(daily.length / 2);
|
||||
const firstHalf = daily.slice(0, mid);
|
||||
const secondHalf = daily.slice(mid);
|
||||
|
||||
const avgFirst = firstHalf.length > 0
|
||||
? firstHalf.reduce((s, d) => s + d.count, 0) / firstHalf.length
|
||||
: 0;
|
||||
const avgSecond = secondHalf.length > 0
|
||||
? secondHalf.reduce((s, d) => s + d.count, 0) / secondHalf.length
|
||||
: 0;
|
||||
|
||||
let trend = 'stable';
|
||||
const delta = avgSecond - avgFirst;
|
||||
if (delta > 0.3) trend = 'accelerating';
|
||||
else if (delta < -0.3) trend = 'decelerating';
|
||||
|
||||
return { daily, weeklyAvg, trend };
|
||||
}
|
||||
|
||||
/**
|
||||
* Build commit type breakdown.
|
||||
*/
|
||||
function buildCommitTypes(commits) {
|
||||
const types = { feat: 0, fix: 0, test: 0, refactor: 0, docs: 0, chore: 0, other: 0 };
|
||||
|
||||
for (const commit of commits) {
|
||||
const bucket = commit.type in types ? commit.type : 'other';
|
||||
types[bucket] += 1;
|
||||
}
|
||||
|
||||
return types;
|
||||
}
|
||||
|
||||
/**
|
||||
* Main entry point. Scans git history for the last 30 days and returns
|
||||
* structured data about module activity, churn, staleness, and velocity.
|
||||
*
|
||||
* @param {string} root - Repository root directory
|
||||
* @param {string} cacheDir - Directory to store cached results
|
||||
* @param {boolean} quick - If true and cache exists, return cached data
|
||||
* @returns {Promise<object>} Structured git history data
|
||||
*/
|
||||
// Exported for testing
|
||||
export { resolveModule };
|
||||
|
||||
export async function scanGitHistory(root, cacheDir, quick = false) {
|
||||
const cacheFile = join(cacheDir, 'git-data.json');
|
||||
|
||||
// Quick mode: return cache if available
|
||||
if (quick && existsSync(cacheFile)) {
|
||||
try {
|
||||
const cached = JSON.parse(readFileSync(cacheFile, 'utf8'));
|
||||
return cached;
|
||||
} catch {
|
||||
// Cache corrupt — fall through to fresh scan
|
||||
}
|
||||
}
|
||||
|
||||
// Fetch git log with file names
|
||||
const raw = git(
|
||||
['log', `--since=${WINDOW_DAYS} days ago`, '--format=%H|%ai|%s', '--name-only'],
|
||||
root,
|
||||
);
|
||||
|
||||
const commits = parseGitLog(raw);
|
||||
const commitsByModule = buildCommitsByModule(commits);
|
||||
const fileChurn = buildFileChurn(commits);
|
||||
const staleness = buildStaleness(commitsByModule);
|
||||
const velocity = buildVelocity(commits);
|
||||
const commitTypes = buildCommitTypes(commits);
|
||||
|
||||
const recentCommits = commits.slice(0, RECENT_LIMIT).map(c => ({
|
||||
hash: c.hash,
|
||||
date: c.date,
|
||||
message: c.message,
|
||||
type: c.type,
|
||||
modules: c.modules,
|
||||
}));
|
||||
|
||||
const result = {
|
||||
timestamp: new Date().toISOString(),
|
||||
commitsByModule,
|
||||
fileChurn,
|
||||
staleness,
|
||||
velocity,
|
||||
commitTypes,
|
||||
recentCommits,
|
||||
totalCommits30d: commits.length,
|
||||
};
|
||||
|
||||
// Persist cache
|
||||
try {
|
||||
if (!existsSync(cacheDir)) {
|
||||
mkdirSync(cacheDir, { recursive: true });
|
||||
}
|
||||
writeFileSync(cacheFile, JSON.stringify(result, null, 2), 'utf8');
|
||||
} catch {
|
||||
// Non-fatal — scanning still succeeds without cache write
|
||||
}
|
||||
|
||||
return result;
|
||||
}
|
||||
@@ -1,131 +0,0 @@
|
||||
/**
|
||||
* Go test coverage collector.
|
||||
* Runs `go test ./... -cover -short -json` and parses per-package coverage.
|
||||
* Caches results to .cache/go-coverage.json.
|
||||
*/
|
||||
import { execFileSync } from 'node:child_process';
|
||||
import { readFileSync, writeFileSync, existsSync } from 'node:fs';
|
||||
import { resolve } from 'node:path';
|
||||
|
||||
const CACHE_FILE = 'go-coverage.json';
|
||||
|
||||
// Extract short package name from full Go module path
|
||||
// e.g. "github.com/owncord/server/admin" -> "admin"
|
||||
// e.g. "github.com/owncord/server" -> "root"
|
||||
function extractPkgName(fullPath) {
|
||||
const parts = fullPath.split('/');
|
||||
const last = parts[parts.length - 1];
|
||||
// If the package ends with "server" it's the root package
|
||||
if (last === 'server') return 'server-root';
|
||||
return last;
|
||||
}
|
||||
|
||||
function parseGoCoverage(jsonLines) {
|
||||
const coverage = {};
|
||||
|
||||
for (const line of jsonLines.split('\n')) {
|
||||
if (!line.trim()) continue;
|
||||
try {
|
||||
const entry = JSON.parse(line);
|
||||
// Look for coverage output lines
|
||||
if (entry.Action === 'output' && entry.Output) {
|
||||
// Match: "coverage: 67.3% of statements"
|
||||
const coverMatch = entry.Output.match(/coverage:\s+([\d.]+)%\s+of\s+statements/);
|
||||
if (coverMatch && entry.Package) {
|
||||
const pkg = extractPkgName(entry.Package);
|
||||
coverage[pkg] = {
|
||||
percentage: parseFloat(coverMatch[1]),
|
||||
package: pkg,
|
||||
};
|
||||
}
|
||||
// Match: "[no test files]"
|
||||
if (entry.Output.includes('[no test files]') && entry.Package) {
|
||||
const pkg = extractPkgName(entry.Package);
|
||||
coverage[pkg] = {
|
||||
percentage: null,
|
||||
package: pkg,
|
||||
noTests: true,
|
||||
};
|
||||
}
|
||||
}
|
||||
// Also check for pass/fail
|
||||
if (entry.Action === 'pass' && entry.Package) {
|
||||
const pkg = extractPkgName(entry.Package);
|
||||
if (!coverage[pkg]) {
|
||||
coverage[pkg] = { percentage: 0, package: pkg };
|
||||
}
|
||||
coverage[pkg].passed = true;
|
||||
}
|
||||
if (entry.Action === 'fail' && entry.Package) {
|
||||
const pkg = extractPkgName(entry.Package);
|
||||
if (!coverage[pkg]) {
|
||||
coverage[pkg] = { percentage: 0, package: pkg };
|
||||
}
|
||||
coverage[pkg].failed = true;
|
||||
}
|
||||
} catch { /* skip non-JSON lines */ }
|
||||
}
|
||||
|
||||
return coverage;
|
||||
}
|
||||
|
||||
export async function collectGoCoverage(root, cacheDir, quick) {
|
||||
const cacheFile = resolve(cacheDir, CACHE_FILE);
|
||||
|
||||
if (quick && existsSync(cacheFile)) {
|
||||
console.log(' [Go] Using cached coverage data');
|
||||
try {
|
||||
const cached = JSON.parse(readFileSync(cacheFile, 'utf8'));
|
||||
if (cached.hasFailures) {
|
||||
console.warn(' [Go Coverage] Cached data has test failures — re-running tests');
|
||||
// Fall through to full collection instead of returning cached
|
||||
} else {
|
||||
return cached;
|
||||
}
|
||||
} catch {
|
||||
console.warn(' [Go] Corrupt cache — re-running tests');
|
||||
}
|
||||
}
|
||||
|
||||
const serverDir = resolve(root, 'Server');
|
||||
if (!existsSync(serverDir)) {
|
||||
console.log(' [Go] Server directory not found, skipping');
|
||||
return {};
|
||||
}
|
||||
|
||||
console.log(' [Go] Running tests with coverage (this may take a minute)...');
|
||||
try {
|
||||
const output = execFileSync('go', ['test', './...', '-cover', '-short', '-json', '-count=1'], {
|
||||
cwd: serverDir,
|
||||
encoding: 'utf8',
|
||||
timeout: 300_000, // 5 min
|
||||
maxBuffer: 10 * 1024 * 1024,
|
||||
});
|
||||
|
||||
const coverage = parseGoCoverage(output);
|
||||
|
||||
// Cache results
|
||||
const result = {
|
||||
timestamp: new Date().toISOString(),
|
||||
packages: coverage,
|
||||
};
|
||||
writeFileSync(cacheFile, JSON.stringify(result, null, 2));
|
||||
console.log(` [Go] Coverage collected for ${Object.keys(coverage).length} packages`);
|
||||
return result;
|
||||
} catch (err) {
|
||||
// go test returns non-zero on test failure but still produces output
|
||||
if (err.stdout) {
|
||||
const coverage = parseGoCoverage(err.stdout);
|
||||
const result = {
|
||||
timestamp: new Date().toISOString(),
|
||||
packages: coverage,
|
||||
hasFailures: true,
|
||||
};
|
||||
writeFileSync(cacheFile, JSON.stringify(result, null, 2));
|
||||
console.log(` [Go] Coverage collected (some tests failed)`);
|
||||
return result;
|
||||
}
|
||||
console.error(` [Go] Failed to collect coverage: ${err.message}`);
|
||||
return { timestamp: new Date().toISOString(), packages: {}, error: err.message };
|
||||
}
|
||||
}
|
||||
@@ -1,472 +0,0 @@
|
||||
/**
|
||||
* Import-graph builder — parses Go, TypeScript, and Rust source files to
|
||||
* construct a dependency graph with fan-in/fan-out metrics and cycle detection.
|
||||
* Zero external dependencies — Node built-ins only.
|
||||
*/
|
||||
import { readFileSync, readdirSync, existsSync, mkdirSync, writeFileSync } from 'node:fs';
|
||||
import { join, resolve, basename, relative } from 'node:path';
|
||||
|
||||
// ---------------------------------------------------------------------------
|
||||
// File discovery
|
||||
// ---------------------------------------------------------------------------
|
||||
|
||||
/**
|
||||
* Recursively collect files matching `extensions` under `dir`, skipping
|
||||
* common non-source directories.
|
||||
*/
|
||||
function collectFiles(dir, extensions, skipSuffix = []) {
|
||||
const results = [];
|
||||
if (!existsSync(dir)) return results;
|
||||
|
||||
function walk(d) {
|
||||
let entries;
|
||||
try { entries = readdirSync(d, { withFileTypes: true }); } catch { return; }
|
||||
for (const entry of entries) {
|
||||
if (entry.name.startsWith('.') || ['node_modules', 'vendor', 'dist', 'target'].includes(entry.name)) continue;
|
||||
const full = join(d, entry.name);
|
||||
if (entry.isDirectory()) {
|
||||
walk(full);
|
||||
} else if (entry.isFile()
|
||||
&& extensions.some(ext => entry.name.endsWith(ext))
|
||||
&& !skipSuffix.some(suf => entry.name.endsWith(suf))) {
|
||||
results.push(full);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
walk(dir);
|
||||
return results;
|
||||
}
|
||||
|
||||
// ---------------------------------------------------------------------------
|
||||
// Go import parsing
|
||||
// ---------------------------------------------------------------------------
|
||||
|
||||
const GO_MODULE_PREFIX = 'github.com/owncord/server/';
|
||||
|
||||
/**
|
||||
* Parse a single Go file and return the set of internal package short-names
|
||||
* it imports (e.g. "db", "auth", "ws").
|
||||
*/
|
||||
function parseGoImports(content) {
|
||||
const deps = new Set();
|
||||
// Match import blocks: import ( ... )
|
||||
const blockRe = /import\s*\(([^)]*)\)/gs;
|
||||
let blockMatch;
|
||||
while ((blockMatch = blockRe.exec(content)) !== null) {
|
||||
const block = blockMatch[1];
|
||||
const lineRe = /["']([^"']+)["']/g;
|
||||
let lineMatch;
|
||||
while ((lineMatch = lineRe.exec(block)) !== null) {
|
||||
const path = lineMatch[1];
|
||||
if (path.startsWith(GO_MODULE_PREFIX)) {
|
||||
deps.add(path.slice(GO_MODULE_PREFIX.length).split('/')[0]);
|
||||
}
|
||||
}
|
||||
}
|
||||
// Match single-line imports: import "..."
|
||||
const singleRe = /import\s+["']([^"']+)["']/g;
|
||||
let singleMatch;
|
||||
while ((singleMatch = singleRe.exec(content)) !== null) {
|
||||
const path = singleMatch[1];
|
||||
if (path.startsWith(GO_MODULE_PREFIX)) {
|
||||
deps.add(path.slice(GO_MODULE_PREFIX.length).split('/')[0]);
|
||||
}
|
||||
}
|
||||
return deps;
|
||||
}
|
||||
|
||||
/**
|
||||
* Scan Go source files under `serverDir` and return a map of
|
||||
* package-name -> Set<dependency-package-name>.
|
||||
*/
|
||||
function scanGoImports(serverDir) {
|
||||
const graph = new Map();
|
||||
const files = collectFiles(serverDir, ['.go'], ['_test.go']);
|
||||
|
||||
for (const file of files) {
|
||||
// Determine package from directory name relative to server root
|
||||
const rel = relative(serverDir, file);
|
||||
const pkg = rel.includes('/') || rel.includes('\\')
|
||||
? rel.split(/[/\\]/)[0]
|
||||
: '.'; // root-level files (main.go etc.)
|
||||
|
||||
if (pkg === '.' || pkg === 'scripts' || pkg === 'migrations') continue;
|
||||
|
||||
if (!graph.has(pkg)) graph.set(pkg, new Set());
|
||||
|
||||
let content;
|
||||
try { content = readFileSync(file, 'utf8'); } catch { continue; }
|
||||
|
||||
const deps = parseGoImports(content);
|
||||
const existing = graph.get(pkg);
|
||||
for (const dep of deps) {
|
||||
if (dep !== pkg) existing.add(dep);
|
||||
}
|
||||
}
|
||||
|
||||
return graph;
|
||||
}
|
||||
|
||||
// ---------------------------------------------------------------------------
|
||||
// TypeScript import parsing
|
||||
// ---------------------------------------------------------------------------
|
||||
|
||||
/** Known TS path-alias prefixes that map to source directories. */
|
||||
const TS_ALIAS_MAP = {
|
||||
'@lib': 'lib',
|
||||
'@stores': 'stores',
|
||||
'@components': 'components',
|
||||
'@pages': 'pages',
|
||||
'@styles': 'styles',
|
||||
'@types': 'types',
|
||||
};
|
||||
|
||||
/**
|
||||
* Parse a TypeScript file and return the set of internal module names it
|
||||
* imports (e.g. "lib", "stores", "components").
|
||||
*/
|
||||
function parseTsImports(content) {
|
||||
const deps = new Set();
|
||||
|
||||
// Match: import ... from '...' / import '...' (including type imports)
|
||||
const re = /import\s+(?:type\s+)?(?:[^'"]*from\s+)?['"]([^'"]+)['"]/g;
|
||||
let m;
|
||||
while ((m = re.exec(content)) !== null) {
|
||||
const specifier = m[1];
|
||||
|
||||
// Check @alias paths: @lib/foo -> "lib"
|
||||
for (const [alias, dir] of Object.entries(TS_ALIAS_MAP)) {
|
||||
if (specifier.startsWith(alias + '/') || specifier === alias) {
|
||||
deps.add(dir);
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
// Check relative paths: ../lib/foo -> "lib", ./sibling stays in same dir
|
||||
if (specifier.startsWith('../')) {
|
||||
const segment = specifier.slice(3).split('/')[0];
|
||||
if (segment && Object.values(TS_ALIAS_MAP).includes(segment)) {
|
||||
deps.add(segment);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
return deps;
|
||||
}
|
||||
|
||||
/**
|
||||
* Determine which TS "module" a file belongs to based on its directory.
|
||||
* Files directly in src/ are grouped as "main".
|
||||
*/
|
||||
function tsModuleName(file, srcDir) {
|
||||
const rel = relative(srcDir, file).replace(/\\/g, '/');
|
||||
const parts = rel.split('/');
|
||||
if (parts.length === 1) return basename(parts[0], '.ts'); // top-level file -> its name
|
||||
return parts[0]; // first directory segment
|
||||
}
|
||||
|
||||
/**
|
||||
* Scan TypeScript files under `srcDir` and return a dependency map.
|
||||
*/
|
||||
function scanTsImports(srcDir) {
|
||||
const graph = new Map();
|
||||
const files = collectFiles(srcDir, ['.ts']);
|
||||
|
||||
for (const file of files) {
|
||||
const mod = tsModuleName(file, srcDir);
|
||||
if (!graph.has(mod)) graph.set(mod, new Set());
|
||||
|
||||
let content;
|
||||
try { content = readFileSync(file, 'utf8'); } catch { continue; }
|
||||
|
||||
const deps = parseTsImports(content);
|
||||
const existing = graph.get(mod);
|
||||
for (const dep of deps) {
|
||||
if (dep !== mod) existing.add(dep);
|
||||
}
|
||||
}
|
||||
|
||||
return graph;
|
||||
}
|
||||
|
||||
// ---------------------------------------------------------------------------
|
||||
// Rust import parsing
|
||||
// ---------------------------------------------------------------------------
|
||||
|
||||
/**
|
||||
* Parse a Rust file and return module names referenced via `mod` declarations
|
||||
* and `use crate::` paths.
|
||||
*/
|
||||
function parseRustImports(content) {
|
||||
const deps = new Set();
|
||||
|
||||
// mod declarations: mod foo;
|
||||
const modRe = /^\s*(?:pub\s+)?mod\s+(\w+)\s*;/gm;
|
||||
let m;
|
||||
while ((m = modRe.exec(content)) !== null) {
|
||||
deps.add(m[1]);
|
||||
}
|
||||
|
||||
// use crate::foo (possibly ::bar::baz)
|
||||
const useRe = /use\s+crate::(\w+)/g;
|
||||
while ((m = useRe.exec(content)) !== null) {
|
||||
deps.add(m[1]);
|
||||
}
|
||||
|
||||
return deps;
|
||||
}
|
||||
|
||||
/**
|
||||
* Determine Rust module name from filename.
|
||||
* lib.rs and main.rs -> "lib" / "main"; others -> stem.
|
||||
*/
|
||||
function rustModuleName(file) {
|
||||
const name = basename(file, '.rs');
|
||||
return name;
|
||||
}
|
||||
|
||||
/**
|
||||
* Scan Rust files and return a dependency map.
|
||||
*/
|
||||
function scanRustImports(rustDir) {
|
||||
const graph = new Map();
|
||||
const files = collectFiles(rustDir, ['.rs']);
|
||||
|
||||
for (const file of files) {
|
||||
const mod = rustModuleName(file);
|
||||
if (!graph.has(mod)) graph.set(mod, new Set());
|
||||
|
||||
let content;
|
||||
try { content = readFileSync(file, 'utf8'); } catch { continue; }
|
||||
|
||||
const deps = parseRustImports(content);
|
||||
const existing = graph.get(mod);
|
||||
for (const dep of deps) {
|
||||
if (dep !== mod) existing.add(dep);
|
||||
}
|
||||
}
|
||||
|
||||
return graph;
|
||||
}
|
||||
|
||||
// ---------------------------------------------------------------------------
|
||||
// Graph analysis
|
||||
// ---------------------------------------------------------------------------
|
||||
|
||||
/**
|
||||
* Merge multiple per-language graphs into a single adjacency list (object).
|
||||
* Each value is a Map<moduleName, Set<dep>>; we also track which language
|
||||
* each module belongs to.
|
||||
*/
|
||||
function mergeGraphs(goGraph, tsGraph, rustGraph) {
|
||||
const merged = {}; // module -> string[]
|
||||
const types = {}; // module -> 'go' | 'typescript' | 'rust'
|
||||
|
||||
for (const [mod, deps] of goGraph) {
|
||||
const key = `go/${mod}`;
|
||||
merged[key] = [...deps].map(d => `go/${d}`);
|
||||
types[key] = 'go';
|
||||
}
|
||||
for (const [mod, deps] of tsGraph) {
|
||||
const key = `ts/${mod}`;
|
||||
merged[key] = [...deps].map(d => `ts/${d}`);
|
||||
types[key] = 'typescript';
|
||||
}
|
||||
for (const [mod, deps] of rustGraph) {
|
||||
const key = `rs/${mod}`;
|
||||
merged[key] = [...deps].map(d => `rs/${d}`);
|
||||
types[key] = 'rust';
|
||||
}
|
||||
|
||||
return { merged, types };
|
||||
}
|
||||
|
||||
/**
|
||||
* Compute fan-in (how many modules depend on this one) and fan-out (how many
|
||||
* modules this one depends on).
|
||||
*/
|
||||
function computeMetrics(graph) {
|
||||
const fanIn = {};
|
||||
const fanOut = {};
|
||||
|
||||
for (const mod of Object.keys(graph)) {
|
||||
fanOut[mod] = graph[mod].length;
|
||||
if (!(mod in fanIn)) fanIn[mod] = 0;
|
||||
for (const dep of graph[mod]) {
|
||||
fanIn[dep] = (fanIn[dep] || 0) + 1;
|
||||
}
|
||||
}
|
||||
|
||||
return { fanIn, fanOut };
|
||||
}
|
||||
|
||||
/**
|
||||
* Detect all cycles in the directed graph using iterative DFS with an
|
||||
* explicit stack to avoid call-stack overflow on large graphs.
|
||||
* Returns an array of cycles, each cycle being an array of module names.
|
||||
*/
|
||||
function detectCycles(graph) {
|
||||
const WHITE = 0; // unvisited
|
||||
const GRAY = 1; // in current path
|
||||
const BLACK = 2; // fully explored
|
||||
|
||||
const color = {};
|
||||
for (const node of Object.keys(graph)) {
|
||||
color[node] = WHITE;
|
||||
}
|
||||
|
||||
const cycles = [];
|
||||
|
||||
for (const start of Object.keys(graph)) {
|
||||
if (color[start] !== WHITE) continue;
|
||||
|
||||
// Stack entries: [node, neighborIndex, pathSoFar]
|
||||
const stack = [[start, 0, [start]]];
|
||||
color[start] = GRAY;
|
||||
|
||||
while (stack.length > 0) {
|
||||
const top = stack[stack.length - 1];
|
||||
const node = top[0];
|
||||
const neighbors = graph[node] || [];
|
||||
|
||||
if (top[1] >= neighbors.length) {
|
||||
// All neighbors explored — backtrack
|
||||
color[node] = BLACK;
|
||||
stack.pop();
|
||||
continue;
|
||||
}
|
||||
|
||||
const neighbor = neighbors[top[1]];
|
||||
top[1]++;
|
||||
|
||||
if (color[neighbor] === GRAY) {
|
||||
// Found a cycle — extract the cycle portion from the current path
|
||||
const fullPath = [...top[2], neighbor];
|
||||
const cycleStart = fullPath.indexOf(neighbor);
|
||||
if (cycleStart !== -1 && cycleStart < fullPath.length - 1) {
|
||||
cycles.push(fullPath.slice(cycleStart));
|
||||
}
|
||||
} else if (color[neighbor] === WHITE) {
|
||||
color[neighbor] = GRAY;
|
||||
stack.push([neighbor, 0, [...top[2], neighbor]]);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
return cycles;
|
||||
}
|
||||
|
||||
// ---------------------------------------------------------------------------
|
||||
// Main entry point
|
||||
// ---------------------------------------------------------------------------
|
||||
|
||||
/**
|
||||
* Build the full import graph for the OwnCord project.
|
||||
*
|
||||
* @param {string} root — project root directory
|
||||
* @param {string} cacheDir — directory for caching results
|
||||
* @param {boolean} quick — if true, return cached results when available
|
||||
* @returns {Promise<object>} — import graph data
|
||||
*/
|
||||
export async function buildImportGraph(root, cacheDir, quick) {
|
||||
const cacheFile = join(cacheDir, 'import-graph.json');
|
||||
|
||||
// Quick mode: return cache if it exists
|
||||
if (quick && existsSync(cacheFile)) {
|
||||
try {
|
||||
const cached = JSON.parse(readFileSync(cacheFile, 'utf8'));
|
||||
return cached;
|
||||
} catch {
|
||||
// Cache corrupt — rebuild
|
||||
}
|
||||
}
|
||||
|
||||
// Scan each language
|
||||
const serverDir = resolve(root, 'Server');
|
||||
const tsSrcDir = resolve(root, 'Client', 'tauri-client', 'src');
|
||||
const rustDir = resolve(root, 'Client', 'tauri-client', 'src-tauri', 'src');
|
||||
|
||||
const goGraph = scanGoImports(serverDir);
|
||||
const tsGraph = scanTsImports(tsSrcDir);
|
||||
const rustGraph = scanRustImports(rustDir);
|
||||
|
||||
// Merge into unified adjacency list
|
||||
const { merged, types } = mergeGraphs(goGraph, tsGraph, rustGraph);
|
||||
|
||||
// Compute metrics
|
||||
const { fanIn, fanOut } = computeMetrics(merged);
|
||||
|
||||
// Build nodes array
|
||||
const nodes = Object.keys(merged).map(mod => {
|
||||
const fi = fanIn[mod] || 0;
|
||||
const fo = fanOut[mod] || 0;
|
||||
return {
|
||||
name: mod,
|
||||
type: types[mod] || 'go',
|
||||
fanIn: fi,
|
||||
fanOut: fo,
|
||||
coupling: fi * fo,
|
||||
};
|
||||
});
|
||||
|
||||
// Also include nodes that appear only as dependencies (no outgoing edges)
|
||||
for (const mod of Object.keys(fanIn)) {
|
||||
if (!(mod in merged)) {
|
||||
const fi = fanIn[mod] || 0;
|
||||
nodes.push({
|
||||
name: mod,
|
||||
type: types[mod] || inferType(mod),
|
||||
fanIn: fi,
|
||||
fanOut: 0,
|
||||
coupling: 0,
|
||||
});
|
||||
}
|
||||
}
|
||||
|
||||
// Build edges array
|
||||
const edges = [];
|
||||
for (const [from, deps] of Object.entries(merged)) {
|
||||
for (const to of deps) {
|
||||
edges.push({ from, to });
|
||||
}
|
||||
}
|
||||
|
||||
// Detect cycles
|
||||
const cycles = detectCycles(merged);
|
||||
|
||||
// Top 5 most coupled
|
||||
const mostCoupled = [...nodes]
|
||||
.sort((a, b) => b.coupling - a.coupling)
|
||||
.slice(0, 5)
|
||||
.map(({ name, coupling, fanIn, fanOut }) => ({ name, coupling, fanIn, fanOut }));
|
||||
|
||||
const result = {
|
||||
timestamp: new Date().toISOString(),
|
||||
graph: merged,
|
||||
nodes,
|
||||
edges,
|
||||
cycles,
|
||||
mostCoupled,
|
||||
};
|
||||
|
||||
// Write cache
|
||||
try {
|
||||
mkdirSync(cacheDir, { recursive: true });
|
||||
writeFileSync(cacheFile, JSON.stringify(result, null, 2), 'utf8');
|
||||
} catch {
|
||||
// Non-fatal — proceed without caching
|
||||
}
|
||||
|
||||
return result;
|
||||
}
|
||||
|
||||
/**
|
||||
* Infer language type from a prefixed module name.
|
||||
*/
|
||||
function inferType(mod) {
|
||||
if (mod.startsWith('go/')) return 'go';
|
||||
if (mod.startsWith('ts/')) return 'typescript';
|
||||
if (mod.startsWith('rs/')) return 'rust';
|
||||
return 'go';
|
||||
}
|
||||
@@ -1,190 +0,0 @@
|
||||
/**
|
||||
* Morning Briefing — digest of overnight agent results + session suggestions.
|
||||
* Composes data from session-parser, agent-manager, suggestion-engine, and backlog-parser.
|
||||
*/
|
||||
import { readFileSync, existsSync, readdirSync, statSync } from 'node:fs';
|
||||
import { resolve, join } from 'node:path';
|
||||
|
||||
/**
|
||||
* Generate a morning briefing digest.
|
||||
* Shows what happened since the last session (agent results, coverage changes, etc.)
|
||||
* and suggests what to work on next.
|
||||
*/
|
||||
export async function generateBriefing(root, cacheDir, {
|
||||
sessionData = null,
|
||||
suggestions = null,
|
||||
backlog = null,
|
||||
agentJobs = null,
|
||||
} = {}) {
|
||||
const briefing = {
|
||||
timestamp: new Date().toISOString(),
|
||||
greeting: '',
|
||||
agentResults: [],
|
||||
deadJobs: [],
|
||||
coverageChanges: [],
|
||||
suggestedTasks: [],
|
||||
autoQueueSuggestions: [],
|
||||
stats: { completedJobs: 0, failedJobs: 0, deadJobs: 0 },
|
||||
};
|
||||
|
||||
// Determine last session date for "since last session" filtering
|
||||
const lastSessionDate = sessionData?.lastSession?.date
|
||||
? new Date(sessionData.lastSession.date)
|
||||
: null;
|
||||
|
||||
// Greeting
|
||||
if (lastSessionDate) {
|
||||
const daysSince = Math.floor((Date.now() - lastSessionDate.getTime()) / 86400000);
|
||||
if (daysSince === 0) {
|
||||
briefing.greeting = 'Welcome back! You had a session earlier today.';
|
||||
} else if (daysSince === 1) {
|
||||
briefing.greeting = 'Good morning! Last session was yesterday.';
|
||||
} else {
|
||||
briefing.greeting = `Welcome back! It's been ${daysSince} days since your last session.`;
|
||||
}
|
||||
} else {
|
||||
briefing.greeting = 'Welcome! This is your first time opening the briefing.';
|
||||
}
|
||||
|
||||
// Agent results since last session
|
||||
if (agentJobs?.jobs) {
|
||||
for (const job of agentJobs.jobs) {
|
||||
if (job.status === 'completed') {
|
||||
const completedAt = job.completedAt ? new Date(job.completedAt) : null;
|
||||
if (!lastSessionDate || (completedAt && completedAt > lastSessionDate)) {
|
||||
// Read result summary (first 500 chars)
|
||||
let summary = '';
|
||||
const resultPath = resolve(cacheDir, `agent-results/${job.id}.md`);
|
||||
if (existsSync(resultPath)) {
|
||||
try {
|
||||
const content = readFileSync(resultPath, 'utf8');
|
||||
summary = content.slice(0, 500).split('\n').slice(0, 10).join('\n');
|
||||
if (content.length > 500) summary += '\n...';
|
||||
} catch { /* skip */ }
|
||||
}
|
||||
briefing.agentResults.push({
|
||||
id: job.id,
|
||||
type: job.type,
|
||||
target: job.target,
|
||||
completedAt: job.completedAt,
|
||||
summary,
|
||||
});
|
||||
briefing.stats.completedJobs++;
|
||||
}
|
||||
}
|
||||
|
||||
if (job.status === 'failed') briefing.stats.failedJobs++;
|
||||
|
||||
if (job.status === 'dead') {
|
||||
briefing.deadJobs.push({
|
||||
id: job.id,
|
||||
type: job.type,
|
||||
target: job.target,
|
||||
error: job.error,
|
||||
retryCount: job.retryCount,
|
||||
});
|
||||
briefing.stats.deadJobs++;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// Top suggested tasks from suggestion engine
|
||||
if (suggestions?.suggestions) {
|
||||
briefing.suggestedTasks = suggestions.suggestions.slice(0, 5).map(s => ({
|
||||
module: s.module,
|
||||
score: s.score,
|
||||
rationale: s.rationale,
|
||||
breakdown: s.breakdown,
|
||||
}));
|
||||
}
|
||||
|
||||
// Auto-queue suggestions — only when agent jobs context is available
|
||||
briefing.autoQueueSuggestions = agentJobs
|
||||
? generateAutoQueueSuggestions(suggestions, backlog, sessionData, agentJobs)
|
||||
: [];
|
||||
|
||||
return briefing;
|
||||
}
|
||||
|
||||
/**
|
||||
* Generate smart auto-queue suggestions.
|
||||
* Recommends agent jobs based on current project state.
|
||||
*/
|
||||
function generateAutoQueueSuggestions(suggestions, backlog, sessionData, agentJobs) {
|
||||
const existing = new Set(
|
||||
(agentJobs?.jobs || [])
|
||||
.filter(j => ['queued', 'running', 'completed'].includes(j.status))
|
||||
.map(j => `${j.type}:${j.target}`)
|
||||
);
|
||||
|
||||
const suggestions_list = [];
|
||||
|
||||
if (!suggestions?.suggestions) return suggestions_list;
|
||||
|
||||
for (const s of suggestions.suggestions.slice(0, 10)) {
|
||||
// Coverage gap → suggest write-tests
|
||||
if (s.breakdown?.coverage > 20) {
|
||||
const key = `write-tests:${s.module}`;
|
||||
if (!existing.has(key)) {
|
||||
suggestions_list.push({
|
||||
type: 'write-tests',
|
||||
target: s.module,
|
||||
rationale: `Coverage gap on ${s.module} (score: ${s.breakdown.coverage})`,
|
||||
priority: 2,
|
||||
});
|
||||
}
|
||||
}
|
||||
|
||||
// High debt → suggest fix-debt
|
||||
if (s.breakdown?.debt > 15) {
|
||||
const key = `fix-debt:${s.module}`;
|
||||
if (!existing.has(key)) {
|
||||
suggestions_list.push({
|
||||
type: 'fix-debt',
|
||||
target: s.module,
|
||||
rationale: `Tech debt markers in ${s.module} (score: ${s.breakdown.debt})`,
|
||||
priority: 3,
|
||||
});
|
||||
}
|
||||
}
|
||||
|
||||
// Open bugs → suggest code-review
|
||||
if (s.breakdown?.bugs > 10) {
|
||||
const key = `code-review:${s.module}`;
|
||||
if (!existing.has(key)) {
|
||||
suggestions_list.push({
|
||||
type: 'code-review',
|
||||
target: s.module,
|
||||
rationale: `Open bugs/review items in ${s.module} (score: ${s.breakdown.bugs})`,
|
||||
priority: 1,
|
||||
});
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// Stale modules → suggest research (limit to top 2)
|
||||
const staleModules = suggestions.suggestions
|
||||
.filter(s => s.signals?.some(sig => sig.signal === 'stale'))
|
||||
.slice(0, 2);
|
||||
|
||||
for (const s of staleModules) {
|
||||
const key = `research:${s.module}`;
|
||||
if (!existing.has(key)) {
|
||||
suggestions_list.push({
|
||||
type: 'research',
|
||||
target: s.module,
|
||||
rationale: `Module ${s.module} has been stale — investigate status`,
|
||||
priority: 4,
|
||||
});
|
||||
}
|
||||
}
|
||||
|
||||
// Deduplicate and limit to 5
|
||||
const seen = new Set();
|
||||
return suggestions_list.filter(s => {
|
||||
const key = `${s.type}:${s.target}`;
|
||||
if (seen.has(key)) return false;
|
||||
seen.add(key);
|
||||
return true;
|
||||
}).slice(0, 5);
|
||||
}
|
||||
@@ -1,180 +0,0 @@
|
||||
/**
|
||||
* Priority scoring engine.
|
||||
* Ranks modules by where work is most needed based on:
|
||||
* - Coverage gap (distance from 80% target)
|
||||
* - Module size (larger modules = higher impact)
|
||||
* - Open bug/task count
|
||||
* - Roadmap position (earlier phases = higher priority)
|
||||
*/
|
||||
|
||||
const COVERAGE_TARGET = 80;
|
||||
|
||||
const PHASE_WEIGHTS = {
|
||||
'bug': 10,
|
||||
'high': 8,
|
||||
'code-review': 7,
|
||||
'medium': 5,
|
||||
'deferred': 3,
|
||||
'roadmap-r1': 4,
|
||||
'roadmap-r2': 3,
|
||||
'roadmap-r3': 2,
|
||||
'roadmap-r4': 1.5,
|
||||
'roadmap-r5': 1,
|
||||
'roadmap-r6': 0.5,
|
||||
'other': 2,
|
||||
};
|
||||
|
||||
function coverageGapScore(coveragePct) {
|
||||
if (coveragePct === null || coveragePct === undefined) return 50; // no tests = high gap
|
||||
const gap = Math.max(0, COVERAGE_TARGET - coveragePct);
|
||||
return gap * 1.5; // 1.5 points per percent below target
|
||||
}
|
||||
|
||||
function sizeScore(sourceFiles, sourceLines) {
|
||||
// Larger modules are higher impact
|
||||
return Math.min(30, sourceFiles * 2 + (sourceLines / 200));
|
||||
}
|
||||
|
||||
function taskScore(openTasks) {
|
||||
if (!openTasks || openTasks.length === 0) return 0;
|
||||
let score = 0;
|
||||
for (const task of openTasks) {
|
||||
score += PHASE_WEIGHTS[task.phase] || 2;
|
||||
}
|
||||
return score;
|
||||
}
|
||||
|
||||
export function scorePriorities(modules, goCoverage, vitestCoverage, backlog) {
|
||||
const scores = [];
|
||||
|
||||
// Score Go packages
|
||||
for (const pkg of modules.go) {
|
||||
const covData = goCoverage.packages?.[pkg.name];
|
||||
const coverage = covData?.percentage ?? null;
|
||||
const openTasks = backlog.byModule[pkg.name] || [];
|
||||
|
||||
const cScore = coverageGapScore(coverage);
|
||||
const sScore = sizeScore(pkg.sourceFiles, pkg.sourceLines);
|
||||
const tScore = taskScore(openTasks);
|
||||
const total = cScore + sScore + tScore;
|
||||
|
||||
scores.push({
|
||||
name: pkg.name,
|
||||
type: 'go',
|
||||
path: pkg.path,
|
||||
coverage,
|
||||
coverageGap: cScore,
|
||||
sizeImpact: sScore,
|
||||
taskWeight: tScore,
|
||||
totalScore: total,
|
||||
openTaskCount: openTasks.length,
|
||||
openTasks: openTasks.map(t => t.id),
|
||||
recommendation: getRecommendation(coverage, openTasks, pkg),
|
||||
});
|
||||
}
|
||||
|
||||
// Score TypeScript areas
|
||||
const tsAreas = vitestCoverage.areas || {};
|
||||
for (const dir of modules.typescript.filter(d => d.type === 'typescript')) {
|
||||
const areaCov = tsAreas[dir.name];
|
||||
const coverage = areaCov?.statements ?? (tsAreas._total?.statements ?? null);
|
||||
const openTasks = backlog.byModule[dir.name] || [];
|
||||
|
||||
const cScore = coverageGapScore(coverage);
|
||||
const sScore = sizeScore(dir.sourceFiles, dir.sourceLines);
|
||||
const tScore = taskScore(openTasks);
|
||||
const total = cScore + sScore + tScore;
|
||||
|
||||
scores.push({
|
||||
name: dir.name,
|
||||
type: 'typescript',
|
||||
path: dir.path,
|
||||
coverage,
|
||||
coverageGap: cScore,
|
||||
sizeImpact: sScore,
|
||||
taskWeight: tScore,
|
||||
totalScore: total,
|
||||
openTaskCount: openTasks.length,
|
||||
openTasks: openTasks.map(t => t.id),
|
||||
recommendation: getRecommendation(coverage, openTasks, dir),
|
||||
});
|
||||
}
|
||||
|
||||
// Score Rust
|
||||
for (const rust of modules.rust) {
|
||||
const openTasks = backlog.byModule['tauri-rust'] || [];
|
||||
const cScore = coverageGapScore(null); // no Rust tests
|
||||
const sScore = sizeScore(rust.sourceFiles, rust.sourceLines);
|
||||
const tScore = taskScore(openTasks);
|
||||
const total = cScore + sScore + tScore;
|
||||
|
||||
scores.push({
|
||||
name: rust.name,
|
||||
type: 'rust',
|
||||
path: rust.path,
|
||||
coverage: null,
|
||||
coverageGap: cScore,
|
||||
sizeImpact: sScore,
|
||||
taskWeight: tScore,
|
||||
totalScore: total,
|
||||
openTaskCount: openTasks.length,
|
||||
openTasks: openTasks.map(t => t.id),
|
||||
recommendation: 'Add Rust unit tests — currently zero test coverage',
|
||||
});
|
||||
}
|
||||
|
||||
// Score cross-cutting areas from backlog
|
||||
const crossCutting = ['livekit', 'gaming', 'community', 'platform', 'ai', 'protocol'];
|
||||
for (const area of crossCutting) {
|
||||
const openTasks = backlog.byModule[area] || [];
|
||||
if (openTasks.length === 0) continue;
|
||||
|
||||
const tScore = taskScore(openTasks);
|
||||
scores.push({
|
||||
name: area,
|
||||
type: 'feature-area',
|
||||
path: '',
|
||||
coverage: null,
|
||||
coverageGap: 0,
|
||||
sizeImpact: 0,
|
||||
taskWeight: tScore,
|
||||
totalScore: tScore,
|
||||
openTaskCount: openTasks.length,
|
||||
openTasks: openTasks.map(t => t.id),
|
||||
recommendation: `${openTasks.length} open task(s) in backlog`,
|
||||
});
|
||||
}
|
||||
|
||||
// Sort by total score descending
|
||||
scores.sort((a, b) => b.totalScore - a.totalScore);
|
||||
|
||||
return scores;
|
||||
}
|
||||
|
||||
function getRecommendation(coverage, openTasks, module) {
|
||||
const parts = [];
|
||||
|
||||
if (coverage === null) {
|
||||
parts.push('No test coverage');
|
||||
} else if (coverage < 60) {
|
||||
parts.push(`Coverage critically low (${coverage.toFixed(1)}%)`);
|
||||
} else if (coverage < COVERAGE_TARGET) {
|
||||
parts.push(`Coverage below target (${coverage.toFixed(1)}% < ${COVERAGE_TARGET}%)`);
|
||||
}
|
||||
|
||||
if (openTasks.length > 0) {
|
||||
const bugs = openTasks.filter(t => t.phase === 'bug');
|
||||
const reviews = openTasks.filter(t => t.phase === 'code-review');
|
||||
if (bugs.length > 0) parts.push(`${bugs.length} open bug(s)`);
|
||||
if (reviews.length > 0) parts.push(`${reviews.length} code review fix(es)`);
|
||||
if (parts.length === 0 || (bugs.length === 0 && reviews.length === 0)) {
|
||||
parts.push(`${openTasks.length} open task(s)`);
|
||||
}
|
||||
}
|
||||
|
||||
if (module.sourceFiles > 15) {
|
||||
parts.push('Large module — high impact');
|
||||
}
|
||||
|
||||
return parts.length > 0 ? parts.join('; ') : 'Good shape';
|
||||
}
|
||||
@@ -1,162 +0,0 @@
|
||||
/**
|
||||
* Markdown report generator.
|
||||
* Writes the full project map to docs/brain/00-Overview/Project-Map.md.
|
||||
*/
|
||||
import { writeFileSync, mkdirSync } from 'node:fs';
|
||||
import { dirname } from 'node:path';
|
||||
|
||||
function badge(coverage) {
|
||||
if (coverage === null || coverage === undefined) return '---';
|
||||
return `${coverage.toFixed(1)}%`;
|
||||
}
|
||||
|
||||
function statusIcon(coverage) {
|
||||
if (coverage === null || coverage === undefined) return 'No tests';
|
||||
if (coverage >= 80) return 'Above target';
|
||||
if (coverage >= 70) return 'Near target';
|
||||
if (coverage >= 50) return 'Below target';
|
||||
return 'Critical';
|
||||
}
|
||||
|
||||
export async function generateReport(reportPath, modules, goCoverage, vitestCoverage, backlog, priorities) {
|
||||
mkdirSync(dirname(reportPath), { recursive: true });
|
||||
|
||||
const now = new Date().toISOString().replace('T', ' ').slice(0, 19);
|
||||
const lines = [];
|
||||
|
||||
lines.push('# OwnCord Project Map');
|
||||
lines.push('');
|
||||
lines.push(`> Auto-generated on ${now} by \`tools/project-map\``);
|
||||
lines.push(`> Run \`node tools/project-map/index.mjs\` to regenerate`);
|
||||
lines.push('');
|
||||
|
||||
// --- Summary ---
|
||||
lines.push('## Summary');
|
||||
lines.push('');
|
||||
lines.push(`| Metric | Value |`);
|
||||
lines.push(`|--------|-------|`);
|
||||
lines.push(`| Go packages | ${modules.summary.goPackages} |`);
|
||||
lines.push(`| Go source files | ${modules.summary.goSourceFiles} |`);
|
||||
lines.push(`| Go test files | ${modules.summary.goTestFiles} |`);
|
||||
lines.push(`| TypeScript source files | ${modules.summary.tsSourceFiles} |`);
|
||||
lines.push(`| TypeScript test files | ${modules.summary.tsTestFiles} |`);
|
||||
lines.push(`| Rust source files | ${modules.summary.rustSourceFiles} |`);
|
||||
lines.push(`| Rust test files | ${modules.summary.rustTestFiles} |`);
|
||||
lines.push(`| Open backlog tasks | ${backlog.openCount} |`);
|
||||
lines.push(`| Completed tasks | ${backlog.doneCount} |`);
|
||||
lines.push(`| Completion rate | ${backlog.doneCount > 0 ? ((backlog.doneCount / (backlog.openCount + backlog.doneCount)) * 100).toFixed(1) : 0}% |`);
|
||||
lines.push('');
|
||||
|
||||
// --- Server Coverage ---
|
||||
lines.push('## Server (Go) — Test Coverage');
|
||||
lines.push('');
|
||||
lines.push('| Package | Source Files | Test Files | Coverage | Status |');
|
||||
lines.push('|---------|-------------|------------|----------|--------|');
|
||||
|
||||
for (const pkg of modules.go) {
|
||||
const covData = goCoverage.packages?.[pkg.name];
|
||||
const cov = covData?.percentage ?? null;
|
||||
const status = covData?.noTests ? 'No tests' : statusIcon(cov);
|
||||
const failed = covData?.failed ? ' (FAILING)' : '';
|
||||
lines.push(`| \`${pkg.name}/\` | ${pkg.sourceFiles} | ${pkg.testFiles} | ${badge(cov)} | ${status}${failed} |`);
|
||||
}
|
||||
lines.push('');
|
||||
|
||||
// --- Client Coverage ---
|
||||
lines.push('## Client (TypeScript) — Test Coverage');
|
||||
lines.push('');
|
||||
const tsAreas = vitestCoverage.areas || {};
|
||||
const totalCov = tsAreas._total;
|
||||
if (totalCov) {
|
||||
lines.push(`**Overall:** ${totalCov.statements.toFixed(1)}% statements, ${totalCov.branches.toFixed(1)}% branches, ${totalCov.functions.toFixed(1)}% functions`);
|
||||
lines.push('');
|
||||
}
|
||||
if (vitestCoverage.testCount) {
|
||||
lines.push(`**Total tests:** ${vitestCoverage.testCount}`);
|
||||
lines.push('');
|
||||
}
|
||||
|
||||
lines.push('| Area | Source Files | Coverage (stmts) | Status |');
|
||||
lines.push('|------|-------------|------------------|--------|');
|
||||
for (const dir of modules.typescript.filter(d => d.type === 'typescript')) {
|
||||
const areaCov = tsAreas[dir.name];
|
||||
const cov = areaCov?.statements ?? null;
|
||||
lines.push(`| \`${dir.name}/\` | ${dir.sourceFiles} | ${badge(cov)} | ${statusIcon(cov)} |`);
|
||||
}
|
||||
lines.push('');
|
||||
|
||||
// Test file counts
|
||||
lines.push('| Test Suite | Files |');
|
||||
lines.push('|-----------|-------|');
|
||||
for (const dir of modules.typescript.filter(d => d.type !== 'typescript')) {
|
||||
lines.push(`| \`${dir.name}\` | ${dir.testFiles} |`);
|
||||
}
|
||||
lines.push('');
|
||||
|
||||
// --- Rust ---
|
||||
lines.push('## Client (Rust/Tauri) — Status');
|
||||
lines.push('');
|
||||
for (const rust of modules.rust) {
|
||||
lines.push(`| Metric | Value |`);
|
||||
lines.push(`|--------|-------|`);
|
||||
lines.push(`| Source files | ${rust.sourceFiles} |`);
|
||||
lines.push(`| Lines of code | ${rust.sourceLines} |`);
|
||||
lines.push(`| Test files | ${rust.testFiles} |`);
|
||||
lines.push(`| Coverage | No test infrastructure |`);
|
||||
}
|
||||
lines.push('');
|
||||
|
||||
// --- Backlog by Phase ---
|
||||
lines.push('## Open Work — By Phase');
|
||||
lines.push('');
|
||||
const phaseOrder = ['bug', 'high', 'code-review', 'medium', 'deferred', 'roadmap-r1', 'roadmap-r2', 'roadmap-r3', 'roadmap-r4', 'roadmap-r5', 'roadmap-r6', 'other'];
|
||||
const phaseLabels = {
|
||||
'bug': 'Bugs', 'high': 'High Priority', 'code-review': 'Code Review',
|
||||
'medium': 'Medium Priority', 'deferred': 'Deferred Features',
|
||||
'roadmap-r1': 'R1: Community Essentials', 'roadmap-r2': 'R2: Gaming DNA',
|
||||
'roadmap-r3': 'R3: Voice Power', 'roadmap-r4': 'R4: LAN Party Toolkit',
|
||||
'roadmap-r5': 'R5: Platform & Extensibility', 'roadmap-r6': 'R6: Future Vision',
|
||||
'other': 'Other',
|
||||
};
|
||||
|
||||
for (const phase of phaseOrder) {
|
||||
const tasks = backlog.byPhase[phase];
|
||||
if (!tasks || tasks.length === 0) continue;
|
||||
lines.push(`### ${phaseLabels[phase] || phase} (${tasks.length})`);
|
||||
lines.push('');
|
||||
for (const task of tasks) {
|
||||
lines.push(`- **${task.id}:** ${task.description}`);
|
||||
}
|
||||
lines.push('');
|
||||
}
|
||||
|
||||
// --- Where to Work Next ---
|
||||
lines.push('## Where to Work Next');
|
||||
lines.push('');
|
||||
lines.push('Ranked by priority score (coverage gap + module size + open tasks):');
|
||||
lines.push('');
|
||||
lines.push('| # | Module | Type | Score | Coverage | Open Tasks | Recommendation |');
|
||||
lines.push('|---|--------|------|-------|----------|------------|----------------|');
|
||||
|
||||
const top = priorities.slice(0, 15);
|
||||
top.forEach((p, i) => {
|
||||
const cov = p.coverage !== null ? `${p.coverage.toFixed(1)}%` : '---';
|
||||
lines.push(`| ${i + 1} | \`${p.name}\` | ${p.type} | ${p.totalScore.toFixed(0)} | ${cov} | ${p.openTaskCount} | ${p.recommendation} |`);
|
||||
});
|
||||
lines.push('');
|
||||
|
||||
// --- Research ---
|
||||
lines.push('## Research');
|
||||
lines.push('');
|
||||
lines.push('Use `node tools/project-map/index.mjs --research` to launch a Claude Code agent');
|
||||
lines.push('that investigates a specific area and saves findings to `docs/brain/00-Overview/Research/`.');
|
||||
lines.push('');
|
||||
|
||||
// --- Staleness ---
|
||||
lines.push('---');
|
||||
lines.push(`*Last generated: ${now}*`);
|
||||
lines.push('');
|
||||
|
||||
writeFileSync(reportPath, lines.join('\n'), 'utf8');
|
||||
console.log(`\n Report written to: ${reportPath}`);
|
||||
}
|
||||
@@ -1,223 +0,0 @@
|
||||
/**
|
||||
* Research agent launcher.
|
||||
* Spawns a Claude Code subprocess to investigate a specific area
|
||||
* and saves findings to docs/brain/00-Overview/Research/.
|
||||
*/
|
||||
import { execFileSync, spawn } from 'node:child_process';
|
||||
import { existsSync, mkdirSync, writeFileSync, readFileSync } from 'node:fs';
|
||||
import { resolve } from 'node:path';
|
||||
import { createInterface } from 'node:readline';
|
||||
|
||||
const RESEARCH_DIR = 'docs/brain/00-Overview/Research';
|
||||
|
||||
const RESEARCH_AREAS = {
|
||||
'server-api': {
|
||||
label: 'Server API package',
|
||||
description: 'Analyze Server/api/ for coverage gaps, missing error handling, untested endpoints',
|
||||
scope: 'Server/api/',
|
||||
},
|
||||
'server-ws': {
|
||||
label: 'Server WebSocket package',
|
||||
description: 'Analyze Server/ws/ for coverage gaps, race conditions, edge cases in voice/chat handlers',
|
||||
scope: 'Server/ws/',
|
||||
},
|
||||
'server-auth': {
|
||||
label: 'Server auth package',
|
||||
description: 'Analyze Server/auth/ for security gaps, missing test cases, TOTP edge cases',
|
||||
scope: 'Server/auth/',
|
||||
},
|
||||
'server-db': {
|
||||
label: 'Server database package',
|
||||
description: 'Analyze Server/db/ for missing indexes, query performance, untested queries',
|
||||
scope: 'Server/db/',
|
||||
},
|
||||
'server-admin': {
|
||||
label: 'Server admin package',
|
||||
description: 'Analyze Server/admin/ for test coverage issues, build-tag gating, missing functionality',
|
||||
scope: 'Server/admin/',
|
||||
},
|
||||
'client-livekit': {
|
||||
label: 'Client LiveKit session',
|
||||
description: 'Analyze livekitSession.ts and related audio/video code for coverage gaps and edge cases',
|
||||
scope: 'Client/tauri-client/src/lib/livekitSession.ts',
|
||||
},
|
||||
'client-stores': {
|
||||
label: 'Client stores',
|
||||
description: 'Analyze reactive stores for state management edge cases, race conditions, memory leaks',
|
||||
scope: 'Client/tauri-client/src/stores/',
|
||||
},
|
||||
'rust-backend': {
|
||||
label: 'Tauri Rust backend',
|
||||
description: 'Analyze Rust backend for missing tests, security gaps in proxy/credential code',
|
||||
scope: 'Client/tauri-client/src-tauri/src/',
|
||||
},
|
||||
'e2e-coverage': {
|
||||
label: 'E2E test coverage',
|
||||
description: 'Analyze E2E test suite for missing critical user flows, flaky tests, gaps',
|
||||
scope: 'Client/tauri-client/tests/e2e/',
|
||||
},
|
||||
'security': {
|
||||
label: 'Security audit',
|
||||
description: 'Review codebase for OWASP Top 10 vulnerabilities, auth bypass, injection, XSS',
|
||||
scope: 'Server/ Client/tauri-client/src/',
|
||||
},
|
||||
'protocol': {
|
||||
label: 'Protocol compliance',
|
||||
description: 'Check server and client code against docs/brain/06-Specs/PROTOCOL.md for drift',
|
||||
scope: 'Server/ws/ Client/tauri-client/src/lib/dispatcher.ts',
|
||||
},
|
||||
};
|
||||
|
||||
function buildPrompt(areaKey, area, root) {
|
||||
const date = new Date().toISOString().slice(0, 10);
|
||||
const outputFile = `${RESEARCH_DIR}/${areaKey}-${date}.md`;
|
||||
|
||||
return `You are a research agent investigating the OwnCord project.
|
||||
|
||||
## Task
|
||||
${area.description}
|
||||
|
||||
## Scope
|
||||
Focus on: ${area.scope}
|
||||
|
||||
## Instructions
|
||||
1. Read the relevant source files and test files
|
||||
2. Identify:
|
||||
- Coverage gaps (functions/branches not tested)
|
||||
- Potential bugs or edge cases
|
||||
- Security concerns
|
||||
- Code quality issues
|
||||
- Missing functionality vs specs
|
||||
3. For each finding, note the file path and line number
|
||||
4. Prioritize findings as CRITICAL, HIGH, MEDIUM, or LOW
|
||||
|
||||
## Output
|
||||
Write your findings to: ${outputFile}
|
||||
|
||||
Use this format:
|
||||
---
|
||||
# Research: ${area.label}
|
||||
Date: ${date}
|
||||
Scope: ${area.scope}
|
||||
|
||||
## Summary
|
||||
[2-3 sentence overview]
|
||||
|
||||
## Findings
|
||||
|
||||
### CRITICAL
|
||||
- [finding with file:line reference]
|
||||
|
||||
### HIGH
|
||||
- [finding with file:line reference]
|
||||
|
||||
### MEDIUM
|
||||
- [finding with file:line reference]
|
||||
|
||||
### LOW
|
||||
- [finding with file:line reference]
|
||||
|
||||
## Recommendations
|
||||
[Prioritized list of what to fix/improve next]
|
||||
---
|
||||
|
||||
After writing the file, print a brief summary of what you found.`;
|
||||
}
|
||||
|
||||
async function promptUser(question) {
|
||||
const rl = createInterface({ input: process.stdin, output: process.stdout });
|
||||
return new Promise(resolve => {
|
||||
rl.question(question, answer => {
|
||||
rl.close();
|
||||
resolve(answer.trim());
|
||||
});
|
||||
});
|
||||
}
|
||||
|
||||
export async function launchResearchAgent(root) {
|
||||
console.log('\n Research Agent Launcher\n');
|
||||
console.log(' Available research areas:\n');
|
||||
|
||||
const keys = Object.keys(RESEARCH_AREAS);
|
||||
keys.forEach((key, i) => {
|
||||
const area = RESEARCH_AREAS[key];
|
||||
console.log(` ${i + 1}. ${area.label} — ${area.description.slice(0, 70)}...`);
|
||||
});
|
||||
|
||||
console.log(`\n ${keys.length + 1}. Custom (enter your own research prompt)`);
|
||||
|
||||
const choice = await promptUser('\n Enter number (or "q" to quit): ');
|
||||
|
||||
if (choice === 'q' || choice === '') {
|
||||
console.log(' Cancelled.');
|
||||
return;
|
||||
}
|
||||
|
||||
const num = parseInt(choice, 10);
|
||||
if (isNaN(num) || num < 1 || num > keys.length + 1) {
|
||||
console.log(' Invalid choice.');
|
||||
return;
|
||||
}
|
||||
|
||||
// Ensure research directory exists
|
||||
const researchDir = resolve(root, RESEARCH_DIR);
|
||||
mkdirSync(researchDir, { recursive: true });
|
||||
|
||||
let prompt;
|
||||
let areaKey;
|
||||
|
||||
if (num <= keys.length) {
|
||||
areaKey = keys[num - 1];
|
||||
const area = RESEARCH_AREAS[areaKey];
|
||||
prompt = buildPrompt(areaKey, area, root);
|
||||
console.log(`\n Launching research on: ${area.label}`);
|
||||
} else {
|
||||
const customPrompt = await promptUser(' Enter your research prompt: ');
|
||||
if (!customPrompt) {
|
||||
console.log(' Cancelled.');
|
||||
return;
|
||||
}
|
||||
areaKey = 'custom';
|
||||
prompt = customPrompt;
|
||||
console.log(`\n Launching custom research...`);
|
||||
}
|
||||
|
||||
// Save the prompt for reference
|
||||
const date = new Date().toISOString().slice(0, 10);
|
||||
const promptFile = resolve(researchDir, `${areaKey}-${date}-prompt.txt`);
|
||||
// Boundary check: ensure promptFile stays within researchDir
|
||||
if (!promptFile.startsWith(resolve(researchDir))) {
|
||||
console.error(' Error: prompt file path escapes research directory');
|
||||
return;
|
||||
}
|
||||
writeFileSync(promptFile, prompt, 'utf8');
|
||||
|
||||
console.log(` Prompt saved to: ${promptFile}`);
|
||||
console.log(`\n To run the research agent, execute:\n`);
|
||||
console.log(` claude --print "${promptFile.replace(/\\/g, '/')}"`);
|
||||
console.log(`\n Or copy the prompt and paste it into a Claude Code session.`);
|
||||
console.log(` The agent will save findings to: ${RESEARCH_DIR}/${areaKey}-${date}.md\n`);
|
||||
|
||||
// Try to launch claude directly if available
|
||||
try {
|
||||
execFileSync('claude', ['--version'], { stdio: 'pipe' });
|
||||
const launch = await promptUser(' Claude CLI detected. Launch now? (y/n): ');
|
||||
if (launch.toLowerCase() === 'y') {
|
||||
console.log('\n Spawning Claude Code agent...\n');
|
||||
// Use prompt file instead of inline prompt to avoid shell injection
|
||||
const child = spawn('claude', ['--print', promptFile], {
|
||||
cwd: root,
|
||||
stdio: 'inherit',
|
||||
shell: false,
|
||||
});
|
||||
child.on('close', (code) => {
|
||||
console.log(`\n Research agent exited with code ${code}`);
|
||||
console.log(` Check ${RESEARCH_DIR}/${areaKey}-${date}.md for findings.\n`);
|
||||
});
|
||||
// Wait for completion
|
||||
await new Promise(resolve => child.on('close', resolve));
|
||||
}
|
||||
} catch {
|
||||
// Claude CLI not available — just show instructions
|
||||
}
|
||||
}
|
||||
@@ -1,198 +0,0 @@
|
||||
/**
|
||||
* Module scanner — discovers Go packages, TypeScript directories, and Rust files.
|
||||
* Returns a structured inventory of the project.
|
||||
*/
|
||||
import { readdirSync, readFileSync, existsSync } from 'node:fs';
|
||||
import { resolve, join } from 'node:path';
|
||||
|
||||
function scanDir(dir, extensions, recursive = true) {
|
||||
let fileCount = 0;
|
||||
let lineCount = 0;
|
||||
|
||||
function walk(d) {
|
||||
if (!existsSync(d)) return;
|
||||
let entries;
|
||||
try { entries = readdirSync(d, { withFileTypes: true }); } catch { return; }
|
||||
for (const entry of entries) {
|
||||
if (entry.name.startsWith('.') || entry.name === 'node_modules' || entry.name === 'vendor' || entry.name === 'dist' || entry.name === 'target') continue;
|
||||
const full = join(d, entry.name);
|
||||
if (entry.isDirectory() && recursive) {
|
||||
walk(full);
|
||||
} else if (entry.isFile() && extensions.some(ext => entry.name.endsWith(ext))) {
|
||||
fileCount++;
|
||||
try {
|
||||
lineCount += readFileSync(full, 'utf8').split('\n').length;
|
||||
} catch { /* skip */ }
|
||||
}
|
||||
}
|
||||
}
|
||||
walk(dir);
|
||||
return { fileCount, lineCount };
|
||||
}
|
||||
|
||||
function scanGoDir(dir, name, pathPrefix) {
|
||||
const source = scanDir(dir, ['.go'], false);
|
||||
const testSource = { fileCount: 0, lineCount: 0 };
|
||||
|
||||
try {
|
||||
for (const f of readdirSync(dir)) {
|
||||
if (f.endsWith('_test.go')) {
|
||||
testSource.fileCount++;
|
||||
try {
|
||||
testSource.lineCount += readFileSync(join(dir, f), 'utf8').split('\n').length;
|
||||
} catch { /* skip */ }
|
||||
}
|
||||
}
|
||||
} catch { /* skip */ }
|
||||
|
||||
const srcFiles = source.fileCount - testSource.fileCount;
|
||||
const srcLines = source.lineCount - testSource.lineCount;
|
||||
|
||||
if (srcFiles > 0 || testSource.fileCount > 0) {
|
||||
return {
|
||||
name,
|
||||
type: 'go',
|
||||
path: pathPrefix,
|
||||
sourceFiles: srcFiles,
|
||||
sourceLines: srcLines,
|
||||
testFiles: testSource.fileCount,
|
||||
testLines: testSource.lineCount,
|
||||
};
|
||||
}
|
||||
return null;
|
||||
}
|
||||
|
||||
function scanGoPackages(serverDir) {
|
||||
const packages = [];
|
||||
if (!existsSync(serverDir)) return packages;
|
||||
|
||||
// Scan root-level Go files (main.go, etc.)
|
||||
const rootPkg = scanGoDir(serverDir, 'server-root', 'Server');
|
||||
if (rootPkg) packages.push(rootPkg);
|
||||
|
||||
// Scan subdirectory packages
|
||||
for (const entry of readdirSync(serverDir, { withFileTypes: true })) {
|
||||
if (!entry.isDirectory() || entry.name.startsWith('.') || entry.name === 'vendor') continue;
|
||||
const pkg = scanGoDir(join(serverDir, entry.name), entry.name, `Server/${entry.name}`);
|
||||
if (pkg) packages.push(pkg);
|
||||
}
|
||||
return packages;
|
||||
}
|
||||
|
||||
function scanTSDirectories(clientSrcDir) {
|
||||
const dirs = [];
|
||||
if (!existsSync(clientSrcDir)) return dirs;
|
||||
|
||||
const scanAreas = ['lib', 'stores', 'components', 'pages', 'styles'];
|
||||
for (const area of scanAreas) {
|
||||
const areaDir = join(clientSrcDir, area);
|
||||
if (!existsSync(areaDir)) continue;
|
||||
const source = scanDir(areaDir, ['.ts', '.tsx', '.js', '.jsx'], true);
|
||||
dirs.push({
|
||||
name: area,
|
||||
type: 'typescript',
|
||||
path: `Client/tauri-client/src/${area}`,
|
||||
sourceFiles: source.fileCount,
|
||||
sourceLines: source.lineCount,
|
||||
testFiles: 0, // tests are in a separate dir
|
||||
testLines: 0,
|
||||
});
|
||||
}
|
||||
|
||||
// Count test files
|
||||
const testDir = resolve(clientSrcDir, '../tests');
|
||||
if (existsSync(testDir)) {
|
||||
for (const subdir of ['unit', 'integration']) {
|
||||
const td = join(testDir, subdir);
|
||||
if (!existsSync(td)) continue;
|
||||
const tests = scanDir(td, ['.ts', '.tsx', '.test.ts', '.test.tsx', '.spec.ts'], true);
|
||||
dirs.push({
|
||||
name: `tests/${subdir}`,
|
||||
type: 'typescript-tests',
|
||||
path: `Client/tauri-client/tests/${subdir}`,
|
||||
sourceFiles: 0,
|
||||
sourceLines: 0,
|
||||
testFiles: tests.fileCount,
|
||||
testLines: tests.lineCount,
|
||||
});
|
||||
}
|
||||
|
||||
// E2E tests
|
||||
const e2eDir = join(testDir, 'e2e');
|
||||
if (existsSync(e2eDir)) {
|
||||
const e2e = scanDir(e2eDir, ['.ts', '.spec.ts'], true);
|
||||
dirs.push({
|
||||
name: 'tests/e2e',
|
||||
type: 'e2e-tests',
|
||||
path: `Client/tauri-client/tests/e2e`,
|
||||
sourceFiles: 0,
|
||||
sourceLines: 0,
|
||||
testFiles: e2e.fileCount,
|
||||
testLines: e2e.lineCount,
|
||||
});
|
||||
}
|
||||
}
|
||||
|
||||
return dirs;
|
||||
}
|
||||
|
||||
function scanRustFiles(rustDir) {
|
||||
if (!existsSync(rustDir)) return [];
|
||||
const source = scanDir(rustDir, ['.rs'], true);
|
||||
const testCount = (() => {
|
||||
let count = 0;
|
||||
function walk(d) {
|
||||
try {
|
||||
for (const entry of readdirSync(d, { withFileTypes: true })) {
|
||||
const full = join(d, entry.name);
|
||||
if (entry.isDirectory()) walk(full);
|
||||
else if (entry.name.endsWith('_test.rs') || entry.name === 'tests.rs') count++;
|
||||
else if (entry.name.endsWith('.rs')) {
|
||||
// Check for #[cfg(test)] inside the file
|
||||
try {
|
||||
const content = readFileSync(full, 'utf8');
|
||||
if (content.includes('#[cfg(test)]')) count++;
|
||||
} catch { /* skip */ }
|
||||
}
|
||||
}
|
||||
} catch { /* skip */ }
|
||||
}
|
||||
walk(rustDir);
|
||||
return count;
|
||||
})();
|
||||
|
||||
return [{
|
||||
name: 'tauri-rust',
|
||||
type: 'rust',
|
||||
path: 'Client/tauri-client/src-tauri/src',
|
||||
sourceFiles: source.fileCount,
|
||||
sourceLines: source.lineCount,
|
||||
testFiles: testCount,
|
||||
testLines: 0,
|
||||
}];
|
||||
}
|
||||
|
||||
export async function scanModules(root) {
|
||||
const serverDir = resolve(root, 'Server');
|
||||
const clientSrcDir = resolve(root, 'Client/tauri-client/src');
|
||||
const rustDir = resolve(root, 'Client/tauri-client/src-tauri/src');
|
||||
|
||||
const goPackages = scanGoPackages(serverDir);
|
||||
const tsDirectories = scanTSDirectories(clientSrcDir);
|
||||
const rustFiles = scanRustFiles(rustDir);
|
||||
|
||||
return {
|
||||
go: goPackages,
|
||||
typescript: tsDirectories,
|
||||
rust: rustFiles,
|
||||
summary: {
|
||||
goPackages: goPackages.length,
|
||||
goSourceFiles: goPackages.reduce((s, p) => s + p.sourceFiles, 0),
|
||||
goTestFiles: goPackages.reduce((s, p) => s + p.testFiles, 0),
|
||||
tsSourceFiles: tsDirectories.filter(d => d.type === 'typescript').reduce((s, d) => s + d.sourceFiles, 0),
|
||||
tsTestFiles: tsDirectories.filter(d => d.type !== 'typescript').reduce((s, d) => s + d.testFiles, 0),
|
||||
rustSourceFiles: rustFiles.reduce((s, r) => s + r.sourceFiles, 0),
|
||||
rustTestFiles: rustFiles.reduce((s, r) => s + r.testFiles, 0),
|
||||
},
|
||||
};
|
||||
}
|
||||
@@ -1,607 +0,0 @@
|
||||
/**
|
||||
* Session manager — consolidates session planning, tracking, and vault writing.
|
||||
*
|
||||
* Manages the full session lifecycle: plan → start → poll → end, with
|
||||
* automatic vault integration (session logs, task file updates).
|
||||
*
|
||||
* Zero external dependencies — Node built-ins only.
|
||||
*/
|
||||
import { execFileSync } from 'node:child_process';
|
||||
import { readFileSync, writeFileSync, existsSync, mkdirSync, renameSync, unlinkSync, readdirSync } from 'node:fs';
|
||||
import { resolve, join } from 'node:path';
|
||||
|
||||
import { generateSuggestions } from './suggestion-engine.mjs';
|
||||
import { parseSessionHistory } from './session-parser.mjs';
|
||||
import { parseBacklog } from './backlog-parser.mjs';
|
||||
|
||||
// ---------------------------------------------------------------------------
|
||||
// Constants
|
||||
// ---------------------------------------------------------------------------
|
||||
|
||||
const SESSION_STATE_FILE = 'session-state.json';
|
||||
const STALE_THRESHOLD_MS = 30 * 60 * 1000; // 30 minutes
|
||||
const TASK_ID_REGEX = /\b(?:fix|close|resolve|implement|complete)\s+T-(\d+)/gi;
|
||||
const SHA_RE = /^[0-9a-f]{40}$/i;
|
||||
|
||||
function validateSha(sha) {
|
||||
if (!SHA_RE.test(sha)) throw new Error(`Invalid git SHA: "${sha}"`);
|
||||
return sha;
|
||||
}
|
||||
|
||||
// ---------------------------------------------------------------------------
|
||||
// Git helpers
|
||||
// ---------------------------------------------------------------------------
|
||||
|
||||
function git(args, root) {
|
||||
return execFileSync('git', args, {
|
||||
cwd: root,
|
||||
encoding: 'utf8',
|
||||
maxBuffer: 10 * 1024 * 1024,
|
||||
stdio: ['pipe', 'pipe', 'pipe'],
|
||||
}).trim();
|
||||
}
|
||||
|
||||
function getHeadSha(root) {
|
||||
return git(['rev-parse', 'HEAD'], root);
|
||||
}
|
||||
|
||||
// ---------------------------------------------------------------------------
|
||||
// File path to module mapping (mirrors git-scanner.mjs logic)
|
||||
// ---------------------------------------------------------------------------
|
||||
|
||||
function fileToModule(filePath) {
|
||||
const normalized = filePath.replace(/\\/g, '/');
|
||||
|
||||
if (normalized.startsWith('Server/')) {
|
||||
const parts = normalized.split('/');
|
||||
// parts[1] is a subdirectory only when there are 3+ segments
|
||||
// e.g. Server/ws/handler.go → 'ws', Server/main.go → 'server-root'
|
||||
return parts.length >= 3 ? parts[1] : 'server-root';
|
||||
}
|
||||
|
||||
if (normalized.startsWith('Client/tauri-client/src-tauri/src/')) {
|
||||
return 'tauri-rust';
|
||||
}
|
||||
|
||||
if (normalized.startsWith('Client/tauri-client/src/')) {
|
||||
const area = normalized.replace('Client/tauri-client/src/', '').split('/')[0];
|
||||
return area || 'client-root';
|
||||
}
|
||||
|
||||
if (normalized.startsWith('Client/tauri-client/')) {
|
||||
return 'client-config';
|
||||
}
|
||||
|
||||
return 'root';
|
||||
}
|
||||
|
||||
// ---------------------------------------------------------------------------
|
||||
// Session state I/O
|
||||
// ---------------------------------------------------------------------------
|
||||
|
||||
function stateFilePath(cacheDir) {
|
||||
return resolve(cacheDir, SESSION_STATE_FILE);
|
||||
}
|
||||
|
||||
function readSessionState(cacheDir) {
|
||||
const fp = stateFilePath(cacheDir);
|
||||
if (!existsSync(fp)) return null;
|
||||
|
||||
try {
|
||||
return JSON.parse(readFileSync(fp, 'utf8'));
|
||||
} catch {
|
||||
console.warn(' [Session] Corrupt session-state.json — renaming and treating as inactive');
|
||||
try {
|
||||
const corruptPath = `${fp}.corrupt.${Date.now()}`;
|
||||
renameSync(fp, corruptPath);
|
||||
} catch { /* best effort */ }
|
||||
return null;
|
||||
}
|
||||
}
|
||||
|
||||
function writeSessionState(cacheDir, state) {
|
||||
if (!existsSync(cacheDir)) {
|
||||
mkdirSync(cacheDir, { recursive: true });
|
||||
}
|
||||
writeFileSync(stateFilePath(cacheDir), JSON.stringify(state, null, 2));
|
||||
}
|
||||
|
||||
// ---------------------------------------------------------------------------
|
||||
// Safe vault write — temp file → validate → atomic rename → rollback copy
|
||||
// ---------------------------------------------------------------------------
|
||||
|
||||
function safeWriteFile(targetPath, content) {
|
||||
const dir = resolve(targetPath, '..');
|
||||
if (!existsSync(dir)) {
|
||||
mkdirSync(dir, { recursive: true });
|
||||
}
|
||||
|
||||
const tmpPath = targetPath + '.tmp';
|
||||
const backupPath = targetPath + '.bak';
|
||||
|
||||
// Write to temp file
|
||||
writeFileSync(tmpPath, content, 'utf8');
|
||||
|
||||
// Validate: temp file content must match what was written
|
||||
const written = readFileSync(tmpPath, 'utf8');
|
||||
if (written !== content) {
|
||||
unlinkSync(tmpPath);
|
||||
throw new Error(`Safe write validation failed: content mismatch at ${tmpPath}`);
|
||||
}
|
||||
|
||||
// Keep one rollback copy of existing file
|
||||
if (existsSync(targetPath)) {
|
||||
try {
|
||||
if (existsSync(backupPath)) unlinkSync(backupPath);
|
||||
renameSync(targetPath, backupPath);
|
||||
} catch {
|
||||
// Non-fatal — proceed without backup
|
||||
}
|
||||
}
|
||||
|
||||
// Atomic rename
|
||||
renameSync(tmpPath, targetPath);
|
||||
}
|
||||
|
||||
// ---------------------------------------------------------------------------
|
||||
// Vault helpers
|
||||
// ---------------------------------------------------------------------------
|
||||
|
||||
function readVaultFile(filePath) {
|
||||
try {
|
||||
if (!existsSync(filePath)) return null;
|
||||
return readFileSync(filePath, 'utf8');
|
||||
} catch (err) {
|
||||
console.warn(` [Session] Failed to read vault file ${filePath}: ${err.message}`);
|
||||
return null;
|
||||
}
|
||||
}
|
||||
|
||||
function formatDuration(startIso) {
|
||||
const ms = Date.now() - new Date(startIso).getTime();
|
||||
const minutes = Math.floor(ms / 60000);
|
||||
const hours = Math.floor(minutes / 60);
|
||||
const mins = minutes % 60;
|
||||
if (hours > 0) return `${hours}h ${mins}m`;
|
||||
return `${mins}m`;
|
||||
}
|
||||
|
||||
function generateSessionLogPath(root, summary) {
|
||||
const sessionsDir = resolve(root, 'docs/brain/03-Sessions');
|
||||
const today = new Date().toISOString().slice(0, 10);
|
||||
const slug = summary
|
||||
.toLowerCase()
|
||||
.replace(/[^a-z0-9]+/g, '-')
|
||||
.replace(/^-|-$/g, '')
|
||||
.slice(0, 40);
|
||||
|
||||
let baseName = `${today}-${slug || 'session'}`;
|
||||
let filePath = join(sessionsDir, `${baseName}.md`);
|
||||
let counter = 1;
|
||||
|
||||
while (existsSync(filePath)) {
|
||||
filePath = join(sessionsDir, `${baseName}-${counter}.md`);
|
||||
counter++;
|
||||
}
|
||||
|
||||
return filePath;
|
||||
}
|
||||
|
||||
function buildSessionLogContent(state, autoMarker = '') {
|
||||
const today = new Date().toISOString().slice(0, 10);
|
||||
const tasksCompleted = state.commits
|
||||
.flatMap(c => extractTaskIds(c))
|
||||
.filter((id, i, arr) => arr.indexOf(id) === i);
|
||||
|
||||
const modulesStr = state.modulesTouched.length > 0
|
||||
? state.modulesTouched.join(', ')
|
||||
: 'none';
|
||||
|
||||
const commitsList = state.commits.length > 0
|
||||
? state.commits.map(c => `- ${c}`).join('\n')
|
||||
: '- (no commits)';
|
||||
|
||||
const filesList = state.filesChanged.length > 0
|
||||
? state.filesChanged.slice(0, 20).map(f => `- ${f}`).join('\n')
|
||||
: '- (no files changed)';
|
||||
|
||||
const tasksTable = tasksCompleted.length > 0
|
||||
? tasksCompleted.map(id => `| ${id} | completed | Done |`).join('\n')
|
||||
: '| — | — | — |';
|
||||
|
||||
const marker = autoMarker ? ` ${autoMarker}` : '';
|
||||
|
||||
return `---
|
||||
date: ${today}
|
||||
summary: "Session${marker} — ${state.modulesTouched.slice(0, 3).join(', ') || 'general'}"
|
||||
tasks-completed: ${tasksCompleted.length}
|
||||
---
|
||||
|
||||
# Session — ${today}${marker}
|
||||
|
||||
## Goal
|
||||
|
||||
*Auto-generated session log from session manager*
|
||||
|
||||
## What Was Done
|
||||
|
||||
### Commits
|
||||
${commitsList}
|
||||
|
||||
### Files Changed (${state.filesChanged.length} total)
|
||||
${filesList}${state.filesChanged.length > 20 ? `\n- ...and ${state.filesChanged.length - 20} more` : ''}
|
||||
|
||||
### Modules Touched
|
||||
${modulesStr}
|
||||
|
||||
## Decisions Made
|
||||
|
||||
- *See commit messages for details*
|
||||
|
||||
## Blockers / Issues
|
||||
|
||||
-
|
||||
|
||||
## Next Steps
|
||||
|
||||
-
|
||||
|
||||
## Tasks Touched
|
||||
|
||||
| Task | Action | Status |
|
||||
| ---- | ------ | ------ |
|
||||
${tasksTable}
|
||||
`;
|
||||
}
|
||||
|
||||
// ---------------------------------------------------------------------------
|
||||
// Task ID extraction from commit messages
|
||||
// ---------------------------------------------------------------------------
|
||||
|
||||
function extractTaskIds(commitMessage) {
|
||||
const ids = [];
|
||||
let match;
|
||||
const regex = new RegExp(TASK_ID_REGEX.source, TASK_ID_REGEX.flags);
|
||||
while ((match = regex.exec(commitMessage)) !== null) {
|
||||
ids.push(`T-${match[1]}`);
|
||||
}
|
||||
return ids;
|
||||
}
|
||||
|
||||
// ---------------------------------------------------------------------------
|
||||
// Vault task file updates
|
||||
// ---------------------------------------------------------------------------
|
||||
|
||||
function updateVaultTasks(root, completedTaskIds, preloadedInProgressContent) {
|
||||
const inProgressPath = resolve(root, 'docs/brain/02-Tasks/In Progress.md');
|
||||
const donePath = resolve(root, 'docs/brain/02-Tasks/Done.md');
|
||||
const today = new Date().toISOString().slice(0, 10);
|
||||
const updated = [];
|
||||
|
||||
const inProgressContent = preloadedInProgressContent ?? readVaultFile(inProgressPath);
|
||||
const doneContent = readVaultFile(donePath);
|
||||
|
||||
if (!inProgressContent || !doneContent) {
|
||||
console.warn(' [Session] Cannot update vault tasks — file read failed');
|
||||
return updated;
|
||||
}
|
||||
|
||||
const idSet = new Set(completedTaskIds);
|
||||
const movedTasks = [];
|
||||
const remainingLines = [];
|
||||
|
||||
// Parse In Progress.md, extract completed tasks
|
||||
for (const line of inProgressContent.split('\n')) {
|
||||
const taskMatch = line.match(/^- \[ \] \*\*T-(\d+):\*\*\s*(.+)/);
|
||||
if (taskMatch && idSet.has(`T-${taskMatch[1]}`)) {
|
||||
movedTasks.push({
|
||||
id: `T-${taskMatch[1]}`,
|
||||
description: taskMatch[2].trim(),
|
||||
});
|
||||
} else {
|
||||
remainingLines.push(line);
|
||||
}
|
||||
}
|
||||
|
||||
if (movedTasks.length === 0) return updated;
|
||||
|
||||
// Write updated In Progress.md
|
||||
safeWriteFile(inProgressPath, remainingLines.join('\n'));
|
||||
|
||||
// Append to Done.md
|
||||
const doneEntries = movedTasks
|
||||
.map(t => `- [x] **${t.id}:** ${t.description} — completed ${today}`)
|
||||
.join('\n');
|
||||
|
||||
const sectionHeader = `\n## Session (${today})\n\n`;
|
||||
const insertionPoint = doneContent.indexOf('\n## ');
|
||||
let newDoneContent;
|
||||
|
||||
if (insertionPoint !== -1) {
|
||||
// Insert after the main heading, before the first section
|
||||
newDoneContent = doneContent.slice(0, insertionPoint) +
|
||||
sectionHeader + doneEntries + '\n' +
|
||||
doneContent.slice(insertionPoint);
|
||||
} else {
|
||||
newDoneContent = doneContent + sectionHeader + doneEntries + '\n';
|
||||
}
|
||||
|
||||
safeWriteFile(donePath, newDoneContent);
|
||||
|
||||
for (const t of movedTasks) {
|
||||
updated.push(t.id);
|
||||
}
|
||||
|
||||
return updated;
|
||||
}
|
||||
|
||||
// Exported for testing
|
||||
export { fileToModule };
|
||||
|
||||
// ---------------------------------------------------------------------------
|
||||
// Exported functions
|
||||
// ---------------------------------------------------------------------------
|
||||
|
||||
/**
|
||||
* Generate a session plan combining suggestions, last session, and backlog.
|
||||
*/
|
||||
export async function generatePlan(root, cacheDir) {
|
||||
// Gather data from existing engines
|
||||
const [sessionData, backlog] = await Promise.all([
|
||||
parseSessionHistory(root, cacheDir, true),
|
||||
parseBacklog(root),
|
||||
]);
|
||||
|
||||
const suggestions = await generateSuggestions(cacheDir, {
|
||||
backlog,
|
||||
sessionData,
|
||||
});
|
||||
|
||||
// Build greeting
|
||||
const last = sessionData.lastSession;
|
||||
const greeting = last.date
|
||||
? `Welcome back! Last session: ${last.date} — ${last.summary || 'no summary'}`
|
||||
: 'Welcome! This appears to be the first session.';
|
||||
|
||||
// Map suggestions to plan tasks
|
||||
const tasks = suggestions.suggestions.map((s, i) => {
|
||||
const topSignals = s.signals || [];
|
||||
const relatedFiles = topSignals
|
||||
.filter(sig => sig.signal === 'open-bug' || sig.signal === 'open-task')
|
||||
.map(sig => sig.value)
|
||||
.slice(0, 5);
|
||||
|
||||
const score = s.score || 0;
|
||||
let estimatedFocus = 'small';
|
||||
if (score > 100) estimatedFocus = 'large';
|
||||
else if (score > 40) estimatedFocus = 'medium';
|
||||
|
||||
return {
|
||||
priority: Math.min(i + 1, 5),
|
||||
title: `Focus on ${s.module}`,
|
||||
rationale: s.rationale,
|
||||
estimatedFocus,
|
||||
relatedFiles,
|
||||
module: s.module,
|
||||
};
|
||||
});
|
||||
|
||||
// In-progress tasks
|
||||
const inProgress = sessionData.inProgress.map(t => ({
|
||||
id: t.id,
|
||||
description: t.description,
|
||||
}));
|
||||
|
||||
return {
|
||||
greeting,
|
||||
tasks,
|
||||
lastSession: {
|
||||
date: last.date,
|
||||
summary: last.summary,
|
||||
tasksCompleted: last.tasksCompleted,
|
||||
},
|
||||
inProgress,
|
||||
};
|
||||
}
|
||||
|
||||
/**
|
||||
* Start a new session. Records HEAD SHA and creates session state.
|
||||
* Rejects if a session is already active.
|
||||
*/
|
||||
export function startSession(root, cacheDir) {
|
||||
const existing = readSessionState(cacheDir);
|
||||
if (existing && existing.active) {
|
||||
throw new Error(
|
||||
'Session already active (started at ' + existing.startedAt + '). ' +
|
||||
'End or recover it before starting a new one.'
|
||||
);
|
||||
}
|
||||
|
||||
const baselineSha = getHeadSha(root);
|
||||
const state = {
|
||||
active: true,
|
||||
startedAt: new Date().toISOString(),
|
||||
baselineSha,
|
||||
filesChanged: [],
|
||||
commits: [],
|
||||
modulesTouched: [],
|
||||
};
|
||||
|
||||
writeSessionState(cacheDir, state);
|
||||
return { ...state };
|
||||
}
|
||||
|
||||
/**
|
||||
* Get the current session status with live diff stats.
|
||||
*/
|
||||
export function getSessionStatus(cacheDir) {
|
||||
const state = readSessionState(cacheDir);
|
||||
if (!state || !state.active) {
|
||||
return { active: false };
|
||||
}
|
||||
|
||||
return { ...state };
|
||||
}
|
||||
|
||||
/**
|
||||
* Poll for changes since session baseline. Updates session state with
|
||||
* current file changes, commits, and modules touched.
|
||||
*/
|
||||
export function pollChanges(root, cacheDir) {
|
||||
const state = readSessionState(cacheDir);
|
||||
if (!state || !state.active) {
|
||||
return { active: false };
|
||||
}
|
||||
|
||||
let filesChanged = [];
|
||||
let newCommits = [];
|
||||
|
||||
try {
|
||||
const diffOutput = git(['diff', '--name-only', validateSha(state.baselineSha)], root);
|
||||
filesChanged = diffOutput ? diffOutput.split('\n').filter(Boolean) : [];
|
||||
} catch (err) {
|
||||
throw new Error(`Failed to get git diff: ${err.message}`);
|
||||
}
|
||||
|
||||
try {
|
||||
const logOutput = git(['log', '--oneline', `${validateSha(state.baselineSha)}..HEAD`], root);
|
||||
newCommits = logOutput ? logOutput.split('\n').filter(Boolean) : [];
|
||||
} catch (err) {
|
||||
throw new Error(`Failed to get git log: ${err.message}`);
|
||||
}
|
||||
|
||||
// Derive modules from changed files
|
||||
const moduleSet = new Set();
|
||||
for (const file of filesChanged) {
|
||||
moduleSet.add(fileToModule(file));
|
||||
}
|
||||
|
||||
const updatedState = {
|
||||
...state,
|
||||
filesChanged,
|
||||
commits: newCommits,
|
||||
modulesTouched: [...moduleSet],
|
||||
lastHeartbeat: new Date().toISOString(),
|
||||
};
|
||||
|
||||
writeSessionState(cacheDir, updatedState);
|
||||
return { ...updatedState };
|
||||
}
|
||||
|
||||
/**
|
||||
* End the current session. Generates a vault session log, updates task
|
||||
* files, and clears session state.
|
||||
*/
|
||||
export function endSession(root, cacheDir) {
|
||||
const state = readSessionState(cacheDir);
|
||||
if (!state || !state.active) {
|
||||
throw new Error('No active session to end.');
|
||||
}
|
||||
|
||||
// Final poll to capture latest changes
|
||||
const finalState = pollChanges(root, cacheDir);
|
||||
|
||||
// Generate session log
|
||||
const logContent = buildSessionLogContent(finalState);
|
||||
const logPath = generateSessionLogPath(
|
||||
root,
|
||||
finalState.modulesTouched.slice(0, 3).join('-') || 'session'
|
||||
);
|
||||
|
||||
safeWriteFile(logPath, logContent);
|
||||
|
||||
// Extract task IDs from commit messages and update vault
|
||||
const allTaskIds = finalState.commits
|
||||
.flatMap(c => extractTaskIds(c))
|
||||
.filter((id, i, arr) => arr.indexOf(id) === i);
|
||||
|
||||
let tasksUpdated = [];
|
||||
if (allTaskIds.length > 0) {
|
||||
// Verify task IDs exist in vault before updating
|
||||
const inProgressContent = readVaultFile(
|
||||
resolve(root, 'docs/brain/02-Tasks/In Progress.md')
|
||||
);
|
||||
if (inProgressContent) {
|
||||
const knownIds = allTaskIds.filter(id => inProgressContent.includes(id));
|
||||
const unknownIds = allTaskIds.filter(id => !inProgressContent.includes(id));
|
||||
|
||||
for (const uid of unknownIds) {
|
||||
console.warn(` [Session] Task ${uid} not found in In Progress — skipping`);
|
||||
}
|
||||
|
||||
if (knownIds.length > 0) {
|
||||
tasksUpdated = updateVaultTasks(root, knownIds, inProgressContent);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// Clear session state
|
||||
const closedState = {
|
||||
active: false,
|
||||
closedAt: new Date().toISOString(),
|
||||
startedAt: finalState.startedAt,
|
||||
baselineSha: finalState.baselineSha,
|
||||
};
|
||||
writeSessionState(cacheDir, closedState);
|
||||
|
||||
return {
|
||||
sessionLog: logPath,
|
||||
tasksUpdated,
|
||||
filesChanged: finalState.filesChanged.length,
|
||||
duration: formatDuration(finalState.startedAt),
|
||||
};
|
||||
}
|
||||
|
||||
/**
|
||||
* Recover a stale session on dashboard startup.
|
||||
* If session-state.json shows active=true but last git activity was
|
||||
* >30 minutes ago, auto-close it with a partial log.
|
||||
*/
|
||||
export function recoverStaleSession(root, cacheDir) {
|
||||
const state = readSessionState(cacheDir);
|
||||
if (!state || !state.active) {
|
||||
return { recovered: false };
|
||||
}
|
||||
|
||||
// Use session-specific timestamps: lastHeartbeat > startedAt
|
||||
// Do NOT use repo-wide git log — that reflects any commit, not this session's activity
|
||||
const lastActivityTime = new Date(state.lastHeartbeat || state.startedAt).getTime();
|
||||
|
||||
const elapsed = Date.now() - lastActivityTime;
|
||||
if (elapsed < STALE_THRESHOLD_MS) {
|
||||
return { recovered: false };
|
||||
}
|
||||
|
||||
// Auto-close the stale session
|
||||
let finalState;
|
||||
try {
|
||||
finalState = pollChanges(root, cacheDir);
|
||||
} catch {
|
||||
// If poll fails, use whatever state we have
|
||||
finalState = { ...state };
|
||||
}
|
||||
|
||||
const logContent = buildSessionLogContent(finalState, '[auto-closed]');
|
||||
const logPath = generateSessionLogPath(root, 'auto-closed');
|
||||
|
||||
try {
|
||||
safeWriteFile(logPath, logContent);
|
||||
} catch (err) {
|
||||
console.warn(` [Session] Failed to write auto-close log: ${err.message}`);
|
||||
}
|
||||
|
||||
// Clear session state
|
||||
const closedState = {
|
||||
active: false,
|
||||
closedAt: new Date().toISOString(),
|
||||
startedAt: state.startedAt,
|
||||
baselineSha: state.baselineSha,
|
||||
autoRecovered: true,
|
||||
};
|
||||
writeSessionState(cacheDir, closedState);
|
||||
|
||||
return {
|
||||
recovered: true,
|
||||
log: logPath,
|
||||
};
|
||||
}
|
||||
@@ -1,357 +0,0 @@
|
||||
/**
|
||||
* Session parser — reads session log files from docs/brain/03-Sessions/,
|
||||
* builds a timeline, tracks progress over time, calculates streaks,
|
||||
* and extracts last-session and task-status info.
|
||||
*/
|
||||
import { readFileSync, readdirSync, existsSync, mkdirSync, writeFileSync } from 'node:fs';
|
||||
import { resolve, join } from 'node:path';
|
||||
|
||||
// ---------------------------------------------------------------------------
|
||||
// Module keyword map — maps session content to touched modules
|
||||
// ---------------------------------------------------------------------------
|
||||
|
||||
const MODULE_KEYWORDS = {
|
||||
'admin': ['admin panel', 'admin api', 'admin'],
|
||||
'api': ['REST', 'endpoint', 'handler', 'middleware', 'api'],
|
||||
'auth': ['auth', '2FA', 'TOTP', 'login', 'register', 'password', 'session', 'token'],
|
||||
'db': ['database', 'SQLite', 'migration', 'schema', 'query', 'db'],
|
||||
'ws': ['websocket', 'hub', 'broadcast', 'ringbuffer', 'reconnect'],
|
||||
'voice': ['voice', 'audio', 'LiveKit', 'livekit', 'WebRTC', 'SFU', 'RTP', 'VAD'],
|
||||
'permissions': ['permission', 'role', 'RBAC'],
|
||||
'storage': ['upload', 'file storage', 'attachment'],
|
||||
'config': ['config', 'settings'],
|
||||
'lib': ['livekitSession', 'audioPipeline', 'dispatcher', 'tenor', 'ptt', 'notification', 'theme'],
|
||||
'stores': ['store', 'state management'],
|
||||
'components': ['component', 'sidebar', 'overlay', 'widget', 'picker', 'modal'],
|
||||
'pages': ['ConnectPage', 'MainPage', 'ChatArea', 'SidebarArea'],
|
||||
'tauri-rust': ['Rust', 'Tauri', 'tray', 'hotkey', 'credential', 'proxy', 'updater'],
|
||||
'protocol': ['protocol', 'message type', 'payload'],
|
||||
'e2e': ['E2E', 'Playwright', 'end-to-end'],
|
||||
'tests': ['test', 'coverage', 'vitest', 'unit test', 'integration test'],
|
||||
'docs': ['documentation', 'README', 'CLAUDE.md', 'spec', 'docs'],
|
||||
'security': ['security', 'XSS', 'CSRF', 'injection', 'audit', 'vulnerability'],
|
||||
'ci': ['CI', 'GitHub Actions', 'lint', 'golangci'],
|
||||
};
|
||||
|
||||
// ---------------------------------------------------------------------------
|
||||
// Frontmatter parser
|
||||
// ---------------------------------------------------------------------------
|
||||
|
||||
/**
|
||||
* Parse YAML-like frontmatter delimited by --- lines.
|
||||
* Returns { meta: { key: value }, body: string }.
|
||||
*/
|
||||
function parseFrontmatter(content) {
|
||||
const lines = content.split('\n').map(l => l.replace(/\r$/, ''));
|
||||
if (lines[0].trim() !== '---') {
|
||||
return { meta: {}, body: content };
|
||||
}
|
||||
|
||||
const meta = {};
|
||||
let endIdx = -1;
|
||||
|
||||
for (let i = 1; i < lines.length; i++) {
|
||||
if (lines[i].trim() === '---') {
|
||||
endIdx = i;
|
||||
break;
|
||||
}
|
||||
const colonIdx = lines[i].indexOf(':');
|
||||
if (colonIdx > 0) {
|
||||
const key = lines[i].slice(0, colonIdx).trim();
|
||||
let val = lines[i].slice(colonIdx + 1).trim();
|
||||
// Strip surrounding quotes
|
||||
if ((val.startsWith('"') && val.endsWith('"')) ||
|
||||
(val.startsWith("'") && val.endsWith("'"))) {
|
||||
val = val.slice(1, -1);
|
||||
}
|
||||
meta[key] = val;
|
||||
}
|
||||
}
|
||||
|
||||
if (endIdx === -1) {
|
||||
return { meta: {}, body: content };
|
||||
}
|
||||
|
||||
const body = lines.slice(endIdx + 1).join('\n');
|
||||
return { meta, body };
|
||||
}
|
||||
|
||||
// ---------------------------------------------------------------------------
|
||||
// Module detection from session body text
|
||||
// ---------------------------------------------------------------------------
|
||||
|
||||
function detectModules(body) {
|
||||
const lower = body.toLowerCase();
|
||||
const found = [];
|
||||
|
||||
for (const [mod, keywords] of Object.entries(MODULE_KEYWORDS)) {
|
||||
for (const kw of keywords) {
|
||||
if (lower.includes(kw.toLowerCase())) {
|
||||
found.push(mod);
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
return found.length > 0 ? found : ['general'];
|
||||
}
|
||||
|
||||
// ---------------------------------------------------------------------------
|
||||
// Task file parsers (Done.md, In Progress.md)
|
||||
// ---------------------------------------------------------------------------
|
||||
|
||||
function parseDoneFile(filePath) {
|
||||
if (!existsSync(filePath)) return [];
|
||||
|
||||
const content = readFileSync(filePath, 'utf8');
|
||||
const lines = content.split('\n').map(l => l.replace(/\r$/, ''));
|
||||
const tasks = [];
|
||||
let currentSection = '';
|
||||
|
||||
for (const line of lines) {
|
||||
if (line.startsWith('## ')) {
|
||||
currentSection = line.replace(/^##\s*/, '');
|
||||
}
|
||||
|
||||
// Match both formats:
|
||||
// - [x] **T-XXX:** description — completed YYYY-MM-DD
|
||||
// - [x] **T-XXX**: description — YYYY-MM-DD
|
||||
const match = line.match(
|
||||
/^- \[x\] \*\*T-(\d+)[:\*]*\*?\*?\s*(.+?)(?:\s*—\s*(?:completed\s+)?(\d{4}-\d{2}-\d{2}))?$/
|
||||
);
|
||||
if (match) {
|
||||
const id = `T-${match[1]}`;
|
||||
const description = match[2]
|
||||
.replace(/\s*—\s*(?:completed\s+)?\d{4}-\d{2}-\d{2}$/, '')
|
||||
.trim();
|
||||
// Date from the line itself, or try to extract from section header
|
||||
const date = match[3] || extractDateFromSection(currentSection) || '';
|
||||
tasks.push({ id, description, date });
|
||||
}
|
||||
}
|
||||
|
||||
return tasks;
|
||||
}
|
||||
|
||||
function extractDateFromSection(section) {
|
||||
const match = section.match(/\((\d{4}-\d{2}-\d{2})\)/);
|
||||
return match ? match[1] : null;
|
||||
}
|
||||
|
||||
function parseInProgressFile(filePath) {
|
||||
if (!existsSync(filePath)) return [];
|
||||
|
||||
const content = readFileSync(filePath, 'utf8');
|
||||
const lines = content.split('\n').map(l => l.replace(/\r$/, ''));
|
||||
const tasks = [];
|
||||
|
||||
for (const line of lines) {
|
||||
// Match: - [ ] **T-XXX:** description
|
||||
const match = line.match(/^- \[ \] \*\*T-(\d+):\*\*\s*(.+)/);
|
||||
if (match) {
|
||||
const id = `T-${match[1]}`;
|
||||
const description = match[2].trim();
|
||||
tasks.push({ id, description });
|
||||
}
|
||||
|
||||
// Also match lines without checkbox but with task ID
|
||||
const altMatch = line.match(/^\*\*T-(\d+):\*\*\s*(.+)/);
|
||||
if (!match && altMatch) {
|
||||
const id = `T-${altMatch[1]}`;
|
||||
const description = altMatch[2].trim();
|
||||
tasks.push({ id, description });
|
||||
}
|
||||
}
|
||||
|
||||
return tasks;
|
||||
}
|
||||
|
||||
// ---------------------------------------------------------------------------
|
||||
// Streak calculation
|
||||
// ---------------------------------------------------------------------------
|
||||
|
||||
function calculateStreaks(sortedDates) {
|
||||
if (sortedDates.length === 0) {
|
||||
return { current: 0, longest: 0, totalSessions: 0 };
|
||||
}
|
||||
|
||||
// Deduplicate dates (multiple sessions on same day count as 1)
|
||||
const uniqueDates = [...new Set(sortedDates)].sort();
|
||||
const totalSessions = sortedDates.length;
|
||||
|
||||
let longest = 1;
|
||||
let currentStreak = 1;
|
||||
let streakAtEnd = 1;
|
||||
|
||||
for (let i = 1; i < uniqueDates.length; i++) {
|
||||
const prev = new Date(uniqueDates[i - 1] + 'T00:00:00Z');
|
||||
const curr = new Date(uniqueDates[i] + 'T00:00:00Z');
|
||||
const diffMs = curr.getTime() - prev.getTime();
|
||||
const diffDays = Math.round(diffMs / (1000 * 60 * 60 * 24));
|
||||
|
||||
if (diffDays === 1) {
|
||||
currentStreak++;
|
||||
} else {
|
||||
currentStreak = 1;
|
||||
}
|
||||
|
||||
if (currentStreak > longest) {
|
||||
longest = currentStreak;
|
||||
}
|
||||
|
||||
streakAtEnd = currentStreak;
|
||||
}
|
||||
|
||||
// Check if the most recent session date is today or yesterday
|
||||
// to determine if the current streak is still "active"
|
||||
const lastDate = new Date(uniqueDates[uniqueDates.length - 1] + 'T00:00:00Z');
|
||||
const today = new Date();
|
||||
today.setUTCHours(0, 0, 0, 0);
|
||||
const daysSinceLast = Math.round((today.getTime() - lastDate.getTime()) / (1000 * 60 * 60 * 24));
|
||||
|
||||
const current = daysSinceLast <= 1 ? streakAtEnd : 0;
|
||||
|
||||
return { current, longest, totalSessions };
|
||||
}
|
||||
|
||||
// ---------------------------------------------------------------------------
|
||||
// Main export
|
||||
// ---------------------------------------------------------------------------
|
||||
|
||||
/**
|
||||
* Parse all session logs and task files, returning a structured timeline.
|
||||
*
|
||||
* @param {string} root - Repository root directory
|
||||
* @param {string} cacheDir - Directory to store cached results
|
||||
* @param {boolean} quick - If true and cache exists, return cached data
|
||||
* @returns {Promise<Object>} - Parsed session history
|
||||
*/
|
||||
export async function parseSessionHistory(root, cacheDir, quick) {
|
||||
const cachePath = join(cacheDir, 'session-data.json');
|
||||
|
||||
// Quick mode: return cached data if available
|
||||
if (quick && existsSync(cachePath)) {
|
||||
try {
|
||||
const cached = JSON.parse(readFileSync(cachePath, 'utf8'));
|
||||
console.log(' [Sessions] Returning cached session data');
|
||||
return cached;
|
||||
} catch {
|
||||
// Cache corrupt — fall through to fresh parse
|
||||
}
|
||||
}
|
||||
|
||||
const sessionsDir = resolve(root, 'docs/brain/03-Sessions');
|
||||
const donePath = resolve(root, 'docs/brain/02-Tasks/Done.md');
|
||||
const inProgressPath = resolve(root, 'docs/brain/02-Tasks/In Progress.md');
|
||||
|
||||
// -----------------------------------------------------------------------
|
||||
// 1. Parse all session files
|
||||
// -----------------------------------------------------------------------
|
||||
|
||||
const sessions = [];
|
||||
|
||||
if (existsSync(sessionsDir)) {
|
||||
const files = readdirSync(sessionsDir)
|
||||
.filter(f => f.endsWith('.md') && f !== 'index.md')
|
||||
.sort();
|
||||
|
||||
for (const fileName of files) {
|
||||
const filePath = join(sessionsDir, fileName);
|
||||
const content = readFileSync(filePath, 'utf8');
|
||||
const { meta, body } = parseFrontmatter(content);
|
||||
|
||||
const date = meta.date || fileName.slice(0, 10);
|
||||
const summary = meta.summary || '';
|
||||
const tasksCompleted = parseInt(meta['tasks-completed'] || '0', 10);
|
||||
const modulesTouched = detectModules(body);
|
||||
|
||||
sessions.push({
|
||||
date,
|
||||
summary,
|
||||
tasksCompleted,
|
||||
modulesTouched,
|
||||
fileName,
|
||||
});
|
||||
}
|
||||
}
|
||||
|
||||
// Sort by date ascending
|
||||
sessions.sort((a, b) => a.date.localeCompare(b.date));
|
||||
|
||||
console.log(` [Sessions] Parsed ${sessions.length} session files`);
|
||||
|
||||
// -----------------------------------------------------------------------
|
||||
// 2. Build progress over time (cumulative tasks completed)
|
||||
// -----------------------------------------------------------------------
|
||||
|
||||
const progressOverTime = [];
|
||||
let cumulative = 0;
|
||||
|
||||
for (const session of sessions) {
|
||||
cumulative += session.tasksCompleted;
|
||||
progressOverTime.push({
|
||||
date: session.date,
|
||||
cumulativeDone: cumulative,
|
||||
sessionDone: session.tasksCompleted,
|
||||
});
|
||||
}
|
||||
|
||||
// -----------------------------------------------------------------------
|
||||
// 3. Calculate streaks
|
||||
// -----------------------------------------------------------------------
|
||||
|
||||
const sessionDates = sessions.map(s => s.date);
|
||||
const streaks = calculateStreaks(sessionDates);
|
||||
|
||||
// -----------------------------------------------------------------------
|
||||
// 4. Extract last session info
|
||||
// -----------------------------------------------------------------------
|
||||
|
||||
const lastSessionRaw = sessions.length > 0 ? sessions[sessions.length - 1] : null;
|
||||
const lastSession = lastSessionRaw
|
||||
? {
|
||||
date: lastSessionRaw.date,
|
||||
summary: lastSessionRaw.summary,
|
||||
tasksCompleted: lastSessionRaw.tasksCompleted,
|
||||
modulesTouched: lastSessionRaw.modulesTouched,
|
||||
}
|
||||
: { date: '', summary: '', tasksCompleted: 0, modulesTouched: [] };
|
||||
|
||||
// -----------------------------------------------------------------------
|
||||
// 5. Parse task files
|
||||
// -----------------------------------------------------------------------
|
||||
|
||||
const allDone = parseDoneFile(donePath);
|
||||
// Last 10 completed tasks (file is ordered newest-first by section)
|
||||
const recentlyDone = allDone.slice(0, 10);
|
||||
|
||||
const inProgress = parseInProgressFile(inProgressPath);
|
||||
|
||||
console.log(` [Sessions] ${allDone.length} done tasks, ${inProgress.length} in-progress`);
|
||||
|
||||
// -----------------------------------------------------------------------
|
||||
// 6. Assemble result and cache
|
||||
// -----------------------------------------------------------------------
|
||||
|
||||
const result = {
|
||||
timestamp: new Date().toISOString(),
|
||||
sessions,
|
||||
progressOverTime,
|
||||
streaks,
|
||||
lastSession,
|
||||
inProgress,
|
||||
recentlyDone,
|
||||
};
|
||||
|
||||
// Write cache
|
||||
try {
|
||||
if (!existsSync(cacheDir)) {
|
||||
mkdirSync(cacheDir, { recursive: true });
|
||||
}
|
||||
writeFileSync(cachePath, JSON.stringify(result, null, 2));
|
||||
} catch (err) {
|
||||
console.warn(` [Sessions] Failed to write cache: ${err.message}`);
|
||||
}
|
||||
|
||||
return result;
|
||||
}
|
||||
@@ -1,238 +0,0 @@
|
||||
/**
|
||||
* Smart suggestion engine.
|
||||
* Combines all signals (coverage, bugs, churn, staleness, coupling, debt, recent work)
|
||||
* into ranked "Focus Next" recommendations.
|
||||
*/
|
||||
import { readFileSync, writeFileSync, existsSync } from 'node:fs';
|
||||
import { resolve } from 'node:path';
|
||||
|
||||
const CACHE_FILE = 'suggestions.json';
|
||||
const PREFS_FILE = 'user-prefs.json';
|
||||
|
||||
// Signal weights (tunable)
|
||||
const WEIGHTS = {
|
||||
coverageGap: 2.0, // per % below 80
|
||||
openBugs: 15, // per bug
|
||||
codeReviewFixes: 10, // per fix
|
||||
openTasks: 3, // per task
|
||||
highChurn: 1.5, // per commit in last 30d
|
||||
staleness: 0.5, // per day since last commit
|
||||
coupling: 2.0, // per coupling score point
|
||||
debtMarkers: 1.0, // per TODO/FIXME/HACK
|
||||
largeFiles: 5, // per large file
|
||||
longFunctions: 3, // per long function
|
||||
recentWorkCooldown: -20, // penalty if worked on in last 2 sessions
|
||||
};
|
||||
|
||||
function loadPrefs(cacheDir) {
|
||||
const prefsFile = resolve(cacheDir, PREFS_FILE);
|
||||
if (existsSync(prefsFile)) {
|
||||
try { return JSON.parse(readFileSync(prefsFile, 'utf8')); } catch { /* skip */ }
|
||||
}
|
||||
return { recentlyWorked: [], strategy: 'balanced' };
|
||||
}
|
||||
|
||||
function savePrefs(cacheDir, prefs) {
|
||||
try {
|
||||
writeFileSync(resolve(cacheDir, PREFS_FILE), JSON.stringify(prefs, null, 2));
|
||||
} catch { /* non-fatal — prefs write failure should not crash the server */ }
|
||||
}
|
||||
|
||||
export function markWorkedOn(cacheDir, moduleName) {
|
||||
const prefs = loadPrefs(cacheDir);
|
||||
prefs.recentlyWorked = [moduleName, ...prefs.recentlyWorked.filter(m => m !== moduleName)].slice(0, 5);
|
||||
savePrefs(cacheDir, prefs);
|
||||
}
|
||||
|
||||
export function setStrategy(cacheDir, strategy) {
|
||||
const prefs = loadPrefs(cacheDir);
|
||||
prefs.strategy = strategy;
|
||||
savePrefs(cacheDir, prefs);
|
||||
}
|
||||
|
||||
export async function generateSuggestions(cacheDir, {
|
||||
priorities = [],
|
||||
goCoverage = {},
|
||||
vitestCoverage = {},
|
||||
backlog = {},
|
||||
gitData = null,
|
||||
debtData = null,
|
||||
importGraph = null,
|
||||
sessionData = null,
|
||||
} = {}) {
|
||||
const prefs = loadPrefs(cacheDir);
|
||||
const strategy = prefs.strategy || 'balanced';
|
||||
const recentlyWorked = new Set(prefs.recentlyWorked || []);
|
||||
|
||||
// Strategy multipliers
|
||||
const strategyMult = {
|
||||
balanced: { coverage: 1, bugs: 1, momentum: 1, debt: 1 },
|
||||
'bugs-first': { coverage: 0.5, bugs: 2.5, momentum: 0.5, debt: 0.5 },
|
||||
'coverage-first': { coverage: 2.5, bugs: 0.5, momentum: 0.5, debt: 0.5 },
|
||||
'momentum-first': { coverage: 0.5, bugs: 0.5, momentum: 2.5, debt: 0.5 },
|
||||
'debt-first': { coverage: 0.5, bugs: 0.5, momentum: 0.5, debt: 2.5 },
|
||||
};
|
||||
const mult = strategyMult[strategy] || strategyMult.balanced;
|
||||
|
||||
// Build per-module signal aggregation
|
||||
const moduleSignals = {};
|
||||
|
||||
function ensureModule(name) {
|
||||
if (!moduleSignals[name]) {
|
||||
moduleSignals[name] = {
|
||||
name,
|
||||
signals: [],
|
||||
score: 0,
|
||||
coverageScore: 0,
|
||||
bugScore: 0,
|
||||
momentumScore: 0,
|
||||
debtScore: 0,
|
||||
};
|
||||
}
|
||||
return moduleSignals[name];
|
||||
}
|
||||
|
||||
// 1. Coverage gaps (from priorities which already have this data)
|
||||
for (const p of priorities) {
|
||||
const m = ensureModule(p.name);
|
||||
if (p.coverage !== null && p.coverage < 80) {
|
||||
const gap = 80 - p.coverage;
|
||||
const pts = gap * WEIGHTS.coverageGap * mult.coverage;
|
||||
m.coverageScore += pts;
|
||||
m.signals.push({ signal: 'coverage-gap', value: `${p.coverage.toFixed(1)}% (${gap.toFixed(0)}% below target)`, points: pts });
|
||||
} else if (p.coverage === null && p.type !== 'feature-area') {
|
||||
const pts = 80 * WEIGHTS.coverageGap * 0.5 * mult.coverage; // unknown coverage = assume 50% gap
|
||||
m.coverageScore += pts;
|
||||
m.signals.push({ signal: 'no-coverage-data', value: 'No test coverage', points: pts });
|
||||
}
|
||||
}
|
||||
|
||||
// 2. Open bugs and tasks
|
||||
for (const [phase, tasks] of Object.entries(backlog.byPhase || {})) {
|
||||
for (const task of tasks) {
|
||||
for (const mod of task.modules) {
|
||||
const m = ensureModule(mod);
|
||||
if (phase === 'bug') {
|
||||
const pts = WEIGHTS.openBugs * mult.bugs;
|
||||
m.bugScore += pts;
|
||||
m.signals.push({ signal: 'open-bug', value: `${task.id}: ${task.description.slice(0, 60)}`, points: pts });
|
||||
} else if (phase === 'code-review') {
|
||||
const pts = WEIGHTS.codeReviewFixes * mult.bugs;
|
||||
m.bugScore += pts;
|
||||
m.signals.push({ signal: 'code-review-fix', value: `${task.id}: ${task.description.slice(0, 60)}`, points: pts });
|
||||
} else {
|
||||
const pts = WEIGHTS.openTasks * mult.momentum;
|
||||
m.momentumScore += pts;
|
||||
m.signals.push({ signal: 'open-task', value: `${task.id}: ${task.description.slice(0, 60)}`, points: pts });
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// 3. Git signals (churn, staleness)
|
||||
if (gitData) {
|
||||
for (const [mod, data] of Object.entries(gitData.commitsByModule || {})) {
|
||||
const m = ensureModule(mod);
|
||||
// High churn = needs attention
|
||||
if (data.count > 10) {
|
||||
const pts = (data.count - 10) * WEIGHTS.highChurn * mult.momentum;
|
||||
m.momentumScore += pts;
|
||||
m.signals.push({ signal: 'high-churn', value: `${data.count} commits in 30d`, points: pts });
|
||||
}
|
||||
}
|
||||
|
||||
for (const [mod, data] of Object.entries(gitData.staleness || {})) {
|
||||
const m = ensureModule(mod);
|
||||
if (data.daysSinceLastCommit > 14) {
|
||||
const pts = data.daysSinceLastCommit * WEIGHTS.staleness * mult.momentum;
|
||||
m.momentumScore += pts;
|
||||
m.signals.push({ signal: 'stale', value: `${data.daysSinceLastCommit} days since last commit`, points: pts });
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// 4. Debt signals
|
||||
if (debtData) {
|
||||
for (const [mod, data] of Object.entries(debtData.summary?.byModule || {})) {
|
||||
const m = ensureModule(mod);
|
||||
if (data.markers > 0) {
|
||||
const pts = data.markers * WEIGHTS.debtMarkers * mult.debt;
|
||||
m.debtScore += pts;
|
||||
m.signals.push({ signal: 'debt-markers', value: `${data.markers} TODO/FIXME/HACK`, points: pts });
|
||||
}
|
||||
if (data.largeFiles > 0) {
|
||||
const pts = data.largeFiles * WEIGHTS.largeFiles * mult.debt;
|
||||
m.debtScore += pts;
|
||||
m.signals.push({ signal: 'large-files', value: `${data.largeFiles} oversized file(s)`, points: pts });
|
||||
}
|
||||
if (data.longFunctions > 0) {
|
||||
const pts = data.longFunctions * WEIGHTS.longFunctions * mult.debt;
|
||||
m.debtScore += pts;
|
||||
m.signals.push({ signal: 'long-functions', value: `${data.longFunctions} long function(s)`, points: pts });
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// 5. Coupling signals
|
||||
if (importGraph) {
|
||||
for (const node of importGraph.nodes || []) {
|
||||
const m = ensureModule(node.name);
|
||||
if (node.coupling > 10) {
|
||||
const pts = node.coupling * WEIGHTS.coupling * mult.debt;
|
||||
m.debtScore += pts;
|
||||
m.signals.push({ signal: 'high-coupling', value: `Coupling score ${node.coupling} (fan-in ${node.fanIn}, fan-out ${node.fanOut})`, points: pts });
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// 6. Recent work cooldown
|
||||
for (const [name, m] of Object.entries(moduleSignals)) {
|
||||
if (recentlyWorked.has(name)) {
|
||||
const pts = WEIGHTS.recentWorkCooldown;
|
||||
m.momentumScore += pts;
|
||||
m.signals.push({ signal: 'recently-worked', value: 'Worked on recently — cooling down', points: pts });
|
||||
}
|
||||
}
|
||||
|
||||
// Compute total scores
|
||||
for (const m of Object.values(moduleSignals)) {
|
||||
m.score = m.coverageScore + m.bugScore + m.momentumScore + m.debtScore;
|
||||
}
|
||||
|
||||
// Sort and take top suggestions
|
||||
const sorted = Object.values(moduleSignals)
|
||||
.filter(m => m.score > 0)
|
||||
.sort((a, b) => b.score - a.score);
|
||||
|
||||
const suggestions = sorted.slice(0, 10).map((m, i) => {
|
||||
// Build a human-readable rationale from top 3 signals
|
||||
const topSignals = [...m.signals].sort((a, b) => b.points - a.points).slice(0, 3);
|
||||
const rationale = topSignals.map(s => s.value).join('; ');
|
||||
|
||||
return {
|
||||
rank: i + 1,
|
||||
module: m.name,
|
||||
score: Math.round(m.score),
|
||||
rationale,
|
||||
breakdown: {
|
||||
coverage: Math.round(m.coverageScore),
|
||||
bugs: Math.round(m.bugScore),
|
||||
momentum: Math.round(m.momentumScore),
|
||||
debt: Math.round(m.debtScore),
|
||||
},
|
||||
signals: m.signals,
|
||||
};
|
||||
});
|
||||
|
||||
const result = {
|
||||
timestamp: new Date().toISOString(),
|
||||
strategy,
|
||||
suggestions,
|
||||
recentlyWorked: [...recentlyWorked],
|
||||
};
|
||||
|
||||
try {
|
||||
writeFileSync(resolve(cacheDir, CACHE_FILE), JSON.stringify(result, null, 2));
|
||||
} catch { /* non-fatal */ }
|
||||
return result;
|
||||
}
|
||||
@@ -1,103 +0,0 @@
|
||||
/**
|
||||
* Terminal summary — prints a color-coded overview to stdout.
|
||||
*/
|
||||
|
||||
const RESET = '\x1b[0m';
|
||||
const BOLD = '\x1b[1m';
|
||||
const DIM = '\x1b[2m';
|
||||
const RED = '\x1b[31m';
|
||||
const GREEN = '\x1b[32m';
|
||||
const YELLOW = '\x1b[33m';
|
||||
const CYAN = '\x1b[36m';
|
||||
const WHITE = '\x1b[37m';
|
||||
|
||||
function covColor(pct) {
|
||||
if (pct === null || pct === undefined) return RED;
|
||||
if (pct >= 80) return GREEN;
|
||||
if (pct >= 60) return YELLOW;
|
||||
return RED;
|
||||
}
|
||||
|
||||
function bar(pct, width = 20) {
|
||||
if (pct === null || pct === undefined) return `${RED}${'░'.repeat(width)}${RESET} ---`;
|
||||
const filled = Math.round((pct / 100) * width);
|
||||
const empty = width - filled;
|
||||
const color = covColor(pct);
|
||||
return `${color}${'█'.repeat(filled)}${'░'.repeat(empty)}${RESET} ${pct.toFixed(1)}%`;
|
||||
}
|
||||
|
||||
function divider(title) {
|
||||
const line = '─'.repeat(60);
|
||||
return `\n ${CYAN}${BOLD}${title}${RESET}\n ${DIM}${line}${RESET}`;
|
||||
}
|
||||
|
||||
export function printTerminalSummary(modules, goCoverage, vitestCoverage, backlog, priorities) {
|
||||
console.log(divider('PROJECT OVERVIEW'));
|
||||
|
||||
const total = backlog.openCount + backlog.doneCount;
|
||||
const pct = total > 0 ? ((backlog.doneCount / total) * 100).toFixed(1) : '0.0';
|
||||
console.log(` ${WHITE}Tasks: ${GREEN}${backlog.doneCount} done${RESET} / ${YELLOW}${backlog.openCount} open${RESET} (${pct}% complete)`);
|
||||
console.log(` ${WHITE}Files: ${modules.summary.goSourceFiles} Go + ${modules.summary.tsSourceFiles} TS + ${modules.summary.rustSourceFiles} Rust${RESET}`);
|
||||
console.log(` ${WHITE}Tests: ${modules.summary.goTestFiles} Go + ${modules.summary.tsTestFiles} TS + ${modules.summary.rustTestFiles} Rust${RESET}`);
|
||||
|
||||
// Go coverage
|
||||
console.log(divider('SERVER (GO) COVERAGE'));
|
||||
for (const pkg of modules.go) {
|
||||
const covData = goCoverage.packages?.[pkg.name];
|
||||
const cov = covData?.percentage ?? null;
|
||||
const name = `${pkg.name}/`.padEnd(16);
|
||||
const failed = covData?.failed ? ` ${RED}FAIL${RESET}` : '';
|
||||
console.log(` ${WHITE}${name}${RESET} ${bar(cov)}${failed}`);
|
||||
}
|
||||
|
||||
// TS coverage
|
||||
console.log(divider('CLIENT (TYPESCRIPT) COVERAGE'));
|
||||
const tsAreas = vitestCoverage.areas || {};
|
||||
const totalCov = tsAreas._total;
|
||||
if (totalCov) {
|
||||
console.log(` ${WHITE}${'Overall'.padEnd(16)}${RESET} ${bar(totalCov.statements)}`);
|
||||
}
|
||||
for (const dir of modules.typescript.filter(d => d.type === 'typescript')) {
|
||||
const areaCov = tsAreas[dir.name];
|
||||
const cov = areaCov?.statements ?? null;
|
||||
const name = `${dir.name}/`.padEnd(16);
|
||||
console.log(` ${WHITE}${name}${RESET} ${bar(cov)}`);
|
||||
}
|
||||
|
||||
// Rust
|
||||
console.log(divider('CLIENT (RUST) STATUS'));
|
||||
for (const rust of modules.rust) {
|
||||
console.log(` ${WHITE}${rust.sourceFiles} files, ${rust.sourceLines} lines${RESET} — ${RED}No test infrastructure${RESET}`);
|
||||
}
|
||||
|
||||
// Where to work next
|
||||
console.log(divider('WHERE TO WORK NEXT (TOP 5)'));
|
||||
const top5 = priorities.slice(0, 5);
|
||||
top5.forEach((p, i) => {
|
||||
const num = `${i + 1}.`.padEnd(3);
|
||||
const name = p.name.padEnd(16);
|
||||
const cov = p.coverage !== null ? `${p.coverage.toFixed(0)}%`.padEnd(5) : '--- ';
|
||||
const tasks = p.openTaskCount > 0 ? `${YELLOW}${p.openTaskCount} task(s)${RESET}` : `${GREEN}0 tasks${RESET}`;
|
||||
console.log(` ${CYAN}${num}${RESET} ${BOLD}${name}${RESET} ${covColor(p.coverage)}${cov}${RESET} ${tasks} — ${DIM}${p.recommendation}${RESET}`);
|
||||
});
|
||||
|
||||
// Open bugs
|
||||
const bugs = backlog.byPhase['bug'] || [];
|
||||
if (bugs.length > 0) {
|
||||
console.log(divider('OPEN BUGS'));
|
||||
for (const bug of bugs) {
|
||||
console.log(` ${RED}${bug.id}${RESET}: ${bug.description}`);
|
||||
}
|
||||
}
|
||||
|
||||
// Code review items
|
||||
const reviews = backlog.byPhase['code-review'] || [];
|
||||
if (reviews.length > 0) {
|
||||
console.log(divider('CODE REVIEW FIXES'));
|
||||
for (const r of reviews) {
|
||||
console.log(` ${YELLOW}${r.id}${RESET}: ${r.description}`);
|
||||
}
|
||||
}
|
||||
|
||||
console.log(`\n ${DIM}Full report: docs/brain/00-Overview/Project-Map.md${RESET}\n`);
|
||||
}
|
||||
@@ -1,216 +0,0 @@
|
||||
/**
|
||||
* Vitest coverage collector.
|
||||
* Runs vitest with coverage and parses the Istanbul coverage-final.json.
|
||||
* Caches results to .cache/vitest-coverage.json.
|
||||
*/
|
||||
import { execFileSync } from 'node:child_process';
|
||||
import { readFileSync, writeFileSync, existsSync, statSync } from 'node:fs';
|
||||
import { resolve } from 'node:path';
|
||||
|
||||
// Coverage data older than this is considered stale and gets a warning flag
|
||||
const FRESHNESS_MAX_AGE_MS = 24 * 60 * 60 * 1000; // 24 hours
|
||||
|
||||
const CACHE_FILE = 'vitest-coverage.json';
|
||||
|
||||
function computeFileCoverage(fileData) {
|
||||
const s = fileData.s || {};
|
||||
const b = fileData.b || {};
|
||||
const f = fileData.f || {};
|
||||
|
||||
const stmtTotal = Object.keys(s).length;
|
||||
const stmtCovered = Object.values(s).filter(v => v > 0).length;
|
||||
|
||||
let branchTotal = 0;
|
||||
let branchCovered = 0;
|
||||
for (const branches of Object.values(b)) {
|
||||
for (const count of branches) {
|
||||
branchTotal++;
|
||||
if (count > 0) branchCovered++;
|
||||
}
|
||||
}
|
||||
|
||||
const fnTotal = Object.keys(f).length;
|
||||
const fnCovered = Object.values(f).filter(v => v > 0).length;
|
||||
|
||||
return {
|
||||
statements: stmtTotal > 0 ? (stmtCovered / stmtTotal) * 100 : 100,
|
||||
branches: branchTotal > 0 ? (branchCovered / branchTotal) * 100 : 100,
|
||||
functions: fnTotal > 0 ? (fnCovered / fnTotal) * 100 : 100,
|
||||
stmtTotal,
|
||||
stmtCovered,
|
||||
branchTotal,
|
||||
branchCovered,
|
||||
fnTotal,
|
||||
fnCovered,
|
||||
};
|
||||
}
|
||||
|
||||
function parseCoverageFinal(coverageJsonPath) {
|
||||
if (!existsSync(coverageJsonPath)) return {};
|
||||
|
||||
const raw = JSON.parse(readFileSync(coverageJsonPath, 'utf8'));
|
||||
const byArea = {};
|
||||
let totalStmt = 0, totalStmtCov = 0;
|
||||
let totalBranch = 0, totalBranchCov = 0;
|
||||
let totalFn = 0, totalFnCov = 0;
|
||||
|
||||
for (const [filePath, fileData] of Object.entries(raw)) {
|
||||
const normalized = filePath.replace(/\\/g, '/');
|
||||
const srcMatch = normalized.match(/src\/(\w+)\//);
|
||||
const area = srcMatch ? srcMatch[1] : 'other';
|
||||
|
||||
const cov = computeFileCoverage(fileData);
|
||||
|
||||
if (!byArea[area]) {
|
||||
byArea[area] = {
|
||||
files: 0,
|
||||
stmtTotal: 0, stmtCovered: 0,
|
||||
branchTotal: 0, branchCovered: 0,
|
||||
fnTotal: 0, fnCovered: 0,
|
||||
};
|
||||
}
|
||||
|
||||
byArea[area].files++;
|
||||
byArea[area].stmtTotal += cov.stmtTotal;
|
||||
byArea[area].stmtCovered += cov.stmtCovered;
|
||||
byArea[area].branchTotal += cov.branchTotal;
|
||||
byArea[area].branchCovered += cov.branchCovered;
|
||||
byArea[area].fnTotal += cov.fnTotal;
|
||||
byArea[area].fnCovered += cov.fnCovered;
|
||||
|
||||
totalStmt += cov.stmtTotal;
|
||||
totalStmtCov += cov.stmtCovered;
|
||||
totalBranch += cov.branchTotal;
|
||||
totalBranchCov += cov.branchCovered;
|
||||
totalFn += cov.fnTotal;
|
||||
totalFnCov += cov.fnCovered;
|
||||
}
|
||||
|
||||
// Compute percentages
|
||||
const result = {};
|
||||
for (const [area, data] of Object.entries(byArea)) {
|
||||
result[area] = {
|
||||
files: data.files,
|
||||
statements: data.stmtTotal > 0 ? (data.stmtCovered / data.stmtTotal) * 100 : 100,
|
||||
branches: data.branchTotal > 0 ? (data.branchCovered / data.branchTotal) * 100 : 100,
|
||||
functions: data.fnTotal > 0 ? (data.fnCovered / data.fnTotal) * 100 : 100,
|
||||
};
|
||||
}
|
||||
|
||||
result._total = {
|
||||
statements: totalStmt > 0 ? (totalStmtCov / totalStmt) * 100 : 0,
|
||||
branches: totalBranch > 0 ? (totalBranchCov / totalBranch) * 100 : 0,
|
||||
functions: totalFn > 0 ? (totalFnCov / totalFn) * 100 : 0,
|
||||
};
|
||||
|
||||
return result;
|
||||
}
|
||||
|
||||
export async function collectVitestCoverage(root, cacheDir, quick) {
|
||||
const cacheFile = resolve(cacheDir, CACHE_FILE);
|
||||
|
||||
const clientDir = resolve(root, 'Client/tauri-client');
|
||||
|
||||
if (quick && existsSync(cacheFile)) {
|
||||
console.log(' [TS] Using cached coverage data');
|
||||
let cached;
|
||||
try {
|
||||
cached = JSON.parse(readFileSync(cacheFile, 'utf8'));
|
||||
} catch {
|
||||
console.warn(' [TS] Corrupt cache — falling through to fresh collection');
|
||||
cached = null;
|
||||
}
|
||||
if (cached) {
|
||||
// Still evaluate freshness of the underlying coverage-final.json
|
||||
const coveragePath = resolve(clientDir, 'coverage/coverage-final.json');
|
||||
if (existsSync(coveragePath)) {
|
||||
try {
|
||||
const covStat = statSync(coveragePath);
|
||||
const ageMs = Date.now() - covStat.mtimeMs;
|
||||
if (ageMs > FRESHNESS_MAX_AGE_MS) {
|
||||
cached.stale = true;
|
||||
console.log(` [TS] coverage-final.json is ${Math.round(ageMs / 3600000)}h old — flagging as stale`);
|
||||
}
|
||||
} catch { /* stat failed, leave stale flag as-is */ }
|
||||
}
|
||||
return cached;
|
||||
}
|
||||
}
|
||||
if (!existsSync(clientDir)) {
|
||||
console.log(' [TS] Client directory not found, skipping');
|
||||
return {};
|
||||
}
|
||||
|
||||
// Check if coverage-final.json already exists (from a previous test run)
|
||||
const coveragePath = resolve(clientDir, 'coverage/coverage-final.json');
|
||||
let needsRun = !existsSync(coveragePath);
|
||||
let stale = false;
|
||||
|
||||
// Check freshness — don't blindly trust old coverage data
|
||||
if (!needsRun) {
|
||||
try {
|
||||
const covStat = statSync(coveragePath);
|
||||
const ageMs = Date.now() - covStat.mtimeMs;
|
||||
if (ageMs > FRESHNESS_MAX_AGE_MS) {
|
||||
stale = true;
|
||||
console.log(` [TS] coverage-final.json is ${Math.round(ageMs / 3600000)}h old — flagging as stale`);
|
||||
if (!quick) {
|
||||
needsRun = true; // Full mode re-runs stale coverage
|
||||
}
|
||||
}
|
||||
} catch { /* stat failed, treat as needing a run */ needsRun = true; }
|
||||
}
|
||||
|
||||
if (needsRun && !quick) {
|
||||
console.log(' [TS] Running vitest with coverage (this may take a moment)...');
|
||||
try {
|
||||
execFileSync('npx', ['vitest', 'run', '--coverage'], {
|
||||
cwd: clientDir,
|
||||
encoding: 'utf8',
|
||||
timeout: 300_000,
|
||||
maxBuffer: 10 * 1024 * 1024,
|
||||
});
|
||||
} catch {
|
||||
// vitest may exit non-zero but still produce coverage
|
||||
}
|
||||
} else if (!needsRun) {
|
||||
console.log(' [TS] Using existing coverage-final.json');
|
||||
}
|
||||
|
||||
let coverageData = {};
|
||||
if (existsSync(coveragePath)) {
|
||||
coverageData = parseCoverageFinal(coveragePath);
|
||||
}
|
||||
|
||||
// Get test count from a quick vitest --reporter=json run if available
|
||||
let testCount = 0;
|
||||
const reportPath = resolve(clientDir, 'coverage-report.json');
|
||||
if (existsSync(reportPath)) {
|
||||
try {
|
||||
const report = JSON.parse(readFileSync(reportPath, 'utf8'));
|
||||
testCount = report.numTotalTests ?? 0;
|
||||
} catch { /* skip */ }
|
||||
}
|
||||
|
||||
// Instead of running vitest again, count files from coverage data
|
||||
if (testCount === 0 && Object.keys(coverageData).length > 0) {
|
||||
try {
|
||||
const coverageJsonPath = resolve(clientDir, 'coverage', 'coverage-final.json');
|
||||
if (existsSync(coverageJsonPath)) {
|
||||
const raw = JSON.parse(readFileSync(coverageJsonPath, 'utf8'));
|
||||
testCount = Object.keys(raw).length;
|
||||
}
|
||||
} catch { /* keep testCount as 0 */ }
|
||||
}
|
||||
|
||||
const result = {
|
||||
timestamp: new Date().toISOString(),
|
||||
areas: coverageData,
|
||||
testCount,
|
||||
stale,
|
||||
};
|
||||
|
||||
writeFileSync(cacheFile, JSON.stringify(result, null, 2));
|
||||
console.log(` [TS] Coverage collected for ${Object.keys(coverageData).length} areas, ${testCount} tests`);
|
||||
return result;
|
||||
}
|
||||
@@ -1,387 +0,0 @@
|
||||
/**
|
||||
* Worktree Manager — git worktree lifecycle for isolated agent execution.
|
||||
*
|
||||
* Each agent job gets its own worktree under .worktrees/<jobId>.
|
||||
* Changes stay isolated until explicitly merged back.
|
||||
*
|
||||
* Lifecycle:
|
||||
* createWorktree() → agent runs → mergeWorktree() → destroyWorktree()
|
||||
*
|
||||
* State machine:
|
||||
* queued → provisioning → running → review → merged → archived
|
||||
* → failed → (retry → queued)
|
||||
* → cancelled
|
||||
*/
|
||||
import { execFileSync } from 'node:child_process';
|
||||
import {
|
||||
existsSync,
|
||||
mkdirSync,
|
||||
symlinkSync,
|
||||
cpSync,
|
||||
rmSync,
|
||||
readdirSync,
|
||||
lstatSync,
|
||||
} from 'node:fs';
|
||||
import { resolve, join } from 'node:path';
|
||||
|
||||
// ---------------------------------------------------------------------------
|
||||
// Constants
|
||||
// ---------------------------------------------------------------------------
|
||||
|
||||
const WORKTREES_DIR = '.worktrees';
|
||||
const BRANCH_PREFIX = 'agent/';
|
||||
const GIT_TIMEOUT = 30_000;
|
||||
|
||||
// ---------------------------------------------------------------------------
|
||||
// Helpers
|
||||
// ---------------------------------------------------------------------------
|
||||
|
||||
function git(args, cwd, opts = {}) {
|
||||
return execFileSync('git', args, {
|
||||
cwd,
|
||||
encoding: 'utf8',
|
||||
timeout: opts.timeout ?? GIT_TIMEOUT,
|
||||
stdio: ['pipe', 'pipe', 'pipe'],
|
||||
maxBuffer: 10 * 1024 * 1024,
|
||||
}).trim();
|
||||
}
|
||||
|
||||
/**
|
||||
* Link or copy .claude/ and CLAUDE.md into a worktree so agents
|
||||
* inherit project config, skills, and MCP server settings.
|
||||
*
|
||||
* Strategy: try symlink first (works if Developer Mode enabled on Windows).
|
||||
* If symlink fails (EPERM), fall back to a full copy.
|
||||
*
|
||||
* @returns {'symlink'|'copy'|'none'} — method used
|
||||
*/
|
||||
function inheritConfig(rootDir, worktreePath) {
|
||||
let method = 'none';
|
||||
|
||||
const claudeDir = resolve(rootDir, '.claude');
|
||||
const claudeMd = resolve(rootDir, 'CLAUDE.md');
|
||||
const targetDir = resolve(worktreePath, '.claude');
|
||||
const targetMd = resolve(worktreePath, 'CLAUDE.md');
|
||||
|
||||
if (existsSync(claudeDir) && !existsSync(targetDir)) {
|
||||
// Try symlink
|
||||
try {
|
||||
symlinkSync(claudeDir, targetDir, 'junction'); // junction works without admin on Windows
|
||||
method = 'symlink';
|
||||
} catch {
|
||||
// Fallback to copy
|
||||
try {
|
||||
cpSync(claudeDir, targetDir, { recursive: true });
|
||||
method = 'copy';
|
||||
} catch (copyErr) {
|
||||
console.error(` [Worktree] Failed to copy .claude/: ${copyErr.message}`);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
if (existsSync(claudeMd) && !existsSync(targetMd)) {
|
||||
try {
|
||||
symlinkSync(claudeMd, targetMd, 'file');
|
||||
} catch {
|
||||
try {
|
||||
cpSync(claudeMd, targetMd);
|
||||
} catch { /* non-critical */ }
|
||||
}
|
||||
}
|
||||
|
||||
return method;
|
||||
}
|
||||
|
||||
/**
|
||||
* Remove inherited config from a worktree before destruction.
|
||||
* Must handle both symlinks and copies.
|
||||
*/
|
||||
function removeInheritedConfig(worktreePath) {
|
||||
const targets = [
|
||||
resolve(worktreePath, '.claude'),
|
||||
resolve(worktreePath, 'CLAUDE.md'),
|
||||
];
|
||||
|
||||
for (const target of targets) {
|
||||
if (!existsSync(target)) continue;
|
||||
try {
|
||||
rmSync(target, { recursive: true, force: true });
|
||||
} catch (err) {
|
||||
console.error(` [Worktree] Failed to remove ${target}: ${err.message}`);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// ---------------------------------------------------------------------------
|
||||
// Merge mutex — only one merge at a time
|
||||
// ---------------------------------------------------------------------------
|
||||
|
||||
let mergeInProgress = false;
|
||||
|
||||
export function isMergeInProgress() {
|
||||
return mergeInProgress;
|
||||
}
|
||||
|
||||
// ---------------------------------------------------------------------------
|
||||
// Public API
|
||||
// ---------------------------------------------------------------------------
|
||||
|
||||
/**
|
||||
* Create an isolated git worktree for an agent job.
|
||||
*
|
||||
* @param {string} root — project root (must be a git repo)
|
||||
* @param {string} jobId — unique job identifier (used for directory + branch name)
|
||||
* @returns {{ worktreePath: string, branchName: string, configMethod: string }}
|
||||
*/
|
||||
export function createWorktree(root, jobId) {
|
||||
const worktreesBase = resolve(root, WORKTREES_DIR);
|
||||
if (!existsSync(worktreesBase)) {
|
||||
mkdirSync(worktreesBase, { recursive: true });
|
||||
}
|
||||
|
||||
const worktreePath = resolve(worktreesBase, jobId);
|
||||
const branchName = `${BRANCH_PREFIX}${jobId}`;
|
||||
|
||||
if (existsSync(worktreePath)) {
|
||||
throw new Error(`Worktree already exists for job ${jobId}`);
|
||||
}
|
||||
|
||||
// Create worktree with a new branch based on current HEAD
|
||||
git(['worktree', 'add', worktreePath, '-b', branchName], root);
|
||||
|
||||
// Inherit project config
|
||||
const configMethod = inheritConfig(root, worktreePath);
|
||||
|
||||
return { worktreePath, branchName, configMethod };
|
||||
}
|
||||
|
||||
/**
|
||||
* Destroy a worktree and its branch.
|
||||
* Handles the Windows-specific cleanup order: remove config → remove dir → prune → delete branch.
|
||||
*
|
||||
* @param {string} root — project root
|
||||
* @param {string} jobId — job identifier
|
||||
*/
|
||||
export function destroyWorktree(root, jobId) {
|
||||
const worktreePath = resolve(root, WORKTREES_DIR, jobId);
|
||||
const branchName = `${BRANCH_PREFIX}${jobId}`;
|
||||
|
||||
if (existsSync(worktreePath)) {
|
||||
// Step 1: Remove inherited config (symlinks/copies) first
|
||||
removeInheritedConfig(worktreePath);
|
||||
|
||||
// Step 2: Try git worktree remove
|
||||
try {
|
||||
git(['worktree', 'remove', worktreePath, '--force'], root);
|
||||
} catch {
|
||||
// Fallback: force-remove directory + prune
|
||||
try {
|
||||
rmSync(worktreePath, { recursive: true, force: true });
|
||||
} catch (rmErr) {
|
||||
console.error(` [Worktree] rm failed for ${jobId}: ${rmErr.message}`);
|
||||
}
|
||||
try {
|
||||
git(['worktree', 'prune'], root);
|
||||
} catch { /* best effort */ }
|
||||
}
|
||||
} else {
|
||||
// Directory already gone — just prune
|
||||
try {
|
||||
git(['worktree', 'prune'], root);
|
||||
} catch { /* best effort */ }
|
||||
}
|
||||
|
||||
// Step 3: Delete the branch
|
||||
try {
|
||||
git(['branch', '-D', branchName], root);
|
||||
} catch {
|
||||
// Branch may already be deleted or never created
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* List all active worktrees.
|
||||
*
|
||||
* @param {string} root — project root
|
||||
* @returns {Array<{ path: string, branch: string, head: string, jobId: string|null }>}
|
||||
*/
|
||||
export function listWorktrees(root) {
|
||||
let raw;
|
||||
try {
|
||||
raw = git(['worktree', 'list', '--porcelain'], root);
|
||||
} catch {
|
||||
return [];
|
||||
}
|
||||
|
||||
const worktrees = [];
|
||||
let current = {};
|
||||
|
||||
for (const line of raw.split('\n')) {
|
||||
if (line.startsWith('worktree ')) {
|
||||
if (current.path) worktrees.push(current);
|
||||
current = { path: line.slice(9) };
|
||||
} else if (line.startsWith('HEAD ')) {
|
||||
current.head = line.slice(5);
|
||||
} else if (line.startsWith('branch ')) {
|
||||
current.branch = line.slice(7);
|
||||
} else if (line === '') {
|
||||
if (current.path) worktrees.push(current);
|
||||
current = {};
|
||||
}
|
||||
}
|
||||
if (current.path) worktrees.push(current);
|
||||
|
||||
// Filter to agent worktrees only and extract jobId
|
||||
return worktrees
|
||||
.filter(w => w.branch && w.branch.includes(BRANCH_PREFIX))
|
||||
.map(w => ({
|
||||
...w,
|
||||
jobId: w.branch.replace(`refs/heads/${BRANCH_PREFIX}`, ''),
|
||||
}));
|
||||
}
|
||||
|
||||
/**
|
||||
* Merge a worktree's branch back into the current branch.
|
||||
*
|
||||
* Guards:
|
||||
* - Only one merge at a time (mutex)
|
||||
* - Working tree must be clean
|
||||
*
|
||||
* @param {string} root — project root
|
||||
* @param {string} jobId — job identifier
|
||||
* @param {string} [message] — optional merge commit message
|
||||
* @returns {{ success: boolean, filesChanged: number, commitSha: string|null, conflicts: string[] }}
|
||||
*/
|
||||
export function mergeWorktree(root, jobId, message) {
|
||||
if (mergeInProgress) {
|
||||
return { success: false, filesChanged: 0, commitSha: null, conflicts: [], error: 'merge_in_progress' };
|
||||
}
|
||||
|
||||
mergeInProgress = true;
|
||||
|
||||
try {
|
||||
// Guard: working tree must be clean
|
||||
try {
|
||||
git(['diff', '--quiet'], root);
|
||||
git(['diff', '--quiet', '--cached'], root);
|
||||
} catch {
|
||||
return { success: false, filesChanged: 0, commitSha: null, conflicts: [], error: 'working_tree_dirty' };
|
||||
}
|
||||
|
||||
const branchName = `${BRANCH_PREFIX}${jobId}`;
|
||||
const commitMsg = message || `agent: merge results from ${jobId}`;
|
||||
|
||||
// Guard: branch must exist
|
||||
try {
|
||||
git(['rev-parse', '--verify', branchName], root);
|
||||
} catch {
|
||||
return { success: false, filesChanged: 0, commitSha: null, conflicts: [], error: 'branch_not_found' };
|
||||
}
|
||||
|
||||
// Attempt merge
|
||||
try {
|
||||
git(['merge', branchName, '--no-ff', '-m', commitMsg], root, { timeout: 60_000 });
|
||||
} catch (mergeErr) {
|
||||
// Check if it's a conflict
|
||||
try {
|
||||
const conflictRaw = git(['diff', '--name-only', '--diff-filter=U'], root);
|
||||
const conflicts = conflictRaw.split('\n').filter(Boolean);
|
||||
|
||||
if (conflicts.length > 0) {
|
||||
// Abort the merge
|
||||
try { git(['merge', '--abort'], root); } catch { /* may already be clean */ }
|
||||
return { success: false, filesChanged: 0, commitSha: null, conflicts };
|
||||
}
|
||||
} catch { /* fall through */ }
|
||||
|
||||
// Not a conflict — some other error
|
||||
try { git(['merge', '--abort'], root); } catch { /* best effort */ }
|
||||
throw mergeErr;
|
||||
}
|
||||
|
||||
// Success — get stats
|
||||
const commitSha = git(['rev-parse', '--short', 'HEAD'], root);
|
||||
let filesChanged = 0;
|
||||
try {
|
||||
const stat = git(['diff', '--stat', 'HEAD~1..HEAD', '--numstat'], root);
|
||||
filesChanged = stat.split('\n').filter(Boolean).length;
|
||||
} catch { /* non-critical */ }
|
||||
|
||||
return { success: true, filesChanged, commitSha, conflicts: [] };
|
||||
} finally {
|
||||
mergeInProgress = false;
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Clean up stale worktrees — those whose agent process is dead.
|
||||
* Call on server startup.
|
||||
*
|
||||
* @param {string} root — project root
|
||||
* @param {function} isJobAlive — callback (jobId) => boolean, checks if the agent process is still running
|
||||
* @returns {{ cleaned: number, errors: string[] }}
|
||||
*/
|
||||
export function cleanupStaleWorktrees(root, isJobAlive) {
|
||||
const worktreesBase = resolve(root, WORKTREES_DIR);
|
||||
if (!existsSync(worktreesBase)) return { cleaned: 0, errors: [] };
|
||||
|
||||
let entries;
|
||||
try {
|
||||
entries = readdirSync(worktreesBase);
|
||||
} catch {
|
||||
return { cleaned: 0, errors: [] };
|
||||
}
|
||||
|
||||
let cleaned = 0;
|
||||
const errors = [];
|
||||
|
||||
for (const entry of entries) {
|
||||
const entryPath = resolve(worktreesBase, entry);
|
||||
try {
|
||||
const stat = lstatSync(entryPath);
|
||||
if (!stat.isDirectory()) continue;
|
||||
} catch {
|
||||
continue;
|
||||
}
|
||||
|
||||
// Check if the agent for this worktree is still alive
|
||||
const alive = typeof isJobAlive === 'function' ? isJobAlive(entry) : false;
|
||||
if (alive) continue;
|
||||
|
||||
// Dead worktree — clean up
|
||||
try {
|
||||
destroyWorktree(root, entry);
|
||||
cleaned += 1;
|
||||
} catch (err) {
|
||||
errors.push(`${entry}: ${err.message}`);
|
||||
}
|
||||
}
|
||||
|
||||
return { cleaned, errors };
|
||||
}
|
||||
|
||||
/**
|
||||
* Get disk usage estimate for a worktree directory (in bytes).
|
||||
* Best-effort — returns 0 on failure.
|
||||
*/
|
||||
export function getWorktreeDiskUsage(root, jobId) {
|
||||
const worktreePath = resolve(root, WORKTREES_DIR, jobId);
|
||||
if (!existsSync(worktreePath)) return 0;
|
||||
|
||||
try {
|
||||
// Use git to count the worktree overhead (not the full repo — worktrees share objects)
|
||||
const countOutput = git(['count-objects', '-vH'], worktreePath);
|
||||
// Parse "size-pack: 42.00 MiB" or similar
|
||||
const match = countOutput.match(/size-pack:\s*([\d.]+)\s*(\w+)/);
|
||||
if (match) {
|
||||
const size = parseFloat(match[1]);
|
||||
const unit = match[2].toLowerCase();
|
||||
if (unit.startsWith('kib') || unit.startsWith('k')) return Math.round(size * 1024);
|
||||
if (unit.startsWith('mib') || unit.startsWith('m')) return Math.round(size * 1024 * 1024);
|
||||
if (unit.startsWith('gib') || unit.startsWith('g')) return Math.round(size * 1024 * 1024 * 1024);
|
||||
return Math.round(size);
|
||||
}
|
||||
} catch { /* best effort */ }
|
||||
|
||||
return 0;
|
||||
}
|
||||
@@ -1,13 +0,0 @@
|
||||
{
|
||||
"name": "owncord-project-map",
|
||||
"version": "1.0.0",
|
||||
"private": true,
|
||||
"type": "module",
|
||||
"description": "Project map generator for OwnCord — completeness, testing, priorities",
|
||||
"scripts": {
|
||||
"map": "node index.mjs",
|
||||
"map:quick": "node index.mjs --quick",
|
||||
"map:research": "node index.mjs --research",
|
||||
"test": "node --test --test-concurrency=1 tests/*.test.mjs"
|
||||
}
|
||||
}
|
||||
@@ -1,661 +0,0 @@
|
||||
#!/usr/bin/env node
|
||||
/**
|
||||
* Project Map Web Dashboard
|
||||
* Run: node tools/project-map/server.mjs
|
||||
* Open: http://localhost:3333
|
||||
*/
|
||||
import { createServer } from 'node:http';
|
||||
import { randomBytes } from 'node:crypto';
|
||||
import { readFileSync, writeFileSync as _writeFileSync, existsSync, mkdirSync } from 'node:fs';
|
||||
import { resolve, dirname } from 'node:path';
|
||||
import { fileURLToPath } from 'node:url';
|
||||
|
||||
import { scanModules } from './lib/scanner.mjs';
|
||||
import { collectGoCoverage } from './lib/go-coverage.mjs';
|
||||
import { collectVitestCoverage } from './lib/vitest-coverage.mjs';
|
||||
import { parseBacklog } from './lib/backlog-parser.mjs';
|
||||
import { scorePriorities } from './lib/priority-engine.mjs';
|
||||
import { scanGitHistory } from './lib/git-scanner.mjs';
|
||||
import { parseSessionHistory } from './lib/session-parser.mjs';
|
||||
import { scanTechnicalDebt } from './lib/debt-scanner.mjs';
|
||||
import { buildImportGraph } from './lib/import-graph.mjs';
|
||||
import { generateSuggestions, markWorkedOn, setStrategy } from './lib/suggestion-engine.mjs';
|
||||
import { createFileWatcher, createSSEManager } from './lib/file-watcher.mjs';
|
||||
import { generatePlan, startSession, getSessionStatus, pollChanges, endSession, recoverStaleSession } from './lib/session-manager.mjs';
|
||||
import { healthCheck, getJobs, createJob, cancelJob, getJobResult, processQueue, recoverOrphans, pruneResults, getLiveOutput, getJobDiff, parseActivityHints, getActiveCount, getMaxConcurrent, setMaxConcurrent, getActiveAgentIds } from './lib/agent-manager.mjs';
|
||||
import { mergeWorktree, destroyWorktree, listWorktrees, isMergeInProgress, getWorktreeDiskUsage } from './lib/worktree-manager.mjs';
|
||||
import { generateBriefing } from './lib/morning-briefing.mjs';
|
||||
|
||||
const __dirname = dirname(fileURLToPath(import.meta.url));
|
||||
const ROOT = resolve(__dirname, '../..');
|
||||
const CACHE_DIR = resolve(__dirname, '.cache');
|
||||
let PORT = parseInt(process.env.PORT || '3333', 10);
|
||||
if (isNaN(PORT) || PORT < 1 || PORT > 65535) { console.error(`Invalid PORT "${process.env.PORT}", using 3333`); PORT = 3333; }
|
||||
|
||||
if (!existsSync(CACHE_DIR)) mkdirSync(CACHE_DIR, { recursive: true });
|
||||
|
||||
// Auth token — generated per process, required for privileged endpoints
|
||||
const AUTH_TOKEN = process.env.PROJECT_MAP_TOKEN || randomBytes(24).toString('hex');
|
||||
|
||||
// In-memory cache (mode-aware)
|
||||
let cachedData = null;
|
||||
let cachedDataMode = null; // 'quick' or 'full'
|
||||
let collectInflight = null;
|
||||
|
||||
// Valid job types
|
||||
const VALID_JOB_TYPES = new Set(['research', 'write-tests', 'code-review', 'security-audit', 'fix-debt', 'custom']);
|
||||
const JOB_ID_RE = /^job-\d+(-[a-f0-9]+)?$/;
|
||||
|
||||
async function collectData(quick = true) {
|
||||
console.log(` Collecting data (${quick ? 'quick' : 'full'} mode)...`);
|
||||
|
||||
const modules = await scanModules(ROOT);
|
||||
const goCoverage = await collectGoCoverage(ROOT, CACHE_DIR, quick);
|
||||
const vitestCoverage = await collectVitestCoverage(ROOT, CACHE_DIR, quick);
|
||||
const backlog = await parseBacklog(ROOT);
|
||||
const priorities = scorePriorities(modules, goCoverage, vitestCoverage, backlog);
|
||||
|
||||
let gitData = null, sessionData = null, debtData = null, importGraph = null;
|
||||
try { gitData = await scanGitHistory(ROOT, CACHE_DIR, quick); } catch (e) { console.error(' [Git] Error:', e.message); }
|
||||
try { sessionData = await parseSessionHistory(ROOT, CACHE_DIR, quick); } catch (e) { console.error(' [Session] Error:', e.message); }
|
||||
try { debtData = await scanTechnicalDebt(ROOT, CACHE_DIR, quick); } catch (e) { console.error(' [Debt] Error:', e.message); }
|
||||
try { importGraph = await buildImportGraph(ROOT, CACHE_DIR, quick); } catch (e) { console.error(' [Graph] Error:', e.message); }
|
||||
|
||||
let suggestions = null;
|
||||
try {
|
||||
suggestions = await generateSuggestions(CACHE_DIR, {
|
||||
priorities, goCoverage, vitestCoverage, backlog, gitData, debtData, importGraph, sessionData,
|
||||
});
|
||||
} catch (e) { console.error(' [Suggestions] Error:', e.message); }
|
||||
|
||||
// Agent jobs
|
||||
let agentJobs = null;
|
||||
try { agentJobs = getJobs(CACHE_DIR); } catch (e) { console.error(' [Jobs] Error:', e.message); }
|
||||
|
||||
// Morning briefing
|
||||
let briefing = null;
|
||||
try { briefing = await generateBriefing(ROOT, CACHE_DIR, { sessionData, suggestions, backlog, agentJobs }); } catch (e) { console.error(' [Briefing] Error:', e.message); }
|
||||
|
||||
return {
|
||||
modules, goCoverage, vitestCoverage, backlog, priorities,
|
||||
gitData, sessionData, debtData, importGraph, suggestions,
|
||||
agentJobs, briefing,
|
||||
agentHealth: null, // populated on demand
|
||||
timestamp: new Date().toISOString(),
|
||||
};
|
||||
}
|
||||
|
||||
// SSE manager for live updates
|
||||
const sse = createSSEManager();
|
||||
|
||||
// File watcher for auto-refresh
|
||||
const watcher = createFileWatcher(ROOT, (change) => {
|
||||
console.log(` [Watch] Change detected: ${change.filename}`);
|
||||
cachedData = null;
|
||||
sse.broadcast({ type: 'file-change', ...change });
|
||||
});
|
||||
|
||||
// Valid strategy values
|
||||
const VALID_STRATEGIES = new Set(['balanced', 'bugs-first', 'coverage-first', 'momentum-first', 'debt-first']);
|
||||
|
||||
// Parse JSON body from POST requests (with size limit and error handling)
|
||||
async function parseBody(req) {
|
||||
return new Promise((resolve) => {
|
||||
let body = '';
|
||||
let destroyed = false;
|
||||
req.on('data', chunk => {
|
||||
if (destroyed) return;
|
||||
body += chunk;
|
||||
if (body.length > 4096) { destroyed = true; req.destroy(); resolve(null); }
|
||||
});
|
||||
req.on('end', () => {
|
||||
if (destroyed) return;
|
||||
try { resolve(JSON.parse(body)); } catch { resolve(null); }
|
||||
});
|
||||
req.on('error', () => { if (!destroyed) resolve(null); });
|
||||
});
|
||||
}
|
||||
|
||||
function json(res, status, data) {
|
||||
res.writeHead(status, { 'Content-Type': 'application/json' });
|
||||
res.end(JSON.stringify(data));
|
||||
}
|
||||
|
||||
// Auto-process agent queue on an interval
|
||||
let processInterval = null;
|
||||
|
||||
// Diff poller — polls git diff every 2s while a job is running
|
||||
let diffPollerInterval = null;
|
||||
|
||||
function startDiffPoller() {
|
||||
if (diffPollerInterval) return;
|
||||
console.log(' [Diff] Starting diff poller (2s interval)');
|
||||
diffPollerInterval = setInterval(() => {
|
||||
try {
|
||||
const { jobs } = getJobs(CACHE_DIR);
|
||||
const running = jobs.filter(j => j.status === 'running' && j.baselineSha);
|
||||
if (running.length === 0) {
|
||||
stopDiffPoller();
|
||||
return;
|
||||
}
|
||||
for (const job of running) {
|
||||
try {
|
||||
const diffData = getJobDiff(ROOT, job.baselineSha, job.preExistingDirtyFiles || []);
|
||||
sse.broadcast({
|
||||
type: 'job-diff',
|
||||
jobId: job.id,
|
||||
files: diffData.files,
|
||||
diffs: diffData.diffs,
|
||||
freshness: diffData.freshness,
|
||||
});
|
||||
} catch (err) {
|
||||
console.error(` [Diff] Error polling job ${job.id}:`, err.message);
|
||||
}
|
||||
}
|
||||
} catch { /* silent */ }
|
||||
}, 2000);
|
||||
}
|
||||
|
||||
function stopDiffPoller() {
|
||||
if (!diffPollerInterval) return;
|
||||
console.log(' [Diff] Stopping diff poller');
|
||||
clearInterval(diffPollerInterval);
|
||||
diffPollerInterval = null;
|
||||
}
|
||||
|
||||
// Check bearer token for privileged endpoints
|
||||
function isAuthorized(req) {
|
||||
const auth = req.headers['authorization'] || '';
|
||||
return auth === `Bearer ${AUTH_TOKEN}`;
|
||||
}
|
||||
|
||||
function requireAuth(req, res) {
|
||||
if (isAuthorized(req)) return true;
|
||||
json(res, 401, { error: 'Unauthorized — pass Authorization: Bearer <token>' });
|
||||
return false;
|
||||
}
|
||||
|
||||
const BIND_HOST = process.env.PROJECT_MAP_HOST || '127.0.0.1';
|
||||
|
||||
const server = createServer(async (req, res) => {
|
||||
const url = new URL(req.url, `http://localhost:${PORT}`);
|
||||
res.setHeader('Access-Control-Allow-Origin', `http://localhost:${PORT}`);
|
||||
res.setHeader('Access-Control-Allow-Methods', 'GET, POST, DELETE, OPTIONS');
|
||||
res.setHeader('Access-Control-Allow-Headers', 'Content-Type, Authorization');
|
||||
|
||||
if (req.method === 'OPTIONS') { res.writeHead(204); res.end(); return; }
|
||||
|
||||
try {
|
||||
// === EXISTING ROUTES ===
|
||||
|
||||
if (url.pathname === '/api/data') {
|
||||
const quick = url.searchParams.get('full') !== '1';
|
||||
const requestedMode = quick ? 'quick' : 'full';
|
||||
// Don't reuse quick cache for full requests; always refresh if mode changed or forced
|
||||
const cacheValid = cachedData && cachedDataMode === requestedMode && !url.searchParams.has('refresh');
|
||||
// Also allow full cache to serve quick requests (full is a superset)
|
||||
const fullCacheForQuick = cachedData && cachedDataMode === 'full' && requestedMode === 'quick' && !url.searchParams.has('refresh');
|
||||
if (!cacheValid && !fullCacheForQuick) {
|
||||
if (!collectInflight) {
|
||||
collectInflight = collectData(quick).then(data => {
|
||||
cachedData = data;
|
||||
cachedDataMode = requestedMode;
|
||||
collectInflight = null;
|
||||
return data;
|
||||
}).catch(err => {
|
||||
collectInflight = null;
|
||||
throw err;
|
||||
});
|
||||
}
|
||||
await collectInflight;
|
||||
}
|
||||
// Strip agentJobs and job-derived briefing fields from unauthenticated responses
|
||||
if (!isAuthorized(req)) {
|
||||
const { agentJobs: _stripped, briefing: fullBriefing, ...publicData } = cachedData;
|
||||
if (fullBriefing) {
|
||||
const { agentResults: _a, deadJobs: _d, stats: _s, autoQueueSuggestions: _q, ...publicBriefing } = fullBriefing;
|
||||
publicData.briefing = publicBriefing;
|
||||
}
|
||||
json(res, 200, publicData);
|
||||
} else {
|
||||
json(res, 200, cachedData);
|
||||
}
|
||||
return;
|
||||
}
|
||||
|
||||
if (url.pathname === '/api/events') {
|
||||
sse.handleConnection(req, res);
|
||||
return;
|
||||
}
|
||||
|
||||
if (url.pathname === '/api/worked-on' && req.method === 'POST') {
|
||||
if (!requireAuth(req, res)) return;
|
||||
const body = await parseBody(req);
|
||||
if (!body) { json(res, 400, { error: 'Invalid JSON' }); return; }
|
||||
if (typeof body.module !== 'string' || !body.module || body.module.length > 100 || !/^[\w:/-]+$/.test(body.module)) {
|
||||
json(res, 400, { error: 'Invalid module name' }); return;
|
||||
}
|
||||
markWorkedOn(CACHE_DIR, body.module);
|
||||
cachedData = null; cachedDataMode = null;
|
||||
json(res, 200, { ok: true });
|
||||
return;
|
||||
}
|
||||
|
||||
if (url.pathname === '/api/strategy' && req.method === 'POST') {
|
||||
if (!requireAuth(req, res)) return;
|
||||
const body = await parseBody(req);
|
||||
if (!body) { json(res, 400, { error: 'Invalid JSON' }); return; }
|
||||
if (!VALID_STRATEGIES.has(body.strategy)) {
|
||||
json(res, 400, { error: `Invalid strategy. Valid: ${[...VALID_STRATEGIES].join(', ')}` }); return;
|
||||
}
|
||||
setStrategy(CACHE_DIR, body.strategy);
|
||||
cachedData = null; cachedDataMode = null;
|
||||
json(res, 200, { ok: true });
|
||||
return;
|
||||
}
|
||||
|
||||
// === SESSION ROUTES ===
|
||||
|
||||
if (url.pathname === '/api/session/plan' && req.method === 'GET') {
|
||||
// Unauthenticated — returns non-sensitive planning suggestions
|
||||
const plan = await generatePlan(ROOT, CACHE_DIR);
|
||||
json(res, 200, plan);
|
||||
return;
|
||||
}
|
||||
|
||||
if (url.pathname === '/api/session/start' && req.method === 'POST') {
|
||||
if (!requireAuth(req, res)) return;
|
||||
const state = startSession(ROOT, CACHE_DIR);
|
||||
sse.broadcast({ type: 'session-started' });
|
||||
json(res, 200, state);
|
||||
return;
|
||||
}
|
||||
|
||||
if (url.pathname === '/api/session/status' && req.method === 'GET') {
|
||||
const status = getSessionStatus(CACHE_DIR);
|
||||
// If active, poll for latest changes
|
||||
if (status.active) {
|
||||
try { pollChanges(ROOT, CACHE_DIR); } catch { /* best effort */ }
|
||||
const updated = getSessionStatus(CACHE_DIR);
|
||||
json(res, 200, updated);
|
||||
} else {
|
||||
json(res, 200, status);
|
||||
}
|
||||
return;
|
||||
}
|
||||
|
||||
if (url.pathname === '/api/session/end' && req.method === 'POST') {
|
||||
if (!requireAuth(req, res)) return;
|
||||
const result = endSession(ROOT, CACHE_DIR);
|
||||
cachedData = null; // Vault changed
|
||||
sse.broadcast({ type: 'session-ended', ...result });
|
||||
json(res, 200, result);
|
||||
return;
|
||||
}
|
||||
|
||||
// === AGENT JOB ROUTES ===
|
||||
|
||||
if (url.pathname === '/api/agent/health' && req.method === 'GET') {
|
||||
const health = healthCheck();
|
||||
json(res, 200, health);
|
||||
return;
|
||||
}
|
||||
|
||||
if (url.pathname === '/api/jobs' && req.method === 'GET') {
|
||||
if (!requireAuth(req, res)) return;
|
||||
const jobs = getJobs(CACHE_DIR);
|
||||
json(res, 200, jobs);
|
||||
return;
|
||||
}
|
||||
|
||||
if (url.pathname === '/api/jobs' && req.method === 'POST') {
|
||||
if (!requireAuth(req, res)) return;
|
||||
const body = await parseBody(req);
|
||||
if (!body) { json(res, 400, { error: 'Invalid JSON' }); return; }
|
||||
if (!VALID_JOB_TYPES.has(body.type)) {
|
||||
json(res, 400, { error: `Invalid job type. Valid: ${[...VALID_JOB_TYPES].join(', ')}` }); return;
|
||||
}
|
||||
if (!body.target || typeof body.target !== 'string' || !/^[\w:/-]+$/.test(body.target) || body.target.length > 100) {
|
||||
json(res, 400, { error: 'Invalid target: must be alphanumeric with :/-_ only, max 100 chars' }); return;
|
||||
}
|
||||
if (body.type === 'custom') {
|
||||
if (typeof body.customPrompt !== 'string' || body.customPrompt.trim().length === 0) {
|
||||
json(res, 400, { error: 'customPrompt required for custom jobs' }); return;
|
||||
}
|
||||
if (body.customPrompt.length > 8000) {
|
||||
json(res, 400, { error: 'customPrompt exceeds 8000 char limit' }); return;
|
||||
}
|
||||
}
|
||||
// Health check before allowing job creation
|
||||
const health = healthCheck();
|
||||
if (!health.available) {
|
||||
json(res, 503, { error: 'Claude CLI not available', details: health.error }); return;
|
||||
}
|
||||
const job = createJob(CACHE_DIR, {
|
||||
type: body.type,
|
||||
target: body.target,
|
||||
priority: body.priority,
|
||||
customPrompt: body.customPrompt,
|
||||
});
|
||||
json(res, 201, job);
|
||||
return;
|
||||
}
|
||||
|
||||
// DELETE /api/jobs/:id
|
||||
const deleteMatch = url.pathname.match(/^\/api\/jobs\/([^/]+)$/);
|
||||
if (deleteMatch && req.method === 'DELETE') {
|
||||
if (!requireAuth(req, res)) return;
|
||||
const jobId = deleteMatch[1];
|
||||
if (!JOB_ID_RE.test(jobId)) { json(res, 400, { error: 'Invalid job ID format' }); return; }
|
||||
try {
|
||||
cancelJob(CACHE_DIR, jobId);
|
||||
json(res, 200, { ok: true });
|
||||
} catch (err) {
|
||||
json(res, 404, { error: err.message });
|
||||
}
|
||||
return;
|
||||
}
|
||||
|
||||
// GET /api/jobs/:id/result
|
||||
const resultMatch = url.pathname.match(/^\/api\/jobs\/([^/]+)\/result$/);
|
||||
if (resultMatch && req.method === 'GET') {
|
||||
if (!requireAuth(req, res)) return;
|
||||
const jobId = resultMatch[1];
|
||||
if (!JOB_ID_RE.test(jobId)) { json(res, 400, { error: 'Invalid job ID format' }); return; }
|
||||
const result = getJobResult(CACHE_DIR, jobId);
|
||||
json(res, 200, result);
|
||||
return;
|
||||
}
|
||||
|
||||
// GET /api/jobs/:id/output — live output for running jobs
|
||||
const outputMatch = url.pathname.match(/^\/api\/jobs\/([^/]+)\/output$/);
|
||||
if (outputMatch && req.method === 'GET') {
|
||||
if (!requireAuth(req, res)) return;
|
||||
const jobId = outputMatch[1];
|
||||
if (!JOB_ID_RE.test(jobId)) { json(res, 400, { error: 'Invalid job ID format' }); return; }
|
||||
const output = getLiveOutput(jobId);
|
||||
json(res, 200, { output });
|
||||
return;
|
||||
}
|
||||
|
||||
// GET /api/jobs/:id/diff — current git diff for a job
|
||||
const diffMatch = url.pathname.match(/^\/api\/jobs\/([^/]+)\/diff$/);
|
||||
if (diffMatch && req.method === 'GET') {
|
||||
if (!requireAuth(req, res)) return;
|
||||
const jobId = diffMatch[1];
|
||||
if (!JOB_ID_RE.test(jobId)) { json(res, 400, { error: 'Invalid job ID format' }); return; }
|
||||
const { jobs } = getJobs(CACHE_DIR);
|
||||
const job = jobs.find(j => j.id === jobId);
|
||||
if (!job) { json(res, 404, { error: 'Job not found' }); return; }
|
||||
if (!job.baselineSha) { json(res, 200, { files: [], diffs: {}, freshness: new Date().toISOString() }); return; }
|
||||
try {
|
||||
const diffData = getJobDiff(ROOT, job.baselineSha, job.preExistingDirtyFiles || []);
|
||||
json(res, 200, diffData);
|
||||
} catch (err) {
|
||||
json(res, 500, { error: 'Failed to compute diff: ' + err.message });
|
||||
}
|
||||
return;
|
||||
}
|
||||
|
||||
if (url.pathname === '/api/jobs/process' && req.method === 'POST') {
|
||||
if (!requireAuth(req, res)) return;
|
||||
startDiffPoller();
|
||||
const result = await processQueue(ROOT, CACHE_DIR,
|
||||
(jobId, chunk) => {
|
||||
sse.broadcast({ type: 'job-output', jobId, chunk });
|
||||
const hints = parseActivityHints(chunk);
|
||||
for (const hint of hints) {
|
||||
sse.broadcast({ type: 'job-activity', jobId, hint: hint.hint, file: hint.file });
|
||||
}
|
||||
},
|
||||
(jobId, message) => {
|
||||
sse.broadcast({ type: 'job-warning', jobId, message });
|
||||
},
|
||||
);
|
||||
if (result.launched > 0) {
|
||||
sse.broadcast({ type: 'fleet-update', active: getActiveCount(), max: getMaxConcurrent() });
|
||||
const { jobs } = getJobs(CACHE_DIR);
|
||||
if (!jobs.some(j => j.status === 'running')) stopDiffPoller();
|
||||
}
|
||||
json(res, 200, result);
|
||||
return;
|
||||
}
|
||||
|
||||
// POST /api/jobs/:id/merge — merge worktree back to current branch
|
||||
const mergeMatch = url.pathname.match(/^\/api\/jobs\/([^/]+)\/merge$/);
|
||||
if (mergeMatch && req.method === 'POST') {
|
||||
if (!requireAuth(req, res)) return;
|
||||
const jobId = mergeMatch[1];
|
||||
if (!JOB_ID_RE.test(jobId)) { json(res, 400, { error: 'Invalid job ID format' }); return; }
|
||||
const { jobs } = getJobs(CACHE_DIR);
|
||||
const job = jobs.find(j => j.id === jobId);
|
||||
if (!job) { json(res, 404, { error: 'Job not found' }); return; }
|
||||
if (job.status !== 'review') { json(res, 400, { error: `Cannot merge job with status "${job.status}" — must be in review` }); return; }
|
||||
|
||||
// Broadcast merge lock
|
||||
sse.broadcast({ type: 'merge-lock', locked: true, jobId });
|
||||
const body = await parseBody(req);
|
||||
const message = body?.message || undefined;
|
||||
|
||||
const result = mergeWorktree(ROOT, jobId, message);
|
||||
|
||||
if (result.error === 'merge_in_progress') {
|
||||
sse.broadcast({ type: 'merge-lock', locked: false, jobId });
|
||||
json(res, 423, { error: 'Another merge is in progress' });
|
||||
return;
|
||||
}
|
||||
if (result.error === 'working_tree_dirty') {
|
||||
sse.broadcast({ type: 'merge-lock', locked: false, jobId });
|
||||
json(res, 400, { error: 'Working tree has uncommitted changes — commit or stash first' });
|
||||
return;
|
||||
}
|
||||
if (result.error === 'branch_not_found') {
|
||||
sse.broadcast({ type: 'merge-lock', locked: false, jobId });
|
||||
json(res, 410, { error: 'Branch no longer exists — worktree was already cleaned up. Use Dismiss to clear this job.' });
|
||||
return;
|
||||
}
|
||||
if (!result.success && result.conflicts.length > 0) {
|
||||
sse.broadcast({ type: 'merge-lock', locked: false, jobId });
|
||||
json(res, 409, { error: 'merge_conflict', conflicts: result.conflicts });
|
||||
return;
|
||||
}
|
||||
|
||||
// Success — destroy worktree and update job status
|
||||
try { destroyWorktree(ROOT, jobId); } catch { /* best effort */ }
|
||||
// Update job status to merged
|
||||
const s = getJobs(CACHE_DIR); // refresh
|
||||
// Direct queue file update for status change
|
||||
const allJobs = s.jobs.map(j =>
|
||||
j.id === jobId ? { ...j, status: 'merged', worktreePath: null, branchName: null } : j,
|
||||
);
|
||||
const { writeFileSync: wfs } = await import('node:fs');
|
||||
wfs(resolve(CACHE_DIR, 'agent-queue.json'), JSON.stringify(allJobs, null, 2));
|
||||
|
||||
cachedData = null;
|
||||
sse.broadcast({ type: 'merge-lock', locked: false, jobId });
|
||||
sse.broadcast({ type: 'job-update', jobId, status: 'merged' });
|
||||
json(res, 200, { success: true, filesChanged: result.filesChanged, commitSha: result.commitSha });
|
||||
return;
|
||||
}
|
||||
|
||||
// === FLEET ROUTES ===
|
||||
|
||||
if (url.pathname === '/api/fleet/status' && req.method === 'GET') {
|
||||
const { jobs } = getJobs(CACHE_DIR);
|
||||
const active = jobs.filter(j => j.status === 'running' || j.status === 'provisioning').length;
|
||||
const queued = jobs.filter(j => j.status === 'queued').length;
|
||||
const review = jobs.filter(j => j.status === 'review').length;
|
||||
const worktrees = listWorktrees(ROOT).map(w => ({
|
||||
jobId: w.jobId,
|
||||
path: w.path,
|
||||
branch: w.branch,
|
||||
diskMB: Math.round(getWorktreeDiskUsage(ROOT, w.jobId) / (1024 * 1024)),
|
||||
}));
|
||||
json(res, 200, { active, queued, review, maxConcurrent: getMaxConcurrent(), worktrees });
|
||||
return;
|
||||
}
|
||||
|
||||
if (url.pathname === '/api/fleet/config' && req.method === 'POST') {
|
||||
if (!requireAuth(req, res)) return;
|
||||
const body = await parseBody(req);
|
||||
if (!body) { json(res, 400, { error: 'Invalid JSON' }); return; }
|
||||
if (typeof body.maxConcurrent === 'number') {
|
||||
if (body.maxConcurrent < 1 || body.maxConcurrent > 8) {
|
||||
json(res, 400, { error: 'maxConcurrent must be between 1 and 8' }); return;
|
||||
}
|
||||
setMaxConcurrent(body.maxConcurrent);
|
||||
}
|
||||
// Save to user prefs for persistence
|
||||
const prefsPath = resolve(CACHE_DIR, 'user-prefs.json');
|
||||
let prefs = {};
|
||||
try { prefs = JSON.parse(readFileSync(prefsPath, 'utf8')); } catch { /* new file */ }
|
||||
if (body.maxConcurrent) prefs.maxConcurrent = body.maxConcurrent;
|
||||
if (body.autopilot) prefs.autopilot = { ...prefs.autopilot, ...body.autopilot };
|
||||
_writeFileSync(prefsPath, JSON.stringify(prefs, null, 2));
|
||||
json(res, 200, { ok: true });
|
||||
return;
|
||||
}
|
||||
|
||||
if (url.pathname === '/api/worktrees' && req.method === 'GET') {
|
||||
if (!requireAuth(req, res)) return;
|
||||
const worktrees = listWorktrees(ROOT);
|
||||
json(res, 200, { worktrees });
|
||||
return;
|
||||
}
|
||||
|
||||
// === BRIEFING ROUTE ===
|
||||
|
||||
if (url.pathname === '/api/briefing' && req.method === 'GET') {
|
||||
// Use cached data if available, otherwise collect fresh
|
||||
if (!cachedData) cachedData = await collectData(true);
|
||||
const authenticated = isAuthorized(req);
|
||||
const briefing = await generateBriefing(ROOT, CACHE_DIR, {
|
||||
sessionData: cachedData.sessionData,
|
||||
suggestions: cachedData.suggestions,
|
||||
backlog: cachedData.backlog,
|
||||
// Only pass agent jobs for authenticated callers
|
||||
agentJobs: authenticated ? getJobs(CACHE_DIR) : null,
|
||||
});
|
||||
if (!authenticated) {
|
||||
// Strip all agent-job-derived fields from unauthenticated responses
|
||||
const { agentResults: _a, deadJobs: _d, stats: _s, autoQueueSuggestions: _q, ...publicBriefing } = briefing;
|
||||
json(res, 200, publicBriefing);
|
||||
} else {
|
||||
json(res, 200, briefing);
|
||||
}
|
||||
return;
|
||||
}
|
||||
|
||||
// === DASHBOARD HTML ===
|
||||
|
||||
if (url.pathname === '/' || url.pathname === '/index.html') {
|
||||
const html = readFileSync(resolve(__dirname, 'dashboard.html'), 'utf8');
|
||||
res.writeHead(200, { 'Content-Type': 'text/html; charset=utf-8' });
|
||||
res.end(html);
|
||||
return;
|
||||
}
|
||||
|
||||
res.writeHead(404);
|
||||
res.end('Not found');
|
||||
} catch (err) {
|
||||
console.error(` [Server] ${req.method} ${url.pathname} error:`, err);
|
||||
json(res, 500, { error: 'Internal server error' });
|
||||
}
|
||||
});
|
||||
|
||||
// Startup recovery
|
||||
async function startup() {
|
||||
console.log('\n Project Map Dashboard');
|
||||
console.log(` http://${BIND_HOST}:${PORT}?token=${AUTH_TOKEN}`);
|
||||
// Also write token to a file for programmatic access
|
||||
try {
|
||||
_writeFileSync(resolve(CACHE_DIR, 'token.txt'), AUTH_TOKEN, { mode: 0o600 });
|
||||
} catch { /* non-critical */ }
|
||||
|
||||
// Recover stale sessions
|
||||
try {
|
||||
const recovery = recoverStaleSession(ROOT, CACHE_DIR);
|
||||
if (recovery.recovered) console.log(' [Session] Recovered stale session');
|
||||
} catch (e) { console.error(' [Session] Recovery error:', e.message); }
|
||||
|
||||
// Recover orphaned agent jobs (fleet-aware — also cleans stale worktrees)
|
||||
try {
|
||||
const orphans = recoverOrphans(CACHE_DIR, ROOT);
|
||||
if (orphans.recovered > 0) console.log(` [Fleet] Recovered ${orphans.recovered} orphaned jobs`);
|
||||
} catch (e) { console.error(' [Fleet] Orphan recovery error:', e.message); }
|
||||
|
||||
// Load saved fleet config
|
||||
try {
|
||||
const prefsPath = resolve(CACHE_DIR, 'user-prefs.json');
|
||||
if (existsSync(prefsPath)) {
|
||||
const prefs = JSON.parse(readFileSync(prefsPath, 'utf8'));
|
||||
if (prefs.maxConcurrent) setMaxConcurrent(prefs.maxConcurrent);
|
||||
}
|
||||
} catch { /* use defaults */ }
|
||||
|
||||
// Prune old results
|
||||
try {
|
||||
const pruned = pruneResults(CACHE_DIR);
|
||||
if (pruned.pruned > 0) console.log(` [Agent] Pruned ${pruned.pruned} old results`);
|
||||
} catch (e) { /* silent */ }
|
||||
|
||||
// Agent health check
|
||||
try {
|
||||
const health = healthCheck();
|
||||
if (health.available) {
|
||||
console.log(` [Agent] Claude CLI available (${health.version})`);
|
||||
} else {
|
||||
console.log(' [Agent] Claude CLI not available — agent jobs disabled');
|
||||
}
|
||||
} catch { /* silent */ }
|
||||
|
||||
// Auto-process agent queue every 30 seconds (fleet-aware)
|
||||
processInterval = setInterval(async () => {
|
||||
try {
|
||||
const { jobs } = getJobs(CACHE_DIR);
|
||||
const hasQueued = jobs.some(j => j.status === 'queued');
|
||||
const activeCount = getActiveCount();
|
||||
if (hasQueued && activeCount < getMaxConcurrent()) {
|
||||
console.log(` [Fleet] Auto-processing queue (${activeCount}/${getMaxConcurrent()} active)...`);
|
||||
startDiffPoller();
|
||||
const result = await processQueue(ROOT, CACHE_DIR,
|
||||
(jobId, chunk) => {
|
||||
sse.broadcast({ type: 'job-output', jobId, chunk });
|
||||
const hints = parseActivityHints(chunk);
|
||||
for (const hint of hints) {
|
||||
sse.broadcast({ type: 'job-activity', jobId, hint: hint.hint, file: hint.file });
|
||||
}
|
||||
},
|
||||
(jobId, message) => {
|
||||
sse.broadcast({ type: 'job-warning', jobId, message });
|
||||
},
|
||||
);
|
||||
if (result.launched > 0) {
|
||||
sse.broadcast({ type: 'fleet-update', active: getActiveCount(), max: getMaxConcurrent() });
|
||||
}
|
||||
const { jobs: currentJobs } = getJobs(CACHE_DIR);
|
||||
if (!currentJobs.some(j => j.status === 'running')) stopDiffPoller();
|
||||
}
|
||||
} catch { /* silent */ }
|
||||
}, 30000);
|
||||
|
||||
console.log(' File watcher active — dashboard auto-refreshes on changes');
|
||||
console.log(` Fleet: max ${getMaxConcurrent()} concurrent agents, auto-processes every 30s\n`);
|
||||
}
|
||||
|
||||
server.listen(PORT, BIND_HOST, startup);
|
||||
|
||||
process.on('SIGINT', () => {
|
||||
if (processInterval) clearInterval(processInterval);
|
||||
stopDiffPoller();
|
||||
watcher.close();
|
||||
server.close();
|
||||
process.exit(0);
|
||||
});
|
||||
|
||||
// Exports for testing — token only available in test environment
|
||||
export function getAuthToken() {
|
||||
if (process.env.NODE_ENV !== 'test') throw new Error('Token access restricted to test environment');
|
||||
return AUTH_TOKEN;
|
||||
}
|
||||
export { isAuthorized, server, BIND_HOST };
|
||||
@@ -1,104 +0,0 @@
|
||||
import { describe, it, beforeEach, afterEach } from 'node:test';
|
||||
import assert from 'node:assert/strict';
|
||||
import { mkdirSync, rmSync, writeFileSync } from 'node:fs';
|
||||
import { resolve, dirname } from 'node:path';
|
||||
import { fileURLToPath } from 'node:url';
|
||||
import { execSync } from 'node:child_process';
|
||||
import { parseActivityHints, getJobDiff } from '../lib/agent-manager.mjs';
|
||||
|
||||
const __dirname = dirname(fileURLToPath(import.meta.url));
|
||||
const GIT_TEST_DIR = resolve(__dirname, '.test-git-diff');
|
||||
|
||||
describe('parseActivityHints', () => {
|
||||
it('extracts Go file paths', () => {
|
||||
const chunk = 'Reading Server/ws/handler.go for analysis';
|
||||
const hints = parseActivityHints(chunk);
|
||||
assert.equal(hints.length, 1);
|
||||
assert.equal(hints[0].file, 'Server/ws/handler.go');
|
||||
});
|
||||
|
||||
it('extracts TypeScript file paths', () => {
|
||||
const chunk = 'Checking Client/tauri-client/src/stores/voice.ts';
|
||||
const hints = parseActivityHints(chunk);
|
||||
assert.equal(hints.length, 1);
|
||||
assert.equal(hints[0].file, 'Client/tauri-client/src/stores/voice.ts');
|
||||
});
|
||||
|
||||
it('extracts Rust file paths', () => {
|
||||
const chunk = 'Found issue in src-tauri/src/commands.rs';
|
||||
const hints = parseActivityHints(chunk);
|
||||
assert.equal(hints.length, 1);
|
||||
assert.equal(hints[0].file, 'src-tauri/src/commands.rs');
|
||||
});
|
||||
|
||||
it('extracts multiple paths from one chunk', () => {
|
||||
const chunk = 'Comparing Server/ws/handler.go with Server/ws/conn.go';
|
||||
const hints = parseActivityHints(chunk);
|
||||
assert.equal(hints.length, 2);
|
||||
});
|
||||
|
||||
it('returns empty array when no paths found', () => {
|
||||
const hints = parseActivityHints('Just some regular text here');
|
||||
assert.deepEqual(hints, []);
|
||||
});
|
||||
|
||||
it('handles null/undefined input', () => {
|
||||
assert.deepEqual(parseActivityHints(null), []);
|
||||
assert.deepEqual(parseActivityHints(undefined), []);
|
||||
assert.deepEqual(parseActivityHints(''), []);
|
||||
});
|
||||
});
|
||||
|
||||
describe('getJobDiff', () => {
|
||||
beforeEach(() => {
|
||||
rmSync(GIT_TEST_DIR, { recursive: true, force: true });
|
||||
mkdirSync(GIT_TEST_DIR, { recursive: true });
|
||||
execSync('git init', { cwd: GIT_TEST_DIR, stdio: 'pipe' });
|
||||
execSync('git config user.email "test@test.com"', { cwd: GIT_TEST_DIR, stdio: 'pipe' });
|
||||
execSync('git config user.name "Test"', { cwd: GIT_TEST_DIR, stdio: 'pipe' });
|
||||
writeFileSync(resolve(GIT_TEST_DIR, 'file.txt'), 'original\n');
|
||||
execSync('git add . && git commit -m "init"', { cwd: GIT_TEST_DIR, stdio: 'pipe' });
|
||||
});
|
||||
|
||||
afterEach(() => {
|
||||
rmSync(GIT_TEST_DIR, { recursive: true, force: true });
|
||||
});
|
||||
|
||||
it('returns empty files when nothing changed', () => {
|
||||
const headSha = execSync('git rev-parse HEAD', { cwd: GIT_TEST_DIR, encoding: 'utf8' }).trim();
|
||||
const result = getJobDiff(GIT_TEST_DIR, headSha, []);
|
||||
assert.deepEqual(result.files, []);
|
||||
assert.deepEqual(result.diffs, {});
|
||||
});
|
||||
|
||||
it('detects modified files with +/- counts', () => {
|
||||
const headSha = execSync('git rev-parse HEAD', { cwd: GIT_TEST_DIR, encoding: 'utf8' }).trim();
|
||||
writeFileSync(resolve(GIT_TEST_DIR, 'file.txt'), 'modified\nline2\n');
|
||||
const result = getJobDiff(GIT_TEST_DIR, headSha, []);
|
||||
assert.equal(result.files.length, 1);
|
||||
assert.equal(result.files[0].path, 'file.txt');
|
||||
assert.equal(result.files[0].status, 'M');
|
||||
assert.ok(result.files[0].additions >= 1);
|
||||
assert.ok(typeof result.diffs['file.txt'] === 'string');
|
||||
assert.ok(result.diffs['file.txt'].includes('modified'));
|
||||
});
|
||||
|
||||
it('detects new files', () => {
|
||||
const headSha = execSync('git rev-parse HEAD', { cwd: GIT_TEST_DIR, encoding: 'utf8' }).trim();
|
||||
writeFileSync(resolve(GIT_TEST_DIR, 'newfile.txt'), 'brand new\n');
|
||||
const result = getJobDiff(GIT_TEST_DIR, headSha, []);
|
||||
const newFile = result.files.find(f => f.path === 'newfile.txt');
|
||||
assert.ok(newFile);
|
||||
assert.equal(newFile.status, 'A');
|
||||
});
|
||||
|
||||
it('excludes pre-existing dirty files', () => {
|
||||
const headSha = execSync('git rev-parse HEAD', { cwd: GIT_TEST_DIR, encoding: 'utf8' }).trim();
|
||||
writeFileSync(resolve(GIT_TEST_DIR, 'file.txt'), 'modified\n');
|
||||
writeFileSync(resolve(GIT_TEST_DIR, 'newfile.txt'), 'new\n');
|
||||
const result = getJobDiff(GIT_TEST_DIR, headSha, ['file.txt']);
|
||||
assert.equal(result.files.length, 1);
|
||||
assert.equal(result.files[0].path, 'newfile.txt');
|
||||
assert.ok(!result.diffs['file.txt']);
|
||||
});
|
||||
});
|
||||
@@ -1,89 +0,0 @@
|
||||
/**
|
||||
* Tests for agent-manager.mjs — verifies that a spawn failure
|
||||
* does not wedge the queue (lock must be released).
|
||||
*
|
||||
* Uses setSpawnCommand() to inject a guaranteed-nonexistent binary,
|
||||
* making the test deterministic regardless of whether Claude CLI is installed.
|
||||
*/
|
||||
import { describe, it, beforeEach, afterEach } from 'node:test';
|
||||
import assert from 'node:assert/strict';
|
||||
import { mkdirSync, rmSync } from 'node:fs';
|
||||
import { resolve, dirname } from 'node:path';
|
||||
import { fileURLToPath } from 'node:url';
|
||||
|
||||
import {
|
||||
createJob,
|
||||
processQueue,
|
||||
getJobs,
|
||||
isQueueLocked,
|
||||
resetQueueLock,
|
||||
setSpawnCommand,
|
||||
} from '../lib/agent-manager.mjs';
|
||||
|
||||
const __dirname = dirname(fileURLToPath(import.meta.url));
|
||||
const TEST_CACHE = resolve(__dirname, '.test-cache-agent');
|
||||
const FAKE_ROOT = resolve(__dirname, '.test-root-agent');
|
||||
|
||||
// A binary name that will never exist on any platform
|
||||
const NONEXISTENT_CMD = '__owncord_test_no_such_binary_12345__';
|
||||
|
||||
describe('agent queue lock recovery', () => {
|
||||
beforeEach(() => {
|
||||
mkdirSync(TEST_CACHE, { recursive: true });
|
||||
mkdirSync(FAKE_ROOT, { recursive: true });
|
||||
resetQueueLock();
|
||||
setSpawnCommand(NONEXISTENT_CMD);
|
||||
});
|
||||
|
||||
afterEach(() => {
|
||||
resetQueueLock();
|
||||
setSpawnCommand('claude');
|
||||
rmSync(TEST_CACHE, { recursive: true, force: true });
|
||||
rmSync(FAKE_ROOT, { recursive: true, force: true });
|
||||
});
|
||||
|
||||
it('releases lock after spawn error (command not found)', async () => {
|
||||
createJob(TEST_CACHE, {
|
||||
type: 'research',
|
||||
target: 'api',
|
||||
priority: 1,
|
||||
});
|
||||
|
||||
assert.equal(isQueueLocked(), false, 'lock should be free before processing');
|
||||
|
||||
// processQueue spawns the nonexistent command which will ENOENT
|
||||
const result = await processQueue(FAKE_ROOT, TEST_CACHE);
|
||||
|
||||
assert.equal(result.processed, true, 'should have attempted processing');
|
||||
assert.equal(isQueueLocked(), false, 'lock MUST be released after spawn failure');
|
||||
});
|
||||
|
||||
it('allows subsequent jobs after a failed spawn', async () => {
|
||||
createJob(TEST_CACHE, { type: 'research', target: 'ws', priority: 1 });
|
||||
|
||||
// First job will fail due to nonexistent command
|
||||
await processQueue(FAKE_ROOT, TEST_CACHE);
|
||||
assert.equal(isQueueLocked(), false, 'lock should be free after first failure');
|
||||
|
||||
// Create and process another job — should not be blocked
|
||||
createJob(TEST_CACHE, { type: 'code-review', target: 'auth', priority: 1 });
|
||||
const result2 = await processQueue(FAKE_ROOT, TEST_CACHE);
|
||||
|
||||
// It should attempt processing (not be stuck on 'locked')
|
||||
assert.notEqual(result2.reason, 'locked', 'queue should not be wedged');
|
||||
});
|
||||
|
||||
it('marks job as dead after max retries', async () => {
|
||||
createJob(TEST_CACHE, { type: 'research', target: 'db', priority: 1 });
|
||||
|
||||
// Exhaust retries (maxRetries defaults to 2)
|
||||
await processQueue(FAKE_ROOT, TEST_CACHE);
|
||||
await processQueue(FAKE_ROOT, TEST_CACHE);
|
||||
|
||||
const { jobs } = getJobs(TEST_CACHE);
|
||||
const job = jobs.find(j => j.target === 'db');
|
||||
assert.ok(job, 'job should still exist in queue');
|
||||
assert.equal(job.status, 'dead', 'job should be dead after max retries');
|
||||
assert.ok(job.error, 'job should have an error message');
|
||||
});
|
||||
});
|
||||
@@ -1,80 +0,0 @@
|
||||
/**
|
||||
* Tests for backlog-parser.mjs — verifies both task syntaxes are parsed
|
||||
* and open/done counts match.
|
||||
*/
|
||||
import { describe, it } from 'node:test';
|
||||
import assert from 'node:assert/strict';
|
||||
import { readFileSync, existsSync } from 'node:fs';
|
||||
import { resolve, dirname } from 'node:path';
|
||||
import { fileURLToPath } from 'node:url';
|
||||
|
||||
const __dirname = dirname(fileURLToPath(import.meta.url));
|
||||
const ROOT = resolve(__dirname, '../../..');
|
||||
|
||||
// Direct regex test (same regex the parser uses)
|
||||
const TASK_RE = /^- \[([ x])\] \*\*T-(\d+)(?::\*\*|\*\*:)\s*(.+)/;
|
||||
|
||||
describe('backlog parser regex', () => {
|
||||
it('matches colon-inside-bold format: **T-165:**', () => {
|
||||
const line = '- [x] **T-165:** Fix BUG-046 — wrap voice switchActiveDevice — 2026-03-28';
|
||||
const m = line.match(TASK_RE);
|
||||
assert.ok(m, 'should match');
|
||||
assert.equal(m[1], 'x');
|
||||
assert.equal(m[2], '165');
|
||||
assert.ok(m[3].startsWith('Fix BUG-046'));
|
||||
});
|
||||
|
||||
it('matches colon-after-bold format: **T-033**:', () => {
|
||||
const line = '- [x] **T-033**: Fix voice state broadcast silent DB failures — 2026-03-21';
|
||||
const m = line.match(TASK_RE);
|
||||
assert.ok(m, 'should match');
|
||||
assert.equal(m[1], 'x');
|
||||
assert.equal(m[2], '033');
|
||||
assert.ok(m[3].startsWith('Fix voice state'));
|
||||
});
|
||||
|
||||
it('matches open tasks (unchecked)', () => {
|
||||
const line = '- [ ] **T-195:** User profile/password/session management endpoints';
|
||||
const m = line.match(TASK_RE);
|
||||
assert.ok(m, 'should match');
|
||||
assert.equal(m[1], ' ');
|
||||
assert.equal(m[2], '195');
|
||||
});
|
||||
|
||||
it('does not match non-task lines', () => {
|
||||
assert.equal('## Some Section'.match(TASK_RE), null);
|
||||
assert.equal('- Regular bullet point'.match(TASK_RE), null);
|
||||
assert.equal('- [ ] No bold task id here'.match(TASK_RE), null);
|
||||
});
|
||||
});
|
||||
|
||||
describe('backlog parser integration', () => {
|
||||
it('parses actual Backlog.md and counts match', async () => {
|
||||
const { parseBacklog } = await import('../lib/backlog-parser.mjs');
|
||||
const result = await parseBacklog(ROOT);
|
||||
|
||||
// Read the file directly and count with both regexes
|
||||
const backlogPath = resolve(ROOT, 'docs/brain/02-Tasks/Backlog.md');
|
||||
if (!existsSync(backlogPath)) {
|
||||
// Skip if file doesn't exist in CI
|
||||
return;
|
||||
}
|
||||
const content = readFileSync(backlogPath, 'utf8');
|
||||
const lines = content.split('\n');
|
||||
|
||||
let expectedOpen = 0;
|
||||
let expectedDone = 0;
|
||||
for (const line of lines) {
|
||||
const m = line.match(TASK_RE);
|
||||
if (m) {
|
||||
if (m[1] === 'x') expectedDone++;
|
||||
else expectedOpen++;
|
||||
}
|
||||
}
|
||||
|
||||
assert.equal(result.openCount, expectedOpen, `open count mismatch: got ${result.openCount}, expected ${expectedOpen}`);
|
||||
assert.equal(result.doneCount, expectedDone, `done count mismatch: got ${result.doneCount}, expected ${expectedDone}`);
|
||||
assert.ok(result.tasks.length > 0, 'should find tasks');
|
||||
assert.equal(result.tasks.length, expectedOpen + expectedDone, 'total tasks should match');
|
||||
});
|
||||
});
|
||||
@@ -1,254 +0,0 @@
|
||||
/**
|
||||
* Behavioral tests for:
|
||||
* 1. Root-level Server/*.go files normalize to 'server-root'
|
||||
* 2. Unauthenticated /api/briefing does not leak agent job data
|
||||
*/
|
||||
import { describe, it, before, after } from 'node:test';
|
||||
import assert from 'node:assert/strict';
|
||||
import { createServer } from 'node:http';
|
||||
|
||||
// ---------------------------------------------------------------------------
|
||||
// 1. Root package normalization — behavioral tests calling the real functions
|
||||
// ---------------------------------------------------------------------------
|
||||
|
||||
describe('root package normalization', () => {
|
||||
let resolveModule, fileToModule;
|
||||
|
||||
before(async () => {
|
||||
({ resolveModule } = await import('../lib/git-scanner.mjs'));
|
||||
({ fileToModule } = await import('../lib/session-manager.mjs'));
|
||||
});
|
||||
|
||||
const rootFiles = ['Server/main.go', 'Server/go.mod', 'Server/go.sum', 'Server/Makefile'];
|
||||
const subDirFiles = [
|
||||
{ path: 'Server/ws/handler.go', expected: 'ws' },
|
||||
{ path: 'Server/db/models.go', expected: 'db' },
|
||||
{ path: 'Server/auth/middleware.go', expected: 'auth' },
|
||||
];
|
||||
|
||||
for (const filePath of rootFiles) {
|
||||
it(`git-scanner: ${filePath} → server-root`, () => {
|
||||
assert.equal(resolveModule(filePath), 'server-root');
|
||||
});
|
||||
|
||||
it(`session-manager: ${filePath} → server-root`, () => {
|
||||
assert.equal(fileToModule(filePath), 'server-root');
|
||||
});
|
||||
}
|
||||
|
||||
for (const { path, expected } of subDirFiles) {
|
||||
it(`git-scanner: ${path} → ${expected}`, () => {
|
||||
assert.equal(resolveModule(path), expected);
|
||||
});
|
||||
|
||||
it(`session-manager: ${path} → ${expected}`, () => {
|
||||
assert.equal(fileToModule(path), expected);
|
||||
});
|
||||
}
|
||||
|
||||
it('git-scanner and session-manager agree on all test paths', () => {
|
||||
const all = [...rootFiles, ...subDirFiles.map(s => s.path)];
|
||||
for (const p of all) {
|
||||
assert.equal(resolveModule(p), fileToModule(p),
|
||||
`mismatch on ${p}: git-scanner=${resolveModule(p)}, session-manager=${fileToModule(p)}`);
|
||||
}
|
||||
});
|
||||
});
|
||||
|
||||
// ---------------------------------------------------------------------------
|
||||
// 2. Briefing leak — real HTTP test against the server
|
||||
// ---------------------------------------------------------------------------
|
||||
|
||||
describe('/api/briefing unauthenticated leak prevention', () => {
|
||||
let generateBriefing;
|
||||
|
||||
before(async () => {
|
||||
({ generateBriefing } = await import('../lib/morning-briefing.mjs'));
|
||||
});
|
||||
|
||||
it('generateBriefing with agentJobs=null produces no job data', async () => {
|
||||
const briefing = await generateBriefing('.', '.', {
|
||||
sessionData: null,
|
||||
suggestions: null,
|
||||
backlog: null,
|
||||
agentJobs: null,
|
||||
});
|
||||
assert.deepEqual(briefing.agentResults, [], 'agentResults should be empty');
|
||||
assert.deepEqual(briefing.deadJobs, [], 'deadJobs should be empty');
|
||||
assert.deepEqual(briefing.autoQueueSuggestions, [], 'autoQueueSuggestions should be empty when agentJobs is null');
|
||||
assert.equal(briefing.stats.completedJobs, 0);
|
||||
assert.equal(briefing.stats.deadJobs, 0);
|
||||
});
|
||||
|
||||
it('generateBriefing with agentJobs includes job data', async () => {
|
||||
const fakeJobs = {
|
||||
jobs: [
|
||||
{ id: 'j-1', type: 'research', target: 'ws', status: 'completed', completedAt: new Date().toISOString() },
|
||||
{ id: 'j-2', type: 'fix-debt', target: 'db', status: 'dead', error: 'timeout', retryCount: 3 },
|
||||
],
|
||||
};
|
||||
const briefing = await generateBriefing('.', '.', {
|
||||
sessionData: null,
|
||||
suggestions: null,
|
||||
backlog: null,
|
||||
agentJobs: fakeJobs,
|
||||
});
|
||||
assert.ok(briefing.agentResults.length > 0, 'should have agent results');
|
||||
assert.ok(briefing.deadJobs.length > 0, 'should have dead jobs');
|
||||
assert.ok(briefing.agentResults[0].id === 'j-1', 'should contain job id');
|
||||
});
|
||||
|
||||
it('server strips job fields from unauthenticated briefing response', async () => {
|
||||
// Read server source to verify the stripping logic
|
||||
const { readFileSync } = await import('node:fs');
|
||||
const { resolve, dirname } = await import('node:path');
|
||||
const { fileURLToPath } = await import('node:url');
|
||||
const __dirname = dirname(fileURLToPath(import.meta.url));
|
||||
const source = readFileSync(resolve(__dirname, '../server.mjs'), 'utf8');
|
||||
|
||||
// The /api/briefing route must check auth and strip fields
|
||||
const briefingRoute = source.slice(
|
||||
source.indexOf("url.pathname === '/api/briefing'"),
|
||||
source.indexOf("url.pathname === '/api/briefing'") + 800
|
||||
);
|
||||
assert.ok(briefingRoute.includes('isAuthorized(req)'), 'briefing route should check auth');
|
||||
assert.ok(briefingRoute.includes('agentJobs: authenticated'), 'should only pass agentJobs when authenticated');
|
||||
assert.ok(briefingRoute.includes('agentResults'), 'should strip agentResults');
|
||||
assert.ok(briefingRoute.includes('deadJobs'), 'should strip deadJobs');
|
||||
assert.ok(briefingRoute.includes('autoQueueSuggestions'), 'should strip autoQueueSuggestions');
|
||||
assert.ok(briefingRoute.includes('stats'), 'should strip stats');
|
||||
});
|
||||
|
||||
it('HTTP: unauthenticated briefing has no job fields', async () => {
|
||||
// Spin up a minimal test server that mimics the briefing route logic
|
||||
const { generateBriefing } = await import('../lib/morning-briefing.mjs');
|
||||
|
||||
const fakeJobs = {
|
||||
jobs: [
|
||||
{ id: 'j-1', type: 'research', target: 'ws', status: 'completed', completedAt: new Date().toISOString() },
|
||||
{ id: 'j-2', type: 'fix-debt', target: 'db', status: 'dead', error: 'timeout', retryCount: 3 },
|
||||
],
|
||||
};
|
||||
|
||||
const TOKEN = 'test-secret-token';
|
||||
|
||||
const srv = createServer(async (req, res) => {
|
||||
const authenticated = (req.headers['authorization'] || '') === `Bearer ${TOKEN}`;
|
||||
const briefing = await generateBriefing('.', '.', {
|
||||
sessionData: null,
|
||||
suggestions: null,
|
||||
backlog: null,
|
||||
agentJobs: authenticated ? fakeJobs : null,
|
||||
});
|
||||
let payload;
|
||||
if (!authenticated) {
|
||||
const { agentResults: _a, deadJobs: _d, stats: _s, autoQueueSuggestions: _q, ...pub } = briefing;
|
||||
payload = pub;
|
||||
} else {
|
||||
payload = briefing;
|
||||
}
|
||||
res.writeHead(200, { 'Content-Type': 'application/json' });
|
||||
res.end(JSON.stringify(payload));
|
||||
});
|
||||
|
||||
await new Promise(r => srv.listen(0, '127.0.0.1', r));
|
||||
const port = srv.address().port;
|
||||
|
||||
try {
|
||||
// Unauthenticated request
|
||||
const unauthRes = await fetch(`http://127.0.0.1:${port}/api/briefing`);
|
||||
const unauthData = await unauthRes.json();
|
||||
|
||||
assert.equal(unauthData.agentResults, undefined, 'agentResults must not be present');
|
||||
assert.equal(unauthData.deadJobs, undefined, 'deadJobs must not be present');
|
||||
assert.equal(unauthData.stats, undefined, 'stats must not be present');
|
||||
assert.equal(unauthData.autoQueueSuggestions, undefined, 'autoQueueSuggestions must not be present');
|
||||
assert.ok(unauthData.greeting, 'greeting should still be present');
|
||||
assert.ok(unauthData.suggestedTasks !== undefined, 'suggestedTasks should still be present');
|
||||
|
||||
// Authenticated request — should have all fields
|
||||
const authRes = await fetch(`http://127.0.0.1:${port}/api/briefing`, {
|
||||
headers: { Authorization: `Bearer ${TOKEN}` },
|
||||
});
|
||||
const authData = await authRes.json();
|
||||
|
||||
assert.ok(Array.isArray(authData.agentResults), 'authenticated should have agentResults');
|
||||
assert.ok(Array.isArray(authData.deadJobs), 'authenticated should have deadJobs');
|
||||
assert.ok(authData.stats, 'authenticated should have stats');
|
||||
assert.ok(authData.agentResults.length > 0, 'authenticated should have job data');
|
||||
} finally {
|
||||
srv.close();
|
||||
}
|
||||
});
|
||||
|
||||
it('HTTP: unauthenticated /api/data strips job fields from embedded briefing', async () => {
|
||||
const { generateBriefing } = await import('../lib/morning-briefing.mjs');
|
||||
|
||||
const fakeJobs = {
|
||||
jobs: [
|
||||
{ id: 'j-1', type: 'research', target: 'ws', status: 'completed', completedAt: new Date().toISOString() },
|
||||
{ id: 'j-2', type: 'fix-debt', target: 'db', status: 'dead', error: 'timeout', retryCount: 3 },
|
||||
],
|
||||
};
|
||||
|
||||
const TOKEN = 'test-data-token';
|
||||
|
||||
// Simulate the /api/data route logic with an embedded briefing
|
||||
const srv = createServer(async (req, res) => {
|
||||
const authenticated = (req.headers['authorization'] || '') === `Bearer ${TOKEN}`;
|
||||
|
||||
// Build a cachedData-like object with briefing containing job data
|
||||
const briefing = await generateBriefing('.', '.', {
|
||||
sessionData: null,
|
||||
suggestions: null,
|
||||
backlog: null,
|
||||
agentJobs: fakeJobs,
|
||||
});
|
||||
const cachedData = { modules: [], agentJobs: fakeJobs, briefing, timestamp: new Date().toISOString() };
|
||||
|
||||
let payload;
|
||||
if (!authenticated) {
|
||||
const { agentJobs: _stripped, briefing: fullBriefing, ...publicData } = cachedData;
|
||||
if (fullBriefing) {
|
||||
const { agentResults: _a, deadJobs: _d, stats: _s, autoQueueSuggestions: _q, ...publicBriefing } = fullBriefing;
|
||||
publicData.briefing = publicBriefing;
|
||||
}
|
||||
payload = publicData;
|
||||
} else {
|
||||
payload = cachedData;
|
||||
}
|
||||
res.writeHead(200, { 'Content-Type': 'application/json' });
|
||||
res.end(JSON.stringify(payload));
|
||||
});
|
||||
|
||||
await new Promise(r => srv.listen(0, '127.0.0.1', r));
|
||||
const port = srv.address().port;
|
||||
|
||||
try {
|
||||
// Unauthenticated — briefing should be sanitized
|
||||
const unauthRes = await fetch(`http://127.0.0.1:${port}/api/data`);
|
||||
const unauthData = await unauthRes.json();
|
||||
|
||||
assert.equal(unauthData.agentJobs, undefined, 'agentJobs must not be present');
|
||||
assert.ok(unauthData.briefing, 'briefing should still exist');
|
||||
assert.equal(unauthData.briefing.agentResults, undefined, 'briefing.agentResults must not be present');
|
||||
assert.equal(unauthData.briefing.deadJobs, undefined, 'briefing.deadJobs must not be present');
|
||||
assert.equal(unauthData.briefing.stats, undefined, 'briefing.stats must not be present');
|
||||
assert.equal(unauthData.briefing.autoQueueSuggestions, undefined, 'briefing.autoQueueSuggestions must not be present');
|
||||
assert.ok(unauthData.briefing.greeting, 'briefing.greeting should remain');
|
||||
|
||||
// Authenticated — full data
|
||||
const authRes = await fetch(`http://127.0.0.1:${port}/api/data`, {
|
||||
headers: { Authorization: `Bearer ${TOKEN}` },
|
||||
});
|
||||
const authData = await authRes.json();
|
||||
|
||||
assert.ok(authData.agentJobs, 'authenticated should have agentJobs');
|
||||
assert.ok(authData.briefing.agentResults, 'authenticated briefing should have agentResults');
|
||||
assert.ok(authData.briefing.deadJobs, 'authenticated briefing should have deadJobs');
|
||||
assert.ok(authData.briefing.stats, 'authenticated briefing should have stats');
|
||||
} finally {
|
||||
srv.close();
|
||||
}
|
||||
});
|
||||
});
|
||||
@@ -1,58 +0,0 @@
|
||||
/**
|
||||
* Tests for server cache behavior — verifies that quick-mode cached data
|
||||
* is not incorrectly reused for full-mode requests.
|
||||
*/
|
||||
import { describe, it } from 'node:test';
|
||||
import assert from 'node:assert/strict';
|
||||
|
||||
describe('server cache mode awareness', () => {
|
||||
it('source code has mode-aware cache logic', async () => {
|
||||
const { readFileSync } = await import('node:fs');
|
||||
const { resolve, dirname } = await import('node:path');
|
||||
const { fileURLToPath } = await import('node:url');
|
||||
|
||||
const __dirname = dirname(fileURLToPath(import.meta.url));
|
||||
const source = readFileSync(resolve(__dirname, '../server.mjs'), 'utf8');
|
||||
|
||||
// Should track cache mode separately
|
||||
assert.ok(source.includes('cachedDataMode'), 'should have cachedDataMode variable');
|
||||
|
||||
// The /api/data handler should compare requested mode with cached mode
|
||||
assert.ok(source.includes('requestedMode'), 'should compute requestedMode');
|
||||
|
||||
// Quick cache should not be valid for full requests
|
||||
assert.ok(
|
||||
source.includes('cachedDataMode === requestedMode'),
|
||||
'should compare cached mode with requested mode'
|
||||
);
|
||||
});
|
||||
|
||||
it('cache logic prevents quick data from serving full requests', () => {
|
||||
// Simulate the cache validation logic extracted from server.mjs
|
||||
function isCacheValid(cachedData, cachedDataMode, requestedMode, hasRefresh) {
|
||||
const cacheValid = cachedData && cachedDataMode === requestedMode && !hasRefresh;
|
||||
const fullCacheForQuick = cachedData && cachedDataMode === 'full' && requestedMode === 'quick' && !hasRefresh;
|
||||
return cacheValid || fullCacheForQuick;
|
||||
}
|
||||
|
||||
const data = { some: 'data' };
|
||||
|
||||
// Quick cache should serve quick requests
|
||||
assert.ok(isCacheValid(data, 'quick', 'quick', false), 'quick cache serves quick request');
|
||||
|
||||
// Quick cache should NOT serve full requests
|
||||
assert.ok(!isCacheValid(data, 'quick', 'full', false), 'quick cache must NOT serve full request');
|
||||
|
||||
// Full cache should serve full requests
|
||||
assert.ok(isCacheValid(data, 'full', 'full', false), 'full cache serves full request');
|
||||
|
||||
// Full cache should serve quick requests (superset)
|
||||
assert.ok(isCacheValid(data, 'full', 'quick', false), 'full cache serves quick request');
|
||||
|
||||
// No cached data
|
||||
assert.ok(!isCacheValid(null, null, 'quick', false), 'no cache is not valid');
|
||||
|
||||
// Refresh flag forces re-fetch
|
||||
assert.ok(!isCacheValid(data, 'quick', 'quick', true), 'refresh flag invalidates cache');
|
||||
});
|
||||
});
|
||||
@@ -1,129 +0,0 @@
|
||||
/**
|
||||
* Tests for module name normalization — verifies that git-scanner,
|
||||
* scanner, backlog-parser, and debt-scanner all produce the same
|
||||
* canonical module keys so signals merge correctly.
|
||||
*/
|
||||
import { describe, it } from 'node:test';
|
||||
import assert from 'node:assert/strict';
|
||||
|
||||
// Import the resolveModule function from git-scanner by reading the source
|
||||
// and extracting the function (git-scanner doesn't export it).
|
||||
// Instead, we test the expected behavior by checking the patterns.
|
||||
describe('module naming consistency', () => {
|
||||
// These are the canonical module names used by scanner.mjs:
|
||||
// Go packages: 'api', 'ws', 'db', 'auth', 'config', 'admin', etc.
|
||||
// TS areas: 'lib', 'stores', 'components', 'pages', 'styles'
|
||||
// Rust: 'tauri-rust'
|
||||
|
||||
// git-scanner resolveModule should produce the SAME names (no prefixes).
|
||||
// We test this by importing the git-scanner module and checking its output.
|
||||
|
||||
it('git-scanner resolveModule produces unprefixed Go module names', async () => {
|
||||
// Read the git-scanner source and check that resolveModule for Server paths
|
||||
// no longer returns "go:" prefixed names
|
||||
const { readFileSync } = await import('node:fs');
|
||||
const { resolve, dirname } = await import('node:path');
|
||||
const { fileURLToPath } = await import('node:url');
|
||||
|
||||
const __dirname = dirname(fileURLToPath(import.meta.url));
|
||||
const source = readFileSync(resolve(__dirname, '../lib/git-scanner.mjs'), 'utf8');
|
||||
|
||||
// Ensure "go:" prefix is NOT used in resolveModule
|
||||
const resolveModuleFn = source.match(/function resolveModule\([\s\S]*?\n\}/);
|
||||
assert.ok(resolveModuleFn, 'should find resolveModule function');
|
||||
|
||||
const fnBody = resolveModuleFn[0];
|
||||
assert.ok(!fnBody.includes('`go:'), 'resolveModule should not produce go: prefixed names');
|
||||
assert.ok(!fnBody.includes('`ts:'), 'resolveModule should not produce ts: prefixed names');
|
||||
assert.ok(!fnBody.includes("'go:"), 'resolveModule should not produce go: prefixed names (single quotes)');
|
||||
assert.ok(!fnBody.includes("'ts:"), 'resolveModule should not produce ts: prefixed names (single quotes)');
|
||||
});
|
||||
|
||||
it('session-manager fileToModule matches git-scanner convention', async () => {
|
||||
const { readFileSync } = await import('node:fs');
|
||||
const { resolve, dirname } = await import('node:path');
|
||||
const { fileURLToPath } = await import('node:url');
|
||||
|
||||
const __dirname = dirname(fileURLToPath(import.meta.url));
|
||||
const sessionSource = readFileSync(resolve(__dirname, '../lib/session-manager.mjs'), 'utf8');
|
||||
const gitSource = readFileSync(resolve(__dirname, '../lib/git-scanner.mjs'), 'utf8');
|
||||
|
||||
// Both should use 'server-root' for Server/ root, not 'go:root'
|
||||
assert.ok(sessionSource.includes("'server-root'"), 'session-manager should use server-root');
|
||||
assert.ok(gitSource.includes("'server-root'"), 'git-scanner should use server-root');
|
||||
|
||||
// Both should use 'client-config' not 'ts:config'
|
||||
assert.ok(sessionSource.includes("'client-config'"), 'session-manager should use client-config');
|
||||
assert.ok(gitSource.includes("'client-config'"), 'git-scanner should use client-config');
|
||||
});
|
||||
|
||||
it('backlog and scanner module names have no type prefixes', async () => {
|
||||
const { readFileSync } = await import('node:fs');
|
||||
const { resolve, dirname } = await import('node:path');
|
||||
const { fileURLToPath } = await import('node:url');
|
||||
|
||||
const __dirname = dirname(fileURLToPath(import.meta.url));
|
||||
const backlogSource = readFileSync(resolve(__dirname, '../lib/backlog-parser.mjs'), 'utf8');
|
||||
|
||||
// Backlog MODULE_KEYWORDS keys should be plain names
|
||||
const keyMatch = backlogSource.match(/const MODULE_KEYWORDS = \{([\s\S]*?)\n\};/);
|
||||
assert.ok(keyMatch, 'should find MODULE_KEYWORDS');
|
||||
|
||||
// Ensure no prefixed keys
|
||||
assert.ok(!keyMatch[1].includes("'go:"), 'backlog keywords should not have go: prefix');
|
||||
assert.ok(!keyMatch[1].includes("'ts:"), 'backlog keywords should not have ts: prefix');
|
||||
});
|
||||
|
||||
it('suggestion engine merges modules from different sources under same key', async () => {
|
||||
const { generateSuggestions } = await import('../lib/suggestion-engine.mjs');
|
||||
const { mkdirSync, rmSync } = await import('node:fs');
|
||||
const { resolve, dirname } = await import('node:path');
|
||||
const { fileURLToPath } = await import('node:url');
|
||||
|
||||
const __dirname = dirname(fileURLToPath(import.meta.url));
|
||||
const tmpCache = resolve(__dirname, '.test-cache-naming');
|
||||
mkdirSync(tmpCache, { recursive: true });
|
||||
|
||||
try {
|
||||
// Simulate data from different sources all using 'components' (not 'ts:components')
|
||||
const result = await generateSuggestions(tmpCache, {
|
||||
priorities: [{ name: 'components', coverage: 40, type: 'typescript' }],
|
||||
backlog: {
|
||||
byPhase: {
|
||||
bug: [{ id: 'T-001', description: 'UI button bug', modules: ['components'] }],
|
||||
},
|
||||
},
|
||||
gitData: {
|
||||
commitsByModule: {
|
||||
components: { count: 15, lastCommit: new Date().toISOString() },
|
||||
},
|
||||
staleness: {},
|
||||
},
|
||||
debtData: {
|
||||
summary: {
|
||||
byModule: {
|
||||
components: { markers: 3, largeFiles: 1, longFunctions: 0 },
|
||||
},
|
||||
},
|
||||
},
|
||||
});
|
||||
|
||||
// All signals should merge into a single 'components' entry
|
||||
const compSuggestion = result.suggestions.find(s => s.module === 'components');
|
||||
assert.ok(compSuggestion, 'should have a components suggestion');
|
||||
|
||||
// It should have signals from coverage, bugs, git, AND debt
|
||||
const signalTypes = new Set(compSuggestion.signals.map(s => s.signal));
|
||||
assert.ok(signalTypes.has('coverage-gap'), 'should have coverage signal');
|
||||
assert.ok(signalTypes.has('open-bug'), 'should have bug signal');
|
||||
assert.ok(signalTypes.has('high-churn'), 'should have churn signal');
|
||||
assert.ok(signalTypes.has('debt-markers'), 'should have debt signal');
|
||||
|
||||
// Verify NO 'ts:components' entry exists
|
||||
const prefixed = result.suggestions.find(s => s.module === 'ts:components');
|
||||
assert.equal(prefixed, undefined, 'should NOT have ts:components — should be merged into components');
|
||||
} finally {
|
||||
rmSync(tmpCache, { recursive: true, force: true });
|
||||
}
|
||||
});
|
||||
});
|
||||
@@ -1,73 +0,0 @@
|
||||
/**
|
||||
* Tests for server.mjs — verifies that all mutating / job / session
|
||||
* endpoints require auth and that the server binds to localhost.
|
||||
*/
|
||||
import { describe, it } from 'node:test';
|
||||
import assert from 'node:assert/strict';
|
||||
|
||||
describe('server security configuration', () => {
|
||||
// Helper — read server source once per test (stateless, no port conflict)
|
||||
async function readServerSource() {
|
||||
const { readFileSync } = await import('node:fs');
|
||||
const { resolve, dirname } = await import('node:path');
|
||||
const { fileURLToPath } = await import('node:url');
|
||||
const __dirname = dirname(fileURLToPath(import.meta.url));
|
||||
return readFileSync(resolve(__dirname, '../server.mjs'), 'utf8');
|
||||
}
|
||||
|
||||
it('binds to localhost by default', async () => {
|
||||
const source = await readServerSource();
|
||||
assert.ok(source.includes("'127.0.0.1'"), 'default bind host should be 127.0.0.1');
|
||||
assert.ok(source.includes('BIND_HOST'), 'should use BIND_HOST variable');
|
||||
assert.ok(source.includes('server.listen(PORT, BIND_HOST'), 'server.listen should include host parameter');
|
||||
});
|
||||
|
||||
it('does not use wildcard CORS', async () => {
|
||||
const source = await readServerSource();
|
||||
const corsLines = source.split('\n').filter(l => l.includes('Access-Control-Allow-Origin'));
|
||||
for (const line of corsLines) {
|
||||
assert.ok(!line.includes("'*'"), `CORS should not be wildcard: ${line.trim()}`);
|
||||
}
|
||||
});
|
||||
|
||||
it('generates an auth token on startup', async () => {
|
||||
const source = await readServerSource();
|
||||
assert.ok(source.includes('randomBytes'), 'should use crypto.randomBytes for token generation');
|
||||
assert.ok(source.includes('AUTH_TOKEN'), 'should define AUTH_TOKEN');
|
||||
assert.ok(source.includes('Bearer'), 'should use Bearer token scheme');
|
||||
});
|
||||
|
||||
// ---- Protected route checks ----
|
||||
|
||||
const protectedRoutes = [
|
||||
{ label: 'POST /api/jobs', pattern: "url.pathname === '/api/jobs' && req.method === 'POST'" },
|
||||
{ label: 'DELETE /api/jobs/:id', pattern: "deleteMatch && req.method === 'DELETE'" },
|
||||
{ label: 'GET /api/jobs/:id/result', pattern: "resultMatch && req.method === 'GET'" },
|
||||
{ label: 'POST /api/jobs/process', pattern: "url.pathname === '/api/jobs/process'" },
|
||||
{ label: 'GET /api/jobs', pattern: "url.pathname === '/api/jobs' && req.method === 'GET'" },
|
||||
{ label: 'POST /api/worked-on', pattern: "url.pathname === '/api/worked-on'" },
|
||||
{ label: 'POST /api/strategy', pattern: "url.pathname === '/api/strategy'" },
|
||||
{ label: 'POST /api/session/start', pattern: "url.pathname === '/api/session/start'" },
|
||||
{ label: 'POST /api/session/end', pattern: "url.pathname === '/api/session/end'" },
|
||||
];
|
||||
|
||||
for (const { label, pattern } of protectedRoutes) {
|
||||
it(`protects ${label} with requireAuth`, async () => {
|
||||
const source = await readServerSource();
|
||||
const idx = source.indexOf(pattern);
|
||||
assert.ok(idx !== -1, `should have handler for ${label}`);
|
||||
const routeBlock = source.slice(idx, idx + 300);
|
||||
assert.ok(routeBlock.includes('requireAuth'), `${label} should call requireAuth`);
|
||||
});
|
||||
}
|
||||
|
||||
it('strips agentJobs and briefing job fields from unauthenticated /api/data responses', async () => {
|
||||
const source = await readServerSource();
|
||||
// The /api/data handler should check isAuthorized and strip agentJobs
|
||||
assert.ok(source.includes('isAuthorized(req)'), '/api/data should check isAuthorized');
|
||||
assert.ok(source.includes('agentJobs: _stripped'), 'should destructure out agentJobs for public response');
|
||||
// Should also strip job-derived fields from the embedded briefing
|
||||
assert.ok(source.includes('briefing: fullBriefing'), 'should destructure out briefing for sanitization');
|
||||
assert.ok(source.includes('publicBriefing'), 'should rebuild a public briefing without job fields');
|
||||
});
|
||||
});
|
||||
Reference in New Issue
Block a user