@asterxsk/kiln 0.1.0 → 0.2.0

package/agent/extensions/todo/state/state.ts

@@ -1,18 +1,18 @@
-import type { Task } from "../tool/types.js";
-
-/**
- * Canonical state for the todo tool. Single source of truth — both the reducer
- * (`state/state-reducer.ts`) and the live store cell (`state/store.ts`) read
- * this shape. Replay (`state/replay.ts`) returns a fresh `TaskState`; the
- * lifecycle handlers in `index.ts` write it via `replaceState`.
- *
- * The shape is intentionally minimal — no derived caches or runtime cells.
- * Selectors in `state/selectors.ts` are pure of `TaskState` and own all
- * derivations (visible/grouped/counted/etc).
- */
-export interface TaskState {
-	tasks: Task[];
-	nextId: number;
-}
-
-export const EMPTY_STATE: TaskState = { tasks: [], nextId: 1 };
+import type { Task } from "../tool/types.js";
+
+/**
+ * Canonical state for the todo tool. Single source of truth — both the reducer
+ * (`state/state-reducer.ts`) and the live store cell (`state/store.ts`) read
+ * this shape. Replay (`state/replay.ts`) returns a fresh `TaskState`; the
+ * lifecycle handlers in `index.ts` write it via `replaceState`.
+ *
+ * The shape is intentionally minimal — no derived caches or runtime cells.
+ * Selectors in `state/selectors.ts` are pure of `TaskState` and own all
+ * derivations (visible/grouped/counted/etc).
+ */
+export interface TaskState {
+	tasks: Task[];
+	nextId: number;
+}
+
+export const EMPTY_STATE: TaskState = { tasks: [], nextId: 1 };

package/agent/extensions/todo/state/store.ts

@@ -1,82 +1,82 @@
-import type { Task } from "../tool/types.js";
-import { EMPTY_STATE, type TaskState } from "./state.js";
-
-/**
- * Per-session live state cells, keyed by session id.
- *
- * A single module-level cell was shared between the main session and any
- * in-process subagent session in the same Node process (the extension module
- * is loaded once and cached by URL), so both sessions read/wrote and replayed
- * into the same todos. Keying by `ctx.sessionManager.getSessionId()` gives
- * every session — main or subagent — its own independent state cell.
- *
- * The store remains the single mutation seam and the reducer stays pure.
- */
-const states = new Map<string, TaskState>();
-
-/** Fresh empty state (new array instance — never share EMPTY_STATE itself). */
-export function emptyState(): TaskState {
-	return { tasks: [...EMPTY_STATE.tasks], nextId: EMPTY_STATE.nextId };
-}
-
-function cell(sessionId: string): TaskState {
-	let s = states.get(sessionId);
-	if (!s) {
-		s = emptyState();
-		states.set(sessionId, s);
-	}
-	return s;
-}
-
-/**
- * Live tasks accessor. Returned `readonly Task[]` so callers (overlay render
- * hook, `/todos` command) cannot mutate the live cell. Consumers must not cast
- * back.
- */
-export function getTodos(sessionId: string): readonly Task[] {
-	return cell(sessionId).tasks;
-}
-
-export function getNextId(sessionId: string): number {
-	return cell(sessionId).nextId;
-}
-
-/** Snapshot accessor used by reducer callers to pass canonical state in. */
-export function getState(sessionId: string): TaskState {
-	return cell(sessionId);
-}
-
-/**
- * Replay seam. Lifecycle handlers in `index.ts` call this on
- * `session_start` / `session_compact` / `session_tree` after
- * `replayFromBranch` decodes the latest snapshot.
- */
-export function replaceState(sessionId: string, next: TaskState): void {
-	states.set(sessionId, next);
-}
-
-/**
- * Post-reducer commit seam. Tool execute() calls this with the reducer's
- * `state` output to publish the new canonical state to live readers (overlay,
- * `/todos`).
- */
-export function commitState(sessionId: string, next: TaskState): void {
-	states.set(sessionId, next);
-}
-
-/**
- * Drop a session's cell (called on session_shutdown so cells for ended
- * subagent sessions don't accumulate for the life of the process).
- */
-export function dropState(sessionId: string): void {
-	states.delete(sessionId);
-}
-
-/**
- * Test-setup reset. Wired into the global `test/setup.ts` `beforeEach` via
- * the existing `__resetState` import path. Name preserved verbatim — see
- * Plan §Decisions §Decision 7.
- */
-export function __resetState(): void {
-	states.clear();
-}
+import type { Task } from "../tool/types.js";
+import { EMPTY_STATE, type TaskState } from "./state.js";
+
+/**
+ * Per-session live state cells, keyed by session id.
+ *
+ * A single module-level cell was shared between the main session and any
+ * in-process subagent session in the same Node process (the extension module
+ * is loaded once and cached by URL), so both sessions read/wrote and replayed
+ * into the same todos. Keying by `ctx.sessionManager.getSessionId()` gives
+ * every session — main or subagent — its own independent state cell.
+ *
+ * The store remains the single mutation seam and the reducer stays pure.
+ */
+const states = new Map<string, TaskState>();
+
+/** Fresh empty state (new array instance — never share EMPTY_STATE itself). */
+export function emptyState(): TaskState {
+	return { tasks: [...EMPTY_STATE.tasks], nextId: EMPTY_STATE.nextId };
+}
+
+function cell(sessionId: string): TaskState {
+	let s = states.get(sessionId);
+	if (!s) {
+		s = emptyState();
+		states.set(sessionId, s);
+	}
+	return s;
+}
+
+/**
+ * Live tasks accessor. Returned `readonly Task[]` so callers (overlay render
+ * hook, `/todos` command) cannot mutate the live cell. Consumers must not cast
+ * back.
+ */
+export function getTodos(sessionId: string): readonly Task[] {
+	return cell(sessionId).tasks;
+}
+
+export function getNextId(sessionId: string): number {
+	return cell(sessionId).nextId;
+}
+
+/** Snapshot accessor used by reducer callers to pass canonical state in. */
+export function getState(sessionId: string): TaskState {
+	return cell(sessionId);
+}
+
+/**
+ * Replay seam. Lifecycle handlers in `index.ts` call this on
+ * `session_start` / `session_compact` / `session_tree` after
+ * `replayFromBranch` decodes the latest snapshot.
+ */
+export function replaceState(sessionId: string, next: TaskState): void {
+	states.set(sessionId, next);
+}
+
+/**
+ * Post-reducer commit seam. Tool execute() calls this with the reducer's
+ * `state` output to publish the new canonical state to live readers (overlay,
+ * `/todos`).
+ */
+export function commitState(sessionId: string, next: TaskState): void {
+	states.set(sessionId, next);
+}
+
+/**
+ * Drop a session's cell (called on session_shutdown so cells for ended
+ * subagent sessions don't accumulate for the life of the process).
+ */
+export function dropState(sessionId: string): void {
+	states.delete(sessionId);
+}
+
+/**
+ * Test-setup reset. Wired into the global `test/setup.ts` `beforeEach` via
+ * the existing `__resetState` import path. Name preserved verbatim — see
+ * Plan §Decisions §Decision 7.
+ */
+export function __resetState(): void {
+	states.clear();
+}

