portable-agent-layer 0.9.0 → 0.11.0

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);
+}