pi-brain 0.1.1

package/src/ota-logger.ts

@@ -0,0 +1,132 @@
+/**
+ * Extracts OTA log input from a TurnEndEvent.
+ * Pure function — no dependency on the extension runtime.
+ */
+
+import type { OtaEntryInput } from "./types.js";
+
+interface ContentItem {
+  type: string;
+  text?: string;
+  thinking?: string;
+  name?: string;
+  arguments?: Record<string, unknown>;
+}
+
+interface TurnEndEventLike {
+  turnIndex: number;
+  message: {
+    role: string;
+    content?: unknown;
+    provider?: string;
+    model?: string;
+    timestamp?: number;
+  };
+  toolResults: {
+    toolName: string;
+    isError: boolean;
+  }[];
+}
+
+function formatArgValue(value: unknown): string {
+  if (typeof value === "string") {
+    return `"${value}"`;
+  }
+  return String(value);
+}
+
+function formatToolCallArgs(args: Record<string, unknown>): string {
+  const pairs = Object.entries(args).map(
+    ([key, val]) => `${key}: ${formatArgValue(val)}`
+  );
+  return pairs.join(", ");
+}
+
+function normalizeContent(content: unknown): ContentItem[] {
+  if (!Array.isArray(content)) {
+    return [];
+  }
+
+  return content.filter((item): item is ContentItem => {
+    if (typeof item !== "object" || item === null) {
+      return false;
+    }
+
+    const candidate = item as { type?: unknown };
+    return typeof candidate.type === "string";
+  });
+}
+
+function extractTexts(content: ContentItem[]): string {
+  const texts = content
+    .filter(
+      (item): item is ContentItem & { text: string } =>
+        item.type === "text" && typeof item.text === "string"
+    )
+    .map((item) => item.text);
+  return texts.join("\n\n");
+}
+
+function extractThinking(content: ContentItem[]): string {
+  const blocks = content
+    .filter(
+      (item): item is ContentItem & { thinking: string } =>
+        item.type === "thinking" && typeof item.thinking === "string"
+    )
+    .map((item) => item.thinking);
+  return blocks.join("\n\n");
+}
+
+function extractActions(content: ContentItem[]): string[] {
+  return content
+    .filter(
+      (item): item is ContentItem & { name: string } =>
+        item.type === "toolCall" && typeof item.name === "string"
+    )
+    .map((item) => {
+      const argsStr = item.arguments ? formatToolCallArgs(item.arguments) : "";
+      return argsStr ? `${item.name}(${argsStr})` : `${item.name}()`;
+    });
+}
+
+function extractObservations(
+  toolResults: TurnEndEventLike["toolResults"]
+): string[] {
+  return toolResults.map(
+    (tr) => `${tr.toolName}: ${tr.isError ? "error" : "success"}`
+  );
+}
+
+export function extractOtaInput(event: TurnEndEventLike): OtaEntryInput | null {
+  const { message, turnIndex, toolResults } = event;
+
+  if (message.role !== "assistant") {
+    return null;
+  }
+
+  const content = normalizeContent(message.content);
+  const thought = extractTexts(content);
+  const thinking = extractThinking(content);
+  const actions = extractActions(content);
+
+  // Skip empty turns — no text and no tool calls
+  if (!thought && !thinking && actions.length === 0) {
+    return null;
+  }
+
+  const observations = extractObservations(toolResults);
+  const model = `${message.provider ?? "unknown"}/${message.model ?? "unknown"}`;
+  const timestamp = message.timestamp
+    ? new Date(message.timestamp).toISOString()
+    : new Date().toISOString();
+
+  return {
+    turnNumber: turnIndex + 1,
+    timestamp,
+    model,
+    thought,
+    thinking,
+    actions,
+    observations,
+  };
+}

package/src/state.ts