package/agent/extensions/todo/state/task-graph.ts

@@ -1,57 +1,57 @@
-import type { Task } from "../tool/types.js";
-
-/**
- * Detect whether merging `newBlockedBy` into `taskId`'s `blockedBy` set would
- * introduce a cycle in the dependency graph.
- *
- * Pure of any module state; takes the existing `taskList` and the proposed
- * additions explicitly so the reducer can ask "would this update cycle?"
- * without mutating state first.
- */
-export function detectCycle(taskList: readonly Task[], taskId: number, newBlockedBy: readonly number[]): boolean {
-	const edges = new Map<number, number[]>();
-	for (const t of taskList) {
-		if (t.id === taskId) {
-			const merged = new Set([...(t.blockedBy ?? []), ...newBlockedBy]);
-			edges.set(t.id, [...merged]);
-		} else {
-			edges.set(t.id, t.blockedBy ? [...t.blockedBy] : []);
-		}
-	}
-
-	const visiting = new Set<number>();
-	const visited = new Set<number>();
-	const hasCycleFrom = (node: number): boolean => {
-		if (visiting.has(node)) return true;
-		if (visited.has(node)) return false;
-		visiting.add(node);
-		for (const nb of edges.get(node) ?? []) {
-			if (hasCycleFrom(nb)) return true;
-		}
-		visiting.delete(node);
-		visited.add(node);
-		return false;
-	};
-
-	for (const node of edges.keys()) {
-		if (hasCycleFrom(node)) return true;
-	}
-	return false;
-}
-
-/**
- * Build the inverse adjacency map: for each task `T`, which other tasks list
- * `T` in their `blockedBy`. Consumed by `selectShowTaskIds` (overlay gating)
- * and the `get` action's "blocks: #x, #y" suffix line.
- */
-export function deriveBlocks(taskList: readonly Task[]): Map<number, number[]> {
-	const blocks = new Map<number, number[]>();
-	for (const t of taskList) {
-		for (const dep of t.blockedBy ?? []) {
-			const arr = blocks.get(dep) ?? [];
-			arr.push(t.id);
-			blocks.set(dep, arr);
-		}
-	}
-	return blocks;
-}
+import type { Task } from "../tool/types.js";
+
+/**
+ * Detect whether merging `newBlockedBy` into `taskId`'s `blockedBy` set would
+ * introduce a cycle in the dependency graph.
+ *
+ * Pure of any module state; takes the existing `taskList` and the proposed
+ * additions explicitly so the reducer can ask "would this update cycle?"
+ * without mutating state first.
+ */
+export function detectCycle(taskList: readonly Task[], taskId: number, newBlockedBy: readonly number[]): boolean {
+	const edges = new Map<number, number[]>();
+	for (const t of taskList) {
+		if (t.id === taskId) {
+			const merged = new Set([...(t.blockedBy ?? []), ...newBlockedBy]);
+			edges.set(t.id, [...merged]);
+		} else {
+			edges.set(t.id, t.blockedBy ? [...t.blockedBy] : []);
+		}
+	}
+
+	const visiting = new Set<number>();
+	const visited = new Set<number>();
+	const hasCycleFrom = (node: number): boolean => {
+		if (visiting.has(node)) return true;
+		if (visited.has(node)) return false;
+		visiting.add(node);
+		for (const nb of edges.get(node) ?? []) {
+			if (hasCycleFrom(nb)) return true;
+		}
+		visiting.delete(node);
+		visited.add(node);
+		return false;
+	};
+
+	for (const node of edges.keys()) {
+		if (hasCycleFrom(node)) return true;
+	}
+	return false;
+}
+
+/**
+ * Build the inverse adjacency map: for each task `T`, which other tasks list
+ * `T` in their `blockedBy`. Consumed by `selectShowTaskIds` (overlay gating)
+ * and the `get` action's "blocks: #x, #y" suffix line.
+ */
+export function deriveBlocks(taskList: readonly Task[]): Map<number, number[]> {
+	const blocks = new Map<number, number[]>();
+	for (const t of taskList) {
+		for (const dep of t.blockedBy ?? []) {
+			const arr = blocks.get(dep) ?? [];
+			arr.push(t.id);
+			blocks.set(dep, arr);
+		}
+	}
+	return blocks;
+}