portable-agent-layer 0.8.1 → 0.10.0

package/src/targets/opencode/plugin.ts

@@ -5,7 +5,6 @@
  * This plugin just wires opencode's hook API to those shared functions.
  */
 
-import { writeFileSync } from "node:fs";
 import { resolve } from "node:path";
 import type { Plugin, PluginInput } from "@opencode-ai/plugin";
 
@@ -20,25 +19,21 @@ type TranscriptMessage = { role: string; content: string };
 
 const PALPlugin: Plugin = async ({ directory, client }: PluginInput) => {
   // Pre-load shared modules
-  const { buildGreeting, buildSystemReminder } =
+  const { buildSystemReminder } =
     await lib<typeof import("../../hooks/lib/context")>("context.ts");
   const { checkBashCommand, checkFilePath } =
     await lib<typeof import("../../hooks/lib/security")>("security.ts");
-  const { paths, ensureDir } =
-    await lib<typeof import("../../hooks/lib/paths")>("paths.ts");
-  const { emitRating } =
-    await lib<typeof import("../../hooks/lib/signals")>("signals.ts");
-  const { now } = await lib<typeof import("../../hooks/lib/time")>("time.ts");
-  const { monthPath, fileTimestamp } =
-    await lib<typeof import("../../hooks/lib/time")>("time.ts");
   const { logDebug, logError } =
     await lib<typeof import("../../hooks/lib/log")>("log.ts");
 
-  // Load shared stop-orchestrator handler
+  // Load shared handlers
   const { runStopHandlers } = await lib<typeof import("../../hooks/lib/stop")>("stop.ts");
   const { captureSessionName } = await lib<
     typeof import("../../hooks/handlers/session-name")
   >("../handlers/session-name.ts");
+  const { captureRating } = await lib<typeof import("../../hooks/handlers/rating")>(
+    "../handlers/rating.ts"
+  );
 
   function partsToText(parts: Array<Record<string, unknown>>): string {
     return parts
@@ -76,59 +71,6 @@ const PALPlugin: Plugin = async ({ directory, client }: PluginInput) => {
       .filter((m) => m.content.length > 0);
   }
 
-  const { categorizeLearning } =
-    await lib<typeof import("../../hooks/lib/learning-category")>("learning-category.ts");
-
-  // Local helpers for rating (thin wrappers around shared signals)
-  function handleRating(
-    rating: number,
-    context: string,
-    source: string,
-    detailedContext?: string,
-    userMessage?: string
-  ): void {
-    emitRating(rating, context, source);
-
-    if (rating < 5) {
-      const category = categorizeLearning(context, detailedContext ?? "");
-      const dir = ensureDir(resolve(paths.sessionLearning(), monthPath()));
-      const filename = `${fileTimestamp()}_${source}-rating-${rating}_${category}.md`;
-      writeFileSync(
-        resolve(dir, filename),
-        [
-          "---",
-          `title: "${(context.slice(0, 100) || "(low rating)").replace(/"/g, '\\"')}"`,
-          `category: "${category}"`,
-          `date: "${new Date().toISOString().slice(0, 10)}"`,
-          `rating: ${rating}`,
-          `source: "${source}"`,
-          "---",
-          "",
-          "## Context",
-          context || "*(unavailable)*",
-          "",
-          ...(detailedContext ? ["## Analysis", detailedContext, ""] : []),
-        ].join("\n")
-      );
-    }
-
-    if (rating <= 3) {
-      const userPreview = userMessage?.slice(0, 400);
-      writeFileSync(
-        resolve(paths.state(), "pending-failure.json"),
-        JSON.stringify(
-          { rating, context, source, detailedContext, userPreview, ts: now() },
-          null,
-          2
-        ),
-        "utf-8"
-      );
-    }
-  }
-
-  const PRAISE_PATTERNS =
-    /^(great\s*job|nice|perfect|awesome|excellent|thanks|thank\s*you|well\s*done|good\s*job|love\s*it|amazing|brilliant|fantastic|wonderful|superb|nailed\s*it)[.!?]?$/i;
-
   return {
     // --- Per-message: Inject dynamic system reminder ---
     "experimental.chat.system.transform": async (_input, output) => {
@@ -144,7 +86,6 @@ const PALPlugin: Plugin = async ({ directory, client }: PluginInput) => {
         const { regenerateIfNeeded } =
           await lib<typeof import("../../hooks/lib/claude-md")>("claude-md.ts");
         regenerateIfNeeded();
-        console.log(buildGreeting().join("\n"));
       }
 
       if (event.type === "session.idle" || event.type === "session.diff") {
@@ -161,13 +102,15 @@ const PALPlugin: Plugin = async ({ directory, client }: PluginInput) => {
           logDebug("opencode:event", `Got ${messages.length} transcript messages`);
           if (messages.length < 2) return;
 
-          // Name session from first user message (if not already named)
-          const firstUser = messages.find((m: TranscriptMessage) => m.role === "user");
-          if (firstUser) {
-            await captureSessionName(firstUser.content, sessionID);
-          }
+          // Extract last assistant message for response caching (parity with Claude Code)
+          const lastAssistant = messages
+            .filter((m: TranscriptMessage) => m.role === "assistant")
+            .pop();
 
-          await runStopHandlers(JSON.stringify(messages), { sessionId: sessionID });
+          await runStopHandlers(JSON.stringify(messages), {
+            sessionId: sessionID,
+            lastAssistantMessage: lastAssistant?.content,
+          });
           logDebug("opencode:event", "Stop handlers complete");
         } catch (err) {
           logError("opencode:session.stop", err);
@@ -175,98 +118,19 @@ const PALPlugin: Plugin = async ({ directory, client }: PluginInput) => {
       }
     },
 
-    // --- Capture ratings from user messages ---
-    "chat.message": async (_input, output) => {
+    // --- Capture ratings + session naming from user messages (shared handlers) ---
+    "chat.message": async (input, output) => {
       const text =
         output.parts
           ?.filter((p) => p.type === "text")
           .map((p) => p.text || "")
           .join(" ") ?? "";
 
-      // Explicit rating
-      const match = text.match(
-        /(?:^|rating:?\s*|score:?\s*)(\d|10)(?:\s*(?:\/10|[-.])|$|\s)/i
-      );
-      if (match) {
-        const rating = parseInt(match[1], 10);
-        if (rating >= 1 && rating <= 10) {
-          handleRating(rating, text.slice(0, 200), "explicit", undefined, text);
-          return;
-        }
-      }
-
-      // Implicit sentiment: auto-enabled when ANTHROPIC_API_KEY is set
-      if (process.env.ANTHROPIC_API_KEY) {
-        const trimmed = text.trim();
-        if (PRAISE_PATTERNS.test(trimmed)) {
-          handleRating(8, trimmed, "implicit", undefined, trimmed);
-          return;
-        }
-
-        // Full implicit via API — only for medium-length messages
-        if (
-          trimmed.length >= 5 &&
-          trimmed.length <= 500 &&
-          !/^[/$`{]/.test(trimmed) &&
-          !trimmed.includes("\n\n")
-        ) {
-          const apiKey = process.env.ANTHROPIC_API_KEY;
-          if (apiKey) {
-            try {
-              const response = await fetch("https://api.anthropic.com/v1/messages", {
-                method: "POST",
-                headers: {
-                  "x-api-key": apiKey,
-                  "anthropic-version": "2023-06-01",
-                  "content-type": "application/json",
-                },
-                body: JSON.stringify({
-                  model: (await lib<{ HAIKU_MODEL: string }>("models")).HAIKU_MODEL,
-                  max_tokens: 100,
-                  messages: [
-                    {
-                      role: "user",
-                      content: `Rate the sentiment of this user message toward an AI assistant on a 1-10 scale (1=very negative, 5=neutral, 10=very positive). If the message has no clear sentiment toward the assistant, respond with just "neutral". Otherwise respond with just a JSON object: {"rating": N, "sentiment": "one-word"}\n\nMessage: "${trimmed.slice(0, 300)}"`,
-                    },
-                  ],
-                }),
-              });
-
-              if (response.ok) {
-                const data = (await response.json()) as {
-                  content?: Array<{ text?: string }>;
-                };
-                const rText = data?.content?.[0]?.text?.trim();
-                if (rText && rText !== "neutral") {
-                  try {
-                    const parsed = JSON.parse(rText) as {
-                      rating?: number;
-                      sentiment?: string;
-                    };
-                    if (
-                      typeof parsed.rating === "number" &&
-                      parsed.rating >= 1 &&
-                      parsed.rating <= 10 &&
-                      parsed.rating !== 5
-                    ) {
-                      handleRating(
-                        parsed.rating,
-                        `${parsed.sentiment || "inferred"}: ${trimmed.slice(0, 150)}`,
-                        "implicit",
-                        undefined,
-                        trimmed
-                      );
-                    }
-                  } catch {
-                    // Ignore parse errors
-                  }
-                }
-              }
-            } catch {
-              // Ignore API errors
-            }
-          }
-        }
+      if (text.trim()) {
+        await Promise.allSettled([
+          captureRating(text, input.sessionID),
+          captureSessionName(text, input.sessionID),
+        ]);
       }
     },
 
@@ -298,21 +162,6 @@ const PALPlugin: Plugin = async ({ directory, client }: PluginInput) => {
       }
     },
 
-    // --- Capture work state after tool use ---
-    "tool.execute.after": async (
-      input: { tool: string; sessionID: string; callID: string; args: unknown },
-      _output: { title: string; output: string; metadata: unknown }
-    ) => {
-      try {
-        writeFileSync(
-          resolve(ensureDir(paths.state()), "current-work.json"),
-          JSON.stringify({ ts: now(), tool: input.tool, cwd: directory }, null, 2)
-        );
-      } catch {
-        // Ignore write errors
-      }
-    },
-
     // --- Inject PAL_DIR into shell environment ---
     "shell.env": async (
       _input: { cwd: string; sessionID?: string; callID?: string },

package/src/tools/analyze.ts

@@ -11,6 +11,18 @@
 import { parseArgs } from "node:util";
 import { analyze } from "../hooks/lib/graduation";
 
+// ── ANSI Colors ──
+
+const c = {
+  bold: (s: string) => `\x1b[1m${s}\x1b[0m`,
+  dim: (s: string) => `\x1b[2m${s}\x1b[0m`,
+  cyan: (s: string) => `\x1b[36m${s}\x1b[0m`,
+  yellow: (s: string) => `\x1b[33m${s}\x1b[0m`,
+  green: (s: string) => `\x1b[32m${s}\x1b[0m`,
+  red: (s: string) => `\x1b[31m${s}\x1b[0m`,
+  magenta: (s: string) => `\x1b[35m${s}\x1b[0m`,
+};
+
 const { values } = parseArgs({
   args: Bun.argv.slice(2),
   options: {
@@ -24,7 +36,7 @@ if (values.help) {
   PAL Learning Analysis — unified graduation + ratings report
 
   Reads all captured failures (rating ≤3) and session learnings,
-  groups recurring patterns via Jaccard similarity on context text,
+  groups recurring patterns via Dice similarity on context text,
   and summarizes rating trends.
 
   Sections:
@@ -57,47 +69,69 @@ if (!hasPatterns && !hasRatings) {
 
 if (result.ratings) {
   const r = result.ratings;
-  console.log(`\n  Ratings: ${r.average.toFixed(1)}/10 avg (${r.total} total)`);
-  console.log(`  Low (≤4): ${r.low.count} | High (≥7): ${r.high.count}`);
+  const avgColor = r.average >= 7 ? c.green : r.average <= 4 ? c.red : c.yellow;
+  console.log(
+    `\n  ${c.bold("Ratings:")} ${avgColor(`${r.average.toFixed(1)}/10`)} avg (${r.total} total)`
+  );
+  console.log(
+    `  ${c.red(`Low (≤4): ${r.low.count}`)} | ${c.green(`High (≥7): ${r.high.count}`)}`
+  );
 }
 
 // ── Graduation Candidates ──
 
 if (result.candidates.length > 0) {
   console.log(
-    `\n  Graduation Report — ${result.candidates.length} pattern(s) detected\n`
+    `\n  ${c.bold(c.green(`Graduation Report — ${result.candidates.length} pattern(s) detected`))}\n`
   );
-  console.log("  ─────────────────────────────────────────────────\n");
+  console.log(`  ${c.dim("─────────────────────────────────────────────────")}\n`);
 
   for (const candidate of result.candidates) {
-    console.log(`  [${candidate.domain}] ${candidate.entries.length}x occurrences`);
+    console.log(
+      `  ${c.cyan(`[${candidate.domain}]`)} ${c.bold(`${candidate.entries.length}x`)} occurrences`
+    );
     console.log("");
 
     for (const entry of candidate.entries) {
       const sourceType = entry.source.startsWith("failure:") ? "failure" : "learning";
+      const tag =
+        sourceType === "failure" ? c.red(`[${sourceType}]`) : c.yellow(`[${sourceType}]`);
       console.log(
-        `    ${entry.date || "unknown"} [${sourceType}] ${entry.text.slice(0, 100)}`
+        `    ${c.dim(entry.date || "unknown")} ${tag} ${entry.text.slice(0, 100)}`
       );
     }
 
+    console.log(`\n  ${c.dim("Files:")}`);
+    for (const entry of candidate.entries) {
+      console.log(`    ${c.dim(entry.path)}`);
+    }
+
     console.log("");
-    console.log("  Target frame:", `memory/wisdom/frames/${candidate.domain}.md`);
-    console.log("  ─────────────────────────────────────────────────\n");
+    console.log(
+      `  Target frame: ${c.magenta(`memory/wisdom/frames/${candidate.domain}.md`)}`
+    );
+    console.log(`  ${c.dim("─────────────────────────────────────────────────")}\n`);
   }
 }
 
 // ── Emerging Patterns ──
 
 if (result.emerging.length > 0) {
-  console.log(`  Emerging (2x — one more to graduate)\n`);
+  console.log(`  ${c.bold(c.yellow("Emerging (2x — one more to graduate)"))}\n`);
   for (const group of result.emerging) {
-    console.log(`  [${group.domain}] ${group.entries.length}x`);
+    console.log(`  ${c.cyan(`[${group.domain}]`)} ${c.bold(`${group.entries.length}x`)}`);
     for (const entry of group.entries) {
       const sourceType = entry.source.startsWith("failure:") ? "failure" : "learning";
+      const tag =
+        sourceType === "failure" ? c.red(`[${sourceType}]`) : c.yellow(`[${sourceType}]`);
       console.log(
-        `    ${entry.date || "unknown"} [${sourceType}] ${entry.text.slice(0, 80)}`
+        `    ${c.dim(entry.date || "unknown")} ${tag} ${entry.text.slice(0, 80)}`
       );
     }
+    console.log("  Files:");
+    for (const entry of group.entries) {
+      console.log(`    ${c.dim(entry.path)}`);
+    }
     console.log("");
   }
 }
@@ -105,7 +139,7 @@ if (result.emerging.length > 0) {
 // ── Recommendations ──
 
 if (result.recommendations.length > 0) {
-  console.log("  Recommendations:\n");
+  console.log(`  ${c.bold("Recommendations:")}\n`);
   for (const rec of result.recommendations) {
     console.log(`    ${rec}`);
   }
@@ -113,6 +147,6 @@ if (result.recommendations.length > 0) {
 }
 
 if (result.candidates.length > 0) {
-  console.log("  To crystallize: add a line to the wisdom frame file.");
-  console.log("  Format: - Your principle here [CRYSTAL: 85%]\n");
+  console.log(`  To crystallize: add a line to the wisdom frame file.`);
+  console.log(`  Format: ${c.green("- Your principle here [CRYSTAL: 85%]")}\n`);
 }

package/src/tools/opinion.ts

@@ -0,0 +1,250 @@
+#!/usr/bin/env bun
+/**
+ * OpinionTracker — manage confidence-tracked opinions about the user.
+ *
+ * Called by the AI during conversation when it detects confirmations,
+ * contradictions, or new behavioral patterns.
+ *
+ * Usage:
+ *   bun run tool:opinion -- list                                      List all opinions
+ *   bun run tool:opinion -- show "statement"                          Show opinion details
+ *   bun run tool:opinion -- add "statement" [--category workflow]     Add new opinion
+ *   bun run tool:opinion -- evidence "statement" --supporting "why"   Add supporting evidence
+ *   bun run tool:opinion -- evidence "statement" --counter "why"      Add counter evidence
+ *   bun run tool:opinion -- evidence "statement" --confirmation "why" Explicit user confirmation
+ *   bun run tool:opinion -- evidence "statement" --contradiction "why" Explicit user contradiction
+ */
+
+import {
+  addEvidence,
+  createOpinion,
+  type EvidenceType,
+  findSimilarOpinion,
+  type OpinionCategory,
+  readOpinions,
+  saveOpinion,
+} from "../hooks/lib/opinions";
+
+const args = process.argv.slice(2);
+const command = args[0];
+
+const NOTIFICATION_THRESHOLD = 0.15;
+
+function flag(name: string): string | undefined {
+  const idx = args.indexOf(`--${name}`);
+  return idx !== -1 ? args[idx + 1] : undefined;
+}
+
+const c = {
+  bold: (s: string) => `\x1b[1m${s}\x1b[0m`,
+  dim: (s: string) => `\x1b[2m${s}\x1b[0m`,
+  cyan: (s: string) => `\x1b[36m${s}\x1b[0m`,
+  yellow: (s: string) => `\x1b[33m${s}\x1b[0m`,
+  green: (s: string) => `\x1b[32m${s}\x1b[0m`,
+  red: (s: string) => `\x1b[31m${s}\x1b[0m`,
+};
+
+function bar(confidence: number): string {
+  const filled = Math.round(confidence * 10);
+  return "\u2588".repeat(filled) + "\u2591".repeat(10 - filled);
+}
+
+switch (command) {
+  case "list": {
+    const opinions = readOpinions();
+    if (opinions.length === 0) {
+      console.log("\n  No opinions tracked yet.\n");
+      break;
+    }
+
+    const categories = new Map<string, typeof opinions>();
+    for (const op of opinions) {
+      const list = categories.get(op.category) ?? [];
+      list.push(op);
+      categories.set(op.category, list);
+    }
+
+    console.log(`\n  ${c.bold("Tracked Opinions")} (${opinions.length} total)\n`);
+
+    for (const [category, ops] of categories) {
+      console.log(`  ${c.cyan(category)}`);
+      for (const op of ops.sort((a, b) => b.confidence - a.confidence)) {
+        const pct = `${Math.round(op.confidence * 100)}%`;
+        const color =
+          op.confidence >= 0.85 ? c.green : op.confidence <= 0.3 ? c.red : c.yellow;
+        console.log(`    [${bar(op.confidence)}] ${color(pct)} ${op.statement}`);
+      }
+      console.log("");
+    }
+    break;
+  }
+
+  case "show": {
+    const statement = args[1];
+    if (!statement) {
+      console.error('Usage: bun run tool:opinion -- show "statement"');
+      process.exit(1);
+    }
+
+    const opinions = readOpinions();
+    const match = findSimilarOpinion(statement, opinions);
+    if (!match) {
+      console.error(`  No matching opinion found for: "${statement}"`);
+      process.exit(1);
+    }
+
+    const pct = Math.round(match.confidence * 100);
+    console.log(`\n  ${c.bold("Opinion Details")}\n`);
+    console.log(`  ${c.bold("Statement:")} ${match.statement}`);
+    console.log(`  ${c.bold("Confidence:")} [${bar(match.confidence)}] ${pct}%`);
+    console.log(`  ${c.bold("Category:")} ${match.category}`);
+    console.log(`  ${c.bold("Created:")} ${match.created}`);
+    console.log(`  ${c.bold("Updated:")} ${match.updated}`);
+    console.log(`\n  ${c.bold("Evidence")} (${match.evidence.length} items)\n`);
+
+    const supporting = match.evidence.filter(
+      (e) => e.type === "supporting" || e.type === "confirmation"
+    );
+    const counter = match.evidence.filter(
+      (e) => e.type === "counter" || e.type === "contradiction"
+    );
+
+    if (supporting.length > 0) {
+      console.log(`  ${c.green("Supporting:")}`);
+      for (const e of supporting) {
+        console.log(`    ${c.dim(e.date)} [${e.type}] ${e.source}`);
+      }
+    }
+    if (counter.length > 0) {
+      console.log(`  ${c.red("Counter:")}`);
+      for (const e of counter) {
+        console.log(`    ${c.dim(e.date)} [${e.type}] ${e.source}`);
+      }
+    }
+    console.log("");
+    break;
+  }
+
+  case "add": {
+    const statement = args[1];
+    if (!statement) {
+      console.error(
+        'Usage: bun run tool:opinion -- add "statement" [--category workflow]'
+      );
+      process.exit(1);
+    }
+
+    const category = (flag("category") || "general") as OpinionCategory;
+    const opinions = readOpinions();
+    const existing = findSimilarOpinion(statement, opinions);
+
+    if (existing) {
+      console.log(
+        `  Similar opinion already exists: "${existing.statement}" (${Math.round(existing.confidence * 100)}%)`
+      );
+      break;
+    }
+
+    const opinion = createOpinion(statement, "manual add");
+    opinion.category = category;
+    saveOpinion(opinion);
+    console.log(`  Added: "${statement}" [${category}] at 50%`);
+    break;
+  }
+
+  case "evidence": {
+    const statement = args[1];
+    if (!statement) {
+      console.error(
+        'Usage: bun run tool:opinion -- evidence "statement" --supporting "description"'
+      );
+      process.exit(1);
+    }
+
+    const opinions = readOpinions();
+    const match = findSimilarOpinion(statement, opinions);
+    if (!match) {
+      console.error(`  No matching opinion found for: "${statement}"`);
+      process.exit(1);
+    }
+
+    let evidenceType: EvidenceType | undefined;
+    let description: string | undefined;
+
+    for (const t of ["supporting", "counter", "confirmation", "contradiction"] as const) {
+      const val = flag(t);
+      if (val) {
+        evidenceType = t;
+        description = val;
+        break;
+      }
+    }
+
+    if (!evidenceType || !description) {
+      console.error(
+        "  Provide one of: --supporting, --counter, --confirmation, --contradiction"
+      );
+      process.exit(1);
+    }
+
+    const oldConfidence = match.confidence;
+    const updated = addEvidence(match, evidenceType, description);
+    saveOpinion(updated);
+
+    const shift = updated.confidence - oldConfidence;
+    const arrow = shift > 0 ? c.green("\u2191") : c.red("\u2193");
+    console.log(
+      `  ${arrow} ${Math.round(oldConfidence * 100)}% \u2192 ${Math.round(updated.confidence * 100)}% "${match.statement}"`
+    );
+    console.log(`    [${evidenceType}] ${description}`);
+
+    if (Math.abs(shift) >= NOTIFICATION_THRESHOLD) {
+      console.log(
+        `\n  ${c.bold(c.yellow("Major shift detected!"))} (${shift > 0 ? "+" : ""}${Math.round(shift * 100)}%)`
+      );
+    }
+    break;
+  }
+
+  case "--help":
+  case "-h":
+  case "help":
+  case undefined: {
+    console.log(`
+  OpinionTracker — manage confidence-tracked opinions about the user
+
+  The "statement" argument is fuzzy-matched (Dice similarity) against all
+  stored opinions. Use a few keywords from the opinion, not the exact text.
+
+  Commands:
+    list                                      List all opinions with confidence bars
+    show "keywords"                           Show opinion details + full evidence history
+    add "statement" [--category X]            Create new opinion (starts at 50%)
+    evidence "keywords" --supporting "why"    Supporting evidence (+2%)
+    evidence "keywords" --counter "why"       Counter evidence (-5%)
+    evidence "keywords" --confirmation "why"  User explicitly confirmed (+10%)
+    evidence "keywords" --contradiction "why" User explicitly contradicted (-20%)
+
+  Categories: communication, technical, workflow, general
+
+  Examples:
+    bun run tool:opinion -- list
+    bun run tool:opinion -- evidence "concise direct responses" --confirmation "User said: keep it short"
+    bun run tool:opinion -- evidence "concise direct responses" --contradiction "User asked for detailed explanation"
+    bun run tool:opinion -- add "User prefers iterative development" --category workflow
+    bun run tool:opinion -- show "iterative development"
+
+  Confidence lifecycle:
+    New opinions start at 50%. Supporting notes from reflect add +2% each.
+    Explicit confirmations jump +10%, contradictions drop -20%.
+    At >=85%, opinions are auto-injected into every session context.
+
+  Usage: bun run tool:opinion -- <command> [args]
+`);
+    break;
+  }
+
+  default:
+    console.error(`  Unknown command: ${command}. Run with --help for usage.`);
+    process.exit(1);
+}