pi-weave 0.2.4 → 0.3.0

package/src/opencode/v1.ts

@@ -0,0 +1,161 @@
+import { fileURLToPath } from "node:url";
+import type { Plugin, ToolDefinition } from "@opencode-ai/plugin";
+import { z } from "zod";
+import type { SessionMessagesResponse } from "@opencode-ai/sdk";
+import { hashContent } from "../core";
+import { createWorkspaceCommands } from "../core/workspaceCommands";
+import { WorkspaceServerController } from "../web/server/controller";
+import { openCodeSessionDigest } from "./commands";
+import { weaveTools } from "./tools";
+
+type Client = Parameters<Plugin>[0]["client"];
+type CommandResult = { lines: string[]; viewer?: { url: string; open: boolean } };
+
+// ponytail: only our flat tool schemas; use a converter if nested inputs are added.
+function legacyArgs(input: (typeof weaveTools)[number]["input"]) {
+  return Object.fromEntries(Object.entries(input.properties).map(([name, definition]) => {
+    const schema = "enum" in definition ? z.enum(definition.enum)
+      : definition.type === "array" ? z.array(z.string())
+      : definition.type === "boolean" ? z.boolean()
+      : definition.type === "number" ? z.number()
+      : z.string();
+    const described = "description" in definition ? schema.describe(definition.description) : schema;
+    return [name, (input.required as readonly string[]).includes(name) ? described : described.optional()];
+  }));
+}
+
+function modelOf(messages: SessionMessagesResponse) {
+  for (const { info, parts } of [...messages].reverse()) {
+    if (info.role === "user" && !parts.some((part) => part.type === "text" && part.metadata?.["pi-weave"])) return info.model;
+  }
+  return null;
+}
+
+export function v1SessionDigest(session: { id: string; directory: string }, messages: SessionMessagesResponse) {
+  return openCodeSessionDigest({ ...session, location: { directory: session.directory } }, messages.map(({ info, parts }) => {
+    const text = parts.filter((part) => part.type === "text" && !part.synthetic && !part.ignored)
+      .map((part) => part.type === "text" ? part.text : "").join("\n");
+    if (info.role === "user") return { type: "user", text };
+    return {
+      type: "assistant",
+      model: { providerID: info.providerID, id: info.modelID },
+      error: info.error,
+      content: parts.map((part) => part.type === "tool" ? { ...part, name: part.tool } : part),
+    };
+  }));
+}
+
+async function generate(client: Client, sessionID: string, prompt: string, signal: AbortSignal, selectedModel: string) {
+  const separator = selectedModel.indexOf("/");
+  const model = { providerID: selectedModel.slice(0, separator), modelID: selectedModel.slice(separator + 1) };
+  const { data: session } = await client.session.get({ path: { id: sessionID }, signal, throwOnError: true });
+  // The V1 SDK's legacy types omit permission, but 1.18.29's session API accepts it.
+  const body = { parentID: sessionID, title: "pi-weave scan", permission: [{ permission: "*", pattern: "*", action: "deny" }] };
+  const query = { directory: session.directory };
+  const { data: child } = await client.session.create({ body, query, throwOnError: true });
+  const path = { id: child.id };
+  let aborting: Promise<unknown> | undefined;
+  const abort = () => { aborting = client.session.abort({ path, query, throwOnError: true }).catch(() => {}); };
+  signal.addEventListener("abort", abort, { once: true });
+  try {
+    signal.throwIfAborted();
+    const { data } = await client.session.prompt({
+      path, query,
+      body: { model, parts: [{ type: "text", text: prompt }] },
+      signal,
+      throwOnError: true,
+    });
+    if (data.info.error) throw new Error(JSON.stringify(data.info.error));
+    return data.parts.filter((part) => part.type === "text").map((part) => part.text).join("\n");
+  } finally {
+    signal.removeEventListener("abort", abort);
+    await aborting;
+    await client.session.delete({ path, query, throwOnError: true });
+  }
+}
+
+export const server: Plugin = async ({ client }) => {
+  const viewer = new WorkspaceServerController();
+  const collected = new Map<string, CommandResult>();
+  const toast = (message: string, variant: "info" | "success" | "error" = "info") =>
+    client.tui.showToast({ body: { title: "pi-weave", message, variant } }).catch(() => {});
+  let lastProgress = 0;
+  const shared = createWorkspaceCommands({
+    async getSession(sessionID) {
+      const { data: session } = await client.session.get({ path: { id: sessionID }, throwOnError: true });
+      const { data: messages } = await client.session.messages({ path: { id: sessionID }, throwOnError: true });
+      const model = modelOf(messages);
+      return { id: session.id, cwd: session.directory, model: model ? `${model.providerID}/${model.modelID}` : null };
+    },
+    async getDigest(sessionID, signal) {
+      const { data: session } = await client.session.get({ path: { id: sessionID }, signal, throwOnError: true });
+      const { data: messages } = await client.session.messages({ path: { id: sessionID }, signal, throwOnError: true });
+      const relevant = messages.filter(({ parts }) => !parts.some((part) => part.type === "text" && part.metadata?.["pi-weave"]));
+      return { digest: v1SessionDigest(session, relevant), hash: hashContent(JSON.stringify(relevant)) };
+    },
+    sessionSource: (id) => `opencode:session:${id}`,
+    generate: (id, prompt, signal, model) => generate(client, id, prompt, signal, model),
+    async output(sessionID, text) {
+      const output = collected.get(sessionID);
+      if (output) { output.lines.push(text); return; }
+      await client.session.prompt({
+        path: { id: sessionID },
+        body: { noReply: true, parts: [{ type: "text", text, synthetic: true, metadata: { "pi-weave": true } }] },
+        throwOnError: true,
+      });
+    },
+  }, (status) => {
+    if (status.active && Date.now() - lastProgress < 2_000) return;
+    lastProgress = Date.now();
+    void toast(status.text, status.active ? "info" : status.text.includes("failed") ? "error" : "success");
+  }, viewer, ({ sessionID, url, open }) => {
+    const result = collected.get(sessionID);
+    if (result) result.viewer = { url, open };
+  });
+
+  return {
+    tool: Object.fromEntries(weaveTools.map((definition) => [definition.name, {
+      description: definition.description,
+      args: legacyArgs(definition.input),
+      async execute(input, context) {
+        const result = await definition.execute(input, context.directory, async (title) => context.metadata({ title }));
+        return { output: result.text, metadata: result.details };
+      },
+    } satisfies ToolDefinition])),
+    async config(config) {
+      // V1's public runtime supports skills.paths; its legacy SDK Config omits it.
+      const extended = config as typeof config & { skills?: { paths?: string[] } };
+      extended.skills ??= {};
+      extended.skills.paths = [...new Set([...(extended.skills.paths ?? []), fileURLToPath(new URL("../../skills", import.meta.url))])];
+      config.command ??= {};
+      for (const command of shared.commands) config.command[command.name] = {
+        description: command.description,
+        template: "Report the pi-weave command result below. Do not run additional tools. $ARGUMENTS",
+      };
+    },
+    async "command.execute.before"(input, output) {
+      const command = shared.commands.find((command) => command.name === input.command);
+      if (!command) return;
+      const result: CommandResult = { lines: [] };
+      collected.set(input.sessionID, result);
+      try {
+        // V1 cannot suppress the normal model reply after this hook.
+        await command.execute(input.sessionID, input.arguments);
+        const text = result.lines.join("\n") || "Scan started; completion will be reported separately.";
+        // V1 retains the original parts array after this hook; mutate it in place.
+        for (const part of output.parts) {
+          if (part.type !== "text") continue;
+          part.text = `Report this pi-weave result without running tools:\n${text}`;
+          part.synthetic = true;
+          part.metadata = { "pi-weave": true, "pi-weave-result": { text, viewer: result.viewer } };
+        }
+      } finally {
+        collected.delete(input.sessionID);
+      }
+    },
+    async dispose() {
+      await shared.cleanup();
+      await viewer.close();
+    },
+  };
+};