@@ -0,0 +1,143 @@
+import * as fs from "node:fs";
+import * as path from "node:path";
+
+import { parseYaml, serializeYaml } from "./yaml.js";
+
+interface LastCommit {
+  branch: string;
+  hash: string;
+  timestamp: string;
+  summary: string;
+}
+
+interface SessionRecord {
+  file: string;
+  branch: string;
+  started: string;
+}
+
+type PersistedValue =
+  | string
+  | Record<string, string>
+  | Array<Record<string, string>>;
+
+export class MemoryState {
+  private readonly statePath: string;
+  private readonly memoryDir: string;
+  activeBranch = "main";
+  initialized = "";
+  lastCommit: LastCommit | null = null;
+  sessions: SessionRecord[] = [];
+
+  constructor(projectDir: string) {
+    this.memoryDir = path.join(projectDir, ".memory");
+    this.statePath = path.join(this.memoryDir, "state.yaml");
+  }
+
+  get isInitialized(): boolean {
+    return this.initialized !== "";
+  }
+
+  load(): void {
+    if (!fs.existsSync(this.statePath)) {
+      return;
+    }
+
+    const content = fs.readFileSync(this.statePath, "utf8");
+    if (content.trim() === "") {
+      return;
+    }
+
+    const data = parseYaml(content);
+
+    if (typeof data.active_branch === "string") {
+      this.activeBranch = data.active_branch;
+    }
+
+    if (typeof data.initialized === "string") {
+      this.initialized = data.initialized;
+    }
+
+    if (typeof data.last_commit === "object" && data.last_commit !== null) {
+      const lastCommit = data.last_commit;
+      if (!Array.isArray(lastCommit)) {
+        this.lastCommit = {
+          branch: lastCommit.branch ?? "",
+          hash: lastCommit.hash ?? "",
+          timestamp: lastCommit.timestamp ?? "",
+          summary: lastCommit.summary ?? "",
+        };
+      }
+    }
+
+    if (Array.isArray(data.sessions)) {
+      this.sessions = data.sessions
+        .map((item) => {
+          const file = item.file ?? "";
+          const branch = item.branch ?? "";
+          const started = item.started ?? "";
+          if (file === "" || branch === "" || started === "") {
+            return null;
+          }
+
+          return { file, branch, started };
+        })
+        .filter((item): item is SessionRecord => item !== null);
+    }
+  }
+
+  setActiveBranch(branch: string): void {
+    this.activeBranch = branch;
+  }
+
+  setLastCommit(
+    branch: string,
+    hash: string,
+    timestamp: string,
+    summary: string
+  ): void {
+    this.lastCommit = { branch, hash, timestamp, summary };
+  }
+
+  upsertSession(file: string, branch: string, started: string): void {
+    const existing = this.sessions.find((session) => session.file === file);
+    if (existing) {
+      existing.branch = branch;
+      if (existing.started === "") {
+        existing.started = started;
+      }
+      return;
+    }
+
+    this.sessions.push({ file, branch, started });
+  }
+
+  save(): void {
+    const data: Record<string, PersistedValue> = {
+      active_branch: this.activeBranch,
+    };
+
+    if (this.initialized) {
+      data.initialized = this.initialized;
+    }
+
+    if (this.lastCommit) {
+      data.last_commit = {
+        branch: this.lastCommit.branch,
+        hash: this.lastCommit.hash,
+        timestamp: this.lastCommit.timestamp,
+        summary: this.lastCommit.summary,
+      };
+    }
+
+    if (this.sessions.length > 0) {
+      data.sessions = this.sessions.map((session) => ({
+        file: session.file,
+        branch: session.branch,
+        started: session.started,
+      }));
+    }
+
+    fs.writeFileSync(this.statePath, serializeYaml(data));
+  }
+}

package/src/subagent.ts

