@oisin-ee/oisinpi 0.7.2 → 0.9.0

package/node_modules/@oisin-ee/pi-tiers/src/source.ts

@@ -0,0 +1,258 @@
+import type { Change, Health } from "./health.ts";
+import { RETIRED_MS, STALE_MS, parseOwner, retiredName, sameOwner } from "./lock.ts";
+import { emptyHealth, parseHealth, updateHealth } from "./health.ts";
+import { mkdir, open, readFile, readdir, rename, rm, stat, writeFile } from "node:fs/promises";
+import type { Owner } from "./lock.ts";
+import { getAgentDir } from "@earendil-works/pi-coding-agent";
+import path from "node:path";
+import process from "node:process";
+import { setTimeout } from "node:timers/promises";
+
+const ZERO = 0,
+  LOCK_WAIT = 25,
+  IO_TIMEOUT = 2000,
+  /**
+   * Recognizes a specific filesystem error without suppressing other failures.
+   * @param {unknown} error Failure.
+   * @param {string} code Expected code.
+   * @returns {boolean} Match.
+   */
+  hasCode = (error: unknown, code: string): boolean =>
+    error instanceof Error && "code" in error && error.code === code,
+  /**
+   * Reads optional JSON source.
+   * @param {string} file Path.
+   * @returns {Promise<string | undefined>} Source, absent only for missing files.
+   */
+  readOptional = async (file: string): Promise<string | undefined> => {
+    try {
+      return await readFile(file, "utf8");
+    } catch (error) {
+      if (hasCode(error, "ENOENT")) {
+        return undefined;
+      }
+      throw error;
+    }
+  },
+  /**
+   * Sleeps without retaining an abort listener after completion.
+   * @param {number} delay Milliseconds.
+   * @param {AbortSignal | undefined} signal Cancellation.
+   * @returns {Promise<void>} Completion.
+   */
+  wait = async (delay: number, signal?: AbortSignal): Promise<void> => {
+    await setTimeout(Math.max(ZERO, delay), undefined, { signal });
+  },
+  /**
+   * Probes process existence without treating permission failures as death.
+   * @param {number} pid Recorded process.
+   * @returns {boolean} Whether the process is gone.
+   */
+  dead = (pid: number): boolean => {
+    try {
+      process.kill(pid, ZERO);
+      return false;
+    } catch (error) {
+      return hasCode(error, "ESRCH");
+    }
+  },
+  /**
+   * Reads a complete generation, ignoring missing metadata during creation.
+   * @param {string} directory Lock directory.
+   * @returns {Promise<Owner | undefined>} Owner.
+   */
+  ownerAt = async (directory: string): Promise<Owner | undefined> => {
+    const source = await readOptional(path.join(directory, "owner.json"));
+    return source === undefined ? undefined : parseOwner(source);
+  },
+  /**
+   * Gives an abandoned empty directory stable metadata and a nonempty tombstone.
+   * @param {string} directory Lock directory.
+   * @returns {Promise<void>} Completion.
+   */
+  identifyAbandoned = async (directory: string): Promise<void> => {
+    try {
+      const details = await stat(directory);
+      if (Date.now() - details.mtimeMs > STALE_MS) {
+        await writeFile(
+          path.join(directory, "owner.json"),
+          JSON.stringify({ created_ms: Math.floor(details.mtimeMs), pid: process.pid }),
+          { flag: "wx" },
+        );
+      }
+    } catch (error) {
+      if (!hasCode(error, "ENOENT") && !hasCode(error, "EEXIST")) {
+        throw error;
+      }
+    }
+  },
+  /**
+   * Finds a stale generation, including interrupted directory creation.
+   * @param {string} directory Lock directory.
+   * @returns {Promise<Owner | undefined>} Stale owner.
+   */
+  staleOwner = async (directory: string): Promise<Owner | undefined> => {
+    const owner = await ownerAt(directory);
+    if (owner === undefined) {
+      await identifyAbandoned(directory);
+      return undefined;
+    }
+    return Date.now() - owner.created_ms > STALE_MS || dead(owner.pid) ? owner : undefined;
+  },
+  /**
+   * Retires only a stale, unchanged generation to its unique nonempty directory.
+   * @param {string} directory Lock directory.
+   * @returns {Promise<boolean>} Whether this waiter won retirement.
+   */
+  retire = async (directory: string): Promise<boolean> => {
+    const owner = await staleOwner(directory);
+    if (owner === undefined || !sameOwner(await ownerAt(directory), owner)) {
+      return false;
+    }
+    try {
+      await rename(directory, path.join(path.dirname(directory), retiredName(owner)));
+      return true;
+    } catch (error) {
+      if (hasCode(error, "ENOENT") || hasCode(error, "ENOTEMPTY") || hasCode(error, "EEXIST")) {
+        return false;
+      }
+      throw error;
+    }
+  },
+  /**
+   * Removes only retired directories outside the contention retention window.
+   * @param {string} directory State directory.
+   * @returns {Promise<void>} Completion.
+   */
+  cleanRetired = async (directory: string): Promise<void> => {
+    const entries = await readdir(directory, { withFileTypes: true });
+    await Promise.all(
+      entries
+        .filter(
+          (entry: Readonly<{ name: string; isDirectory: () => boolean }>) =>
+            entry.isDirectory() && /^retired-\d+-\d+$/u.test(entry.name),
+        )
+        .map(async (entry: Readonly<{ name: string }>) => {
+          const retired = path.join(directory, entry.name);
+          try {
+            const details = await stat(retired);
+            if (Date.now() - details.ctimeMs > RETIRED_MS) {
+              await rm(retired, { force: true, recursive: true });
+            }
+          } catch (error) {
+            if (!hasCode(error, "ENOENT")) {
+              throw error;
+            }
+          }
+        }),
+    );
+  },
+  /**
+   * Publishes complete owner metadata after exclusive directory creation.
+   * @param {string} directory Acquired directory.
+   * @returns {Promise<Owner>} Published generation.
+   */
+  publishOwner = async (directory: string): Promise<Owner> => {
+    const owner = { created_ms: Date.now(), pid: process.pid };
+    await writeFile(path.join(directory, "owner.tmp"), JSON.stringify(owner), { flag: "wx" });
+    await rename(path.join(directory, "owner.tmp"), path.join(directory, "owner.json"));
+    await cleanRetired(path.dirname(directory));
+    return owner;
+  },
+  /**
+   * Acquires a recoverable directory lock with a bounded wait.
+   * @param {string} directory Lock directory.
+   * @param {number} deadline Deadline.
+   * @returns {Promise<Owner>} Acquired generation.
+   */
+  acquire = async (directory: string, deadline: number): Promise<Owner> => {
+    try {
+      await mkdir(directory);
+    } catch (error) {
+      if (!hasCode(error, "EEXIST") || Date.now() >= deadline) {
+        throw error;
+      }
+      await retire(directory);
+      await wait(LOCK_WAIT);
+      return acquire(directory, deadline);
+    }
+    return publishOwner(directory);
+  },
+  /**
+   * Releases only the generation this transaction acquired.
+   * @param {string} directory Lock directory.
+   * @param {Owner} owner Acquired generation.
+   * @returns {Promise<void>} Completion.
+   */
+  release = async (directory: string, owner: Owner): Promise<void> => {
+    if (sameOwner(await ownerAt(directory), owner)) {
+      await rm(directory, { recursive: true });
+    }
+  };
+
+/** Atomic host-local circuit and cooldown persistence. */
+class Store {
+  readonly #directory: string;
+  readonly #file: string;
+
+  /**
+   * Selects the agent state directory.
+   * @param {string} directory State root.
+   */
+  public constructor(directory = path.join(getAgentDir(), "state", "pi-tiers")) {
+    this.#directory = directory;
+    this.#file = path.join(directory, "state.json");
+  }
+
+  /**
+   * Reads an atomic state snapshot.
+   * @returns {Promise<Health>} Current shared health.
+   */
+  public async read(): Promise<Health> {
+    const source = await readOptional(this.#file);
+    return source === undefined ? emptyHealth() : parseHealth(source);
+  }
+
+  /**
+   * Writes and syncs a temporary snapshot before atomic replacement.
+   * @param {Health} health New state.
+   * @returns {Promise<void>} Durable replacement.
+   */
+  async #write(health: Health): Promise<void> {
+    const temporary = path.join(this.#directory, `${crypto.randomUUID()}.tmp`),
+      file = await open(temporary, "wx");
+    try {
+      await file.writeFile(JSON.stringify(health));
+      await file.sync();
+      await rename(temporary, this.#file);
+    } finally {
+      await file.close();
+      await rm(temporary, { force: true });
+    }
+  }
+
+  /**
+   * Holds the lock across the entire read-modify-rename transaction.
+   * @param {Change} change Failure to record.
+   * @returns {Promise<void>} Durable completion.
+   */
+  public async change(change: Change): Promise<void> {
+    await mkdir(this.#directory, { recursive: true });
+    const lockPath = path.join(this.#directory, "lock"),
+      lock = await acquire(lockPath, Date.now() + IO_TIMEOUT);
+    try {
+      await this.#write(updateHealth(await this.read(), change));
+    } finally {
+      await release(lockPath, lock);
+    }
+  }
+}
+
+/**
+ * Reads the user-owned tier map.
+ * @returns {Promise<string | undefined>} Config source.
+ */
+const readConfig = async (): Promise<string | undefined> =>
+  readOptional(path.join(getAgentDir(), "tiers.json"));
+
+export { acquire, readConfig, release, retire, Store, wait };

package/node_modules/@oisin-ee/pi-todo/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@oisin-ee/pi-todo",
-  "version": "0.7.2",
+  "version": "0.9.0",
   "description": "A todo tool for pi with a Rust core: one active task, state on the session branch.",
   "keywords": [
     "pi-extension",

package/node_modules/@oisin-ee/pi-todo/src/contract-fixture.ts

@@ -0,0 +1,103 @@
+import type { TodoParams, TodoSession } from "./tool.ts";
+import { STATE_ENTRY } from "./state.ts";
+import type { SessionEntry } from "@earendil-works/pi-coding-agent";
+import type { TodoList } from "./wasm.ts";
+import { runTodo } from "./tool.ts";
+
+interface Fixture {
+  readonly entries: SessionEntry[];
+  readonly session: TodoSession;
+  readonly call: (params: TodoParams) => TodoList;
+}
+
+/**
+ * Creates a branch-backed caller using the real tool and WASM core.
+ * @param {readonly unknown[]} snapshots Existing stored snapshots.
+ * @returns {Fixture} The tool caller and Pi append seam.
+ */
+const first = 0,
+  second = 1,
+  third = 2,
+  last = -1,
+  fixture = (snapshots: readonly unknown[] = []): Fixture => {
+    const entries = snapshots.map((data): SessionEntry => ({
+        customType: STATE_ENTRY,
+        data,
+        id: crypto.randomUUID(),
+        parentId: null,
+        timestamp: "2026-10-20T00:00:00Z",
+        type: "custom",
+      })),
+      session: TodoSession = {
+        append: (customType, data): void => {
+          entries.push({
+            customType,
+            data,
+            id: crypto.randomUUID(),
+            parentId: entries.at(last)?.id ?? null,
+            timestamp: "2026-10-20T00:00:00Z",
+            type: "custom",
+          });
+        },
+        branch: () => entries,
+        sessionId: "test-session",
+      };
+    return { call: (params) => runTodo(params, session).details, entries, session };
+  },
+  /**
+   * A complete self-assigned contract for deterministic behavior tests.
+   * @returns {NonNullable<TodoParams["contract"]>} Authored contract fields.
+   */
+  contract = (): NonNullable<TodoParams["contract"]> => ({
+    acceptance: {
+      argv: ["moon", "run", "todo-core:test"],
+      cwd: ".",
+      expected: "passes",
+      kind: "command",
+    },
+    assignment: { kind: "self" },
+    deliverable: "Executable task contracts",
+    dependsOn: [],
+    scope: { generates: [], owns: ["src/"], reads: ["README.md"], repositoryId: "oisinpi" },
+  }),
+  /**
+   * Returns the runtime ID from the first root in a tool result.
+   * @param {TodoList} list Real tool result.
+   * @returns {string} Runtime ID.
+   */
+  firstId = (list: TodoList): string => {
+    const id = list.tasks.at(first)?.unit?.reference.unitId;
+    if (id === undefined) {
+      throw new Error("Expected a runtime unit ID");
+    }
+    return id;
+  },
+  /**
+   * Requires a root identity at a known fixture position.
+   * @param {TodoList} list Tool result.
+   * @param {number} index Root position.
+   * @returns {string} Runtime ID.
+   */
+  rootId = (list: TodoList, index: number): string => {
+    const id = list.tasks.at(index)?.unit?.reference.unitId;
+    if (id === undefined) {
+      throw new Error("Expected root identity");
+    }
+    return id;
+  },
+  /**
+   * Requires a child identity from the first outcome.
+   * @param {TodoList} list Tool result.
+   * @param {number} index Child position.
+   * @returns {string} Runtime ID.
+   */
+  childId = (list: TodoList, index: number): string => {
+    const id = list.tasks.at(first)?.subtasks?.at(index)?.unit?.reference.unitId;
+    if (id === undefined) {
+      throw new Error("Expected child identity");
+    }
+    return id;
+  };
+
+export { childId, contract, first, firstId, fixture, last, rootId, second, third };
+export type { Fixture };

package/node_modules/@oisin-ee/pi-todo/src/display.ts

@@ -41,8 +41,14 @@ const emptyCount = 0,
       active = list.tasks.flatMap((task) => [
         ...(task.status === "in_progress" ? [task.content] : []),
         ...(task.subtasks ?? [])
-          .filter((child: Readonly<Subtask>) => child.status === "in_progress")
-          .map((child: Readonly<Subtask>) => `${task.content} → ${child.content}`),
+          .filter(
+            (child: Readonly<Pick<Subtask, "content" | "status">>) =>
+              child.status === "in_progress",
+          )
+          .map(
+            (child: Readonly<Pick<Subtask, "content" | "status">>) =>
+              `${task.content} → ${child.content}`,
+          ),
       ]),
       current =
         active.length > emptyCount

package/node_modules/@oisin-ee/pi-todo/src/gate.ts

@@ -0,0 +1,79 @@
+import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+import type { TaskProvider } from "./provider.ts";
+import { ownsTodo } from "./lifecycle.ts";
+
+/** Exact structured reads and workflow controls, never command-text inference. */
+const controls = new Set([
+    "ask",
+    "codemode",
+    "interview",
+    "todo",
+    "tool_search",
+    "read",
+    "ls",
+    "find",
+    "grep",
+    "hypa_read",
+    "hypa_ls",
+    "hypa_find",
+    "hypa_grep",
+    "web_search",
+    "web_fetch",
+    "lsp_diagnostics",
+    "ctx_search",
+    "ctx_stats",
+    "mcp__codebase_memory__search_graph",
+    "mcp__codebase_memory__get_code_snippet",
+    "mcp__codebase_memory__trace_path",
+    "mcp__codebase_memory__detect_changes",
+    "hindsight_search_knowledge_pages",
+    "hindsight_list_knowledge_pages",
+    "hindsight_read_knowledge_page",
+    "hindsight_reflect",
+    "hindsight_sync_status",
+    "hindsight_diagnose",
+    "hindsight_capture_initiative",
+    "mcp__dogsled__spawn",
+    "mcp__dogsled__send",
+    "mcp__dogsled__cancel",
+    "mcp__dogsled__close",
+    "mcp__dogsled__stop",
+    "mcp__dogsled__read",
+    "mcp__dogsled__status",
+    "mcp__dogsled__inbox",
+  ]),
+  /**
+   * Checks actual calls and leases execution-bearing calls.
+   * @param {Readonly<ExtensionAPI>} pi Runtime hooks and metadata.
+   * @param {Readonly<TaskProvider>} provider Task state and leases.
+   */
+  registerGate = (
+    pi: Readonly<Pick<ExtensionAPI, "on" | "getAllTools">>,
+    provider: Readonly<TaskProvider>,
+  ): void => {
+    pi.on("tool_call", (event: Readonly<{ toolName: string; toolCallId: string }>, ctx) => {
+      if (!ownsTodo(pi)) {
+        return { block: false };
+      }
+      provider.context(ctx);
+      if (controls.has(event.toolName)) {
+        return { block: false };
+      }
+      const active = provider.capability().active();
+      if (!active.ok || active.value === null) {
+        return {
+          block: true,
+          reason: active.ok
+            ? "Start a complete self-assigned leaf with todo before shell, code, mutation, or unknown tools."
+            : active.error.message,
+        };
+      }
+      provider.lease(event.toolCallId, active.value.ref);
+      return { block: false };
+    });
+    pi.on("tool_execution_end", (event: Readonly<{ toolCallId: string }>) => {
+      provider.release(event.toolCallId);
+    });
+  };
+
+export { registerGate };