package/src/pi/sessionScan.ts

@@ -14,21 +14,14 @@ import {
   resolveSessionsRoot,
   resolveVaultRoot,
   runSessionScan,
+  SESSION_SCAN_SYSTEM_PROMPT,
+  formatSessionScanResult,
   type SessionScanOptions,
   type SessionScanResult,
   type SummarizeFn,
 } from "../core";
 import { createModelSummarizer, type SummarizerDeps } from "./summarize";
 
-const SESSION_SYSTEM_PROMPT = [
-  "You write durable memory notes that compact coding-agent sessions into their bottom line.",
-  "First summarize what happened, what shipped (features, files, commands, decisions), and",
-  "what went less well (dead ends, breakage, unfinished work) using concrete technical details.",
-  "Then add a '## Takeaways' section with 2–4 reusable lessons: gotchas, root causes of tricky",
-  "failures, non-obvious syntax rules, or architecture patterns a future agent can apply.",
-  "Past tense. No preamble or code fences. Omit lessons unsupported by the transcript.",
-].join("\n");
-
 const SESSION_MAX_OUTPUT_TOKENS = 3_000;
 
 /** Session summarizer over the session model, or null when none is active. */
@@ -36,7 +29,7 @@ export function createSessionSummarizer(
   ctx: Pick<ExtensionContext, "model" | "modelRegistry">,
   deps: SummarizerDeps = {},
 ): { summarize: SummarizeFn; label: string } | null {
-  return createModelSummarizer(ctx, SESSION_SYSTEM_PROMPT, SESSION_MAX_OUTPUT_TOKENS, deps);
+  return createModelSummarizer(ctx, SESSION_SCAN_SYSTEM_PROMPT, SESSION_MAX_OUTPUT_TOKENS, deps);
 }
 
 export type SessionScanOutcome =