@@ -0,0 +1,342 @@
+import { spawn } from "node:child_process";
+import * as fs from "node:fs";
+import * as os from "node:os";
+import * as path from "node:path";
+
+import type { SubagentResult } from "./types.js";
+import { parseYaml } from "./yaml.js";
+
+const COMMITTER_MODEL = "google-antigravity/gemini-3-flash";
+const COMMITTER_TOOLS = "read,grep,find,ls";
+
+interface AgentDefinition {
+  prompt: string;
+  model: string;
+  tools: string;
+  skills: string;
+  extensions: string;
+}
+
+/**
+ * Resolve the memory-committer agent definition from the agent definition file.
+ * Checks multiple locations to support both local development and npm installs.
+ * Parses the YAML frontmatter for properties and uses the body as the system prompt.
+ */
+function resolveAgentPrompt(): AgentDefinition {
+  const currentFile = new URL(import.meta.url).pathname;
+  const currentDir = path.dirname(currentFile);
+
+  // Possible locations for the agent definition file
+  const candidates = [
+    // Installed package: dist/ or src/ -> ../agents/ (bundled in package)
+    path.resolve(currentDir, "../agents/memory-committer.md"),
+    // Local development: src/ -> ../.pi/agents/
+    path.resolve(currentDir, "../.pi/agents/memory-committer.md"),
+    // Fallback: check if bundled alongside source
+    path.resolve(currentDir, "./agents/memory-committer.md"),
+  ];
+
+  for (const agentFile of candidates) {
+    try {
+      const content = fs.readFileSync(agentFile, "utf8");
+
+      const match = content.match(/^---\r?\n([\s\S]*?)\r?\n---\r?\n([\s\S]*)$/);
+      let frontmatter = "";
+      let prompt = content.trim();
+
+      if (match) {
+        const [, matchedFrontmatter, matchedPrompt] = match;
+        frontmatter = matchedFrontmatter;
+        prompt = matchedPrompt.trim();
+      }
+
+      let parsed: Record<string, unknown> = {};
+      if (frontmatter) {
+        try {
+          parsed = parseYaml(frontmatter) as Record<string, unknown>;
+        } catch {
+          // Ignore parse errors, fallback to defaults
+        }
+      }
+
+      return {
+        prompt,
+        model:
+          typeof parsed.model === "string" ? parsed.model : COMMITTER_MODEL,
+        tools:
+          typeof parsed.tools === "string" ? parsed.tools : COMMITTER_TOOLS,
+        skills: typeof parsed.skills === "string" ? parsed.skills : "",
+        extensions:
+          typeof parsed.extensions === "string" ? parsed.extensions : "",
+      };
+    } catch {
+      continue;
+    }
+  }
+
+  throw new Error("Could not locate memory-committer.md agent definition file");
+}
+
+export function buildCommitterTask(branch: string, summary: string): string {
+  return [
+    `Distill a memory commit for branch "${branch}".`,
+    `Summary: ${summary}`,
+    "",
+    "Read these files:",
+    "- .memory/AGENTS.md (protocol reference — read first)",
+    `- .memory/branches/${branch}/log.md (OTA trace to distill)`,
+    `- .memory/branches/${branch}/commits.md (previous commits for rolling summary)`,
+    "",
+    "Produce the three commit blocks.",
+  ].join("\n");
+}
+
+/**
+ * Extract the last assistant text from pi's JSON-mode stdout.
+ * Each line is a JSON event; we want the last message_end with role=assistant.
+ */
+export function extractFinalText(stdout: string): string {
+  let lastText = "";
+  for (const line of stdout.split("\n")) {
+    if (!line.trim()) {
+      continue;
+    }
+    try {
+      const evt = JSON.parse(line) as {
+        type?: string;
+        message?: {
+          role?: string;
+          content?: { type?: string; text?: string }[];
+        };
+      };
+      if (evt.type === "message_end" && evt.message?.role === "assistant") {
+        const texts = (evt.message.content ?? [])
+          .filter((c) => c.type === "text" && typeof c.text === "string")
+          .map((c) => c.text as string);
+        if (texts.length > 0) {
+          lastText = texts.join("\n\n");
+        }
+      }
+    } catch {
+      // Not JSON — skip
+    }
+  }
+  return lastText;
+}
+
+/**
+ * Extract the three commit blocks from subagent response text.
+ * Returns the text from "### Branch Purpose" through the end of
+ * "### This Commit's Contribution" content, stripping preamble
+ * and trailing prose.
+ */
+export function extractCommitBlocks(text: string): string | null {
+  const branchPurposeIndex = text.indexOf("### Branch Purpose");
+  if (branchPurposeIndex === -1) {
+    return null;
+  }
+
+  const progressIndex = text.indexOf("### Previous Progress Summary");
+  if (progressIndex === -1) {
+    return null;
+  }
+
+  const contributionIndex = text.indexOf("### This Commit's Contribution");
+  if (contributionIndex === -1) {
+    return null;
+  }
+
+  // Extract from "### Branch Purpose" onward
+  const fromStart = text.slice(branchPurposeIndex);
+  const lines = fromStart.split("\n");
+
+  // Find where "### This Commit's Contribution" starts, then collect
+  // content lines until we hit a blank line followed by non-content.
+  let inContribution = false;
+  let lastContentLine = 0;
+
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i];
+    if (line.startsWith("### This Commit's Contribution")) {
+      inContribution = true;
+      lastContentLine = i;
+      continue;
+    }
+
+    if (!inContribution) {
+      lastContentLine = i;
+      continue;
+    }
+
+    // In contribution block: keep content lines, stop at blank+non-blank
+    if (line.trim() === "") {
+      continue;
+    }
+
+    // Non-empty line in contribution section — is it still contribution content?
+    // If there was a blank line gap since lastContentLine, check if this
+    // looks like trailing prose (doesn't start with -, *, or indent).
+    const gapHasBlank = lines
+      .slice(lastContentLine + 1, i)
+      .some((l) => l.trim() === "");
+
+    if (
+      gapHasBlank &&
+      !line.startsWith("-") &&
+      !line.startsWith("*") &&
+      !line.startsWith(" ")
+    ) {
+      // Trailing text after the contribution block — stop here
+      break;
+    }
+
+    lastContentLine = i;
+  }
+
+  return lines
+    .slice(0, lastContentLine + 1)
+    .join("\n")
+    .trimEnd();
+}
+
+function writePromptToTempFile(prompt: string): {
+  dir: string;
+  filePath: string;
+} {
+  const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "memory-committer-"));
+  const filePath = path.join(tmpDir, "system-prompt.md");
+  fs.writeFileSync(filePath, prompt, { encoding: "utf8", mode: 0o600 });
+  return { dir: tmpDir, filePath };
+}
+
+export function spawnCommitter(
+  cwd: string,
+  task: string,
+  signal?: AbortSignal
+): Promise<SubagentResult> {
+  return new Promise((resolve) => {
+    let agentDef: AgentDefinition;
+    try {
+      agentDef = resolveAgentPrompt();
+    } catch (error: unknown) {
+      resolve({
+        text: "",
+        exitCode: 1,
+        error:
+          error instanceof Error
+            ? error.message
+            : "Failed to resolve agent definition",
+      });
+      return;
+    }
+
+    const args = [
+      "--mode",
+      "json",
+      "--no-session",
+      "--model",
+      agentDef.model,
+      "--tools",
+      agentDef.tools,
+      "-p",
+      `Task: ${task}`,
+    ];
+
+    if (agentDef.skills) {
+      const skills = agentDef.skills
+        .split(",")
+        .map((s) => s.trim())
+        .filter(Boolean);
+      for (const skill of skills) {
+        args.push("--skill", skill);
+      }
+    }
+
+    if (agentDef.extensions) {
+      const exts = agentDef.extensions
+        .split(",")
+        .map((e) => e.trim())
+        .filter(Boolean);
+      for (const ext of exts) {
+        args.push("--extension", ext);
+      }
+    }
+
+    let tmpPromptDir: string | null = null;
+    let tmpPromptPath: string | null = null;
+
+    if (agentDef.prompt) {
+      const tmp = writePromptToTempFile(agentDef.prompt);
+      tmpPromptDir = tmp.dir;
+      tmpPromptPath = tmp.filePath;
+      args.push("--append-system-prompt", tmpPromptPath);
+    }
+
+    const proc = spawn("pi", args, {
+      cwd,
+      stdio: ["ignore", "pipe", "pipe"],
+    });
+
+    let stdout = "";
+    let stderr = "";
+
+    proc.stdout.on("data", (d: Buffer) => {
+      stdout += d.toString();
+    });
+    proc.stderr.on("data", (d: Buffer) => {
+      stderr += d.toString();
+    });
+
+    const cleanup = () => {
+      if (tmpPromptPath) {
+        try {
+          fs.unlinkSync(tmpPromptPath);
+        } catch {
+          /* ignore */
+        }
+      }
+      if (tmpPromptDir) {
+        try {
+          fs.rmdirSync(tmpPromptDir);
+        } catch {
+          /* ignore */
+        }
+      }
+    };
+
+    proc.on("close", (code) => {
+      cleanup();
+      const text = extractFinalText(stdout);
+      resolve({
+        text,
+        exitCode: code ?? 1,
+        error:
+          code === 0
+            ? undefined
+            : stderr.trim() || "Subagent exited with non-zero code",
+      });
+    });
+
+    proc.on("error", (err) => {
+      cleanup();
+      resolve({
+        text: "",
+        exitCode: 1,
+        error: `Failed to spawn subagent: ${err.message}`,
+      });
+    });
+
+    if (signal) {
+      const kill = () => {
+        proc.kill("SIGTERM");
+        setTimeout(() => !proc.killed && proc.kill("SIGKILL"), 3000);
+      };
+      if (signal.aborted) {
+        kill();
+      } else {
+        signal.addEventListener("abort", kill, { once: true });
+        proc.on("close", () => signal.removeEventListener("abort", kill));
+      }
+    }
+  });
+}

package/src/types.ts

@@ -0,0 +1,22 @@
+export interface OtaEntryInput {
+  turnNumber: number;
+  timestamp: string;
+  model: string;
+  thought: string;
+  thinking: string;
+  actions: string[];
+  observations: string[];
+}
+
+export interface MemoryStatusParams {
+  level?: string;
+  branch?: string;
+  commit?: string;
+  segment?: string;
+}
+
+export interface SubagentResult {
+  text: string;
+  exitCode: number;
+  error?: string;
+}