@@ -85,21 +78,4 @@ export async function scanPiSessions(
   return { kind: "ok", result };
 }
 
-/** One-line human summary of a session-scan result (for notify output). */
-export function formatSessionScanResult(result: SessionScanResult): string {
-  const parts = [
-    `${result.written} summarized (${result.created} new, ${result.updated} updated)`,
-    `${result.skippedFresh} unchanged`,
-  ];
-  if (result.skippedEmpty > 0) parts.push(`${result.skippedEmpty} empty`);
-  if (result.skippedTooBig > 0) parts.push(`${result.skippedTooBig} skipped (size)`);
-  if (result.skippedUnreadable > 0) parts.push(`${result.skippedUnreadable} unreadable`);
-  let text = `${parts.join(", ")} — ${result.considered} sessions considered`;
-  if (result.failed.length > 0) {
-    const [failed0] = result.failed;
-    if (failed0) {
-      text += `; ${result.failed.length} failed, first: ${failed0.path}: ${failed0.error}`;
-    }
-  }
-  return text;
-}
+export { formatSessionScanResult };

package/src/pi/summarize.ts

@@ -17,7 +17,14 @@ import {
   type Model,
 } from "@earendil-works/pi-ai";
 import type { ExtensionContext } from "@earendil-works/pi-coding-agent";
-import { runDeepScan, type DeepScanOptions, type DeepScanResult, type SummarizeFn } from "../core";
+import {
+  DEEP_SCAN_SYSTEM_PROMPT,
+  formatDeepScanResult,
+  runDeepScan,
+  type DeepScanOptions,
+  type DeepScanResult,
+  type SummarizeFn,
+} from "../core";
 
 export type CompleteFn = (
   model: Model<Api>,
@@ -35,12 +42,6 @@ export interface LlmSummarizer {
   label: string;
 }
 
-const SYSTEM_PROMPT = [
-  "You write terse, navigation-oriented summaries of source files for a codebase index.",
-  "Rules: 1–3 sentences. What the file does, its outward surface (exports/routes/commands),",
-  "anything surprising (globals, side effects, generated sections). No preamble, no headings, no code fences.",
-].join("\n");
-
 const MAX_OUTPUT_TOKENS = 220;
 const REQUEST_TIMEOUT_MS = 30_000;
 
@@ -138,7 +139,7 @@ export function createLlmSummarizer(
   ctx: Pick<ExtensionContext, "model" | "modelRegistry">,
   deps: SummarizerDeps = {},
 ): LlmSummarizer | null {
-  return createModelSummarizer(ctx, SYSTEM_PROMPT, MAX_OUTPUT_TOKENS, deps);
+  return createModelSummarizer(ctx, DEEP_SCAN_SYSTEM_PROMPT, MAX_OUTPUT_TOKENS, deps);
 }
 
 export type DeepScanOutcome =
@@ -178,20 +179,4 @@ export async function deepScanRepository(
   return { kind: "ok", result };
 }
 
-/** One-line human summary of a deep-scan result (for notify output). */
-export function formatDeepScanResult(result: DeepScanResult): string {
-  const parts = [
-    `${result.written} summarized`,
-    `${result.skippedFresh} unchanged`,
-  ];
-  if (result.skippedTooBig > 0) parts.push(`${result.skippedTooBig} skipped (size/type)`);
-  if (result.pruned > 0) parts.push(`${result.pruned} pruned`);
-  let text = `${parts.join(", ")} — ${result.considered} files considered`;
-  if (result.failed.length > 0) {
-    const [failed0] = result.failed;
-    if (failed0) {
-      text += `; ${result.failed.length} failed, first: ${failed0.path}: ${failed0.error}`;
-    }
-  }
-  return text;
-}
+export { formatDeepScanResult };