pi-mood 0.1.0

package/README.md

@@ -0,0 +1,58 @@
+# pi-mood
+
+Periodic rule reminders injected as system messages into LLM context. Rules are
+extracted from your AGENTS.md — no duplication.
+
+## How it works
+
+Reads `~/.pi/agent/AGENTS.md` and `<cwd>/AGENTS.md`, parses headings annotated
+with `@N`, and injects the rule text as a persistent system message between LLM
+calls. Rules are selected with weighted probability and a cooldown to avoid
+repetition.
+
+Headings without `@N` are ignored. Any heading level works (`##`, `###`, etc.).
+Parent sections include their subsection headings and bodies.
+
+```markdown
+## Design review @5
+
+Before any change, write a design brief and send to reviewer. If trivial, show
+brief to user and request skip.
+
+### What should be in the brief @3
+
+...
+```
+
+- `@5` — weight. Higher = selected more often.
+- After selection, the rule's effective weight is halved for the next pick
+  (2^(-times_shown)).
+- Rules are injected every `MOOD_EVERY` LLM calls (default 5).
+
+## Status bar
+
+```
+mood: — · — · —                          (fresh start)
+mood: 1.2kt · now · «Design review»      (just injected)
+mood: 3.5kt · 4 ago · «Say it straight»  (between injections)
+```
+
+Three pieces, always two separators. Tokens, time since last injection, current
+rule. Restored from session on resume.
+
+## Install
+
+```bash
+pi install ~/git/pi-mood
+```
+
+## Config
+
+- `MOOD_EVERY` — environment variable, default 5. Inject rule every N LLM
+  calls.
+
+## Tests
+
+```bash
+npx tsx test.ts
+```

package/mood.ts

@@ -0,0 +1,228 @@
+import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+import { estimateTokens } from "@earendil-works/pi-coding-agent";
+import { readFile } from "node:fs/promises";
+import { join } from "node:path";
+import { existsSync } from "node:fs";
+import { homedir } from "node:os";
+
+interface Rule {
+  heading: string;
+  weight: number;
+  body: string;
+}
+
+function parse(content: string): Rule[] {
+  const lines = content.split("\n");
+  const rules: Rule[] = [];
+  const stack: { heading: string; weight: number; body: string[]; level: number }[] = [];
+
+  function popUntil(level: number) {
+    while (stack.length > 0 && stack[stack.length - 1].level >= level) {
+      const s = stack.pop()!;
+      const body = s.body.join("\n").trim();
+      if (body.length > 0 && s.weight > 0) {
+        rules.push({ heading: s.heading, weight: s.weight, body });
+      }
+    }
+  }
+
+  for (const line of lines) {
+    const m = line.match(/^(#{1,6})\s+(.+)/);
+    if (m) {
+      const level = m[1].length;
+      let heading = m[2].trim();
+      let weight = 0;
+      const w = heading.match(/\s*@(\d+)\s*$/);
+      if (w) {
+        weight = Math.max(1, parseInt(w[1], 10));
+        heading = heading.slice(0, heading.length - w[0].length).trim();
+      }
+
+      popUntil(level);
+
+      const section = { heading, weight, body: [] as string[], level };
+      const cleaned = "#".repeat(level) + " " + heading;
+      for (const s of stack) s.body.push(cleaned);
+      stack.push(section);
+    } else {
+      for (const s of stack) s.body.push(line);
+    }
+  }
+  popUntil(0);
+
+  return rules;
+}
+
+function weightedPick(rules: Rule[], shown: Map<Rule, number>): Rule {
+  const w = (r: Rule) => r.weight * Math.pow(2, -(shown.get(r) ?? 0));
+  const total = rules.reduce((s, r) => s + w(r), 0);
+  let r = Math.random() * total;
+  for (const rule of rules) {
+    r -= w(rule);
+    if (r <= 0) return rule;
+  }
+  return rules[rules.length - 1];
+}
+
+const DEFAULT_EVERY = 5;
+
+function resolveEvery(): number {
+  const v = process.env.MOOD_EVERY;
+  if (v) {
+    const n = parseInt(v, 10);
+    if (n > 0) return n;
+  }
+  return DEFAULT_EVERY;
+}
+
+function trunc(s: string, max: number): string {
+  return s.length <= max ? s : s.slice(0, max - 1) + "…";
+}
+
+function fmtTokens(n: number): string {
+  if (n === 0) return "—";
+  if (n < 1000) return `${n}t`;
+  if (n < 10000) return `${(n / 1000).toFixed(1)}kt`;
+  return `${Math.round(n / 1000)}kt`;
+}
+
+function fmtTime(ago: number, active: boolean): string {
+  if (!active) return "—";
+  if (ago === 0) return "now";
+  return `${ago} ago`;
+}
+
+function fmtRule(rule: Rule | null): string {
+  if (!rule) return "—";
+  return `«${trunc(rule.heading, 30)}»`;
+}
+
+function statusLine(
+  tokens: number,
+  ago: number,
+  active: boolean,
+  rule: Rule | null,
+): string {
+  return `mood: ${fmtTokens(tokens)} · ${fmtTime(ago, active)} · ${fmtRule(rule)}`;
+}
+
+export default function (pi: ExtensionAPI) {
+  let rules: Rule[] = [];
+  let every = DEFAULT_EVERY;
+  let calls = 0;
+  let totalTokens = 0;
+  let currentRule: Rule | null = null;
+  let shown = new Map<Rule, number>();
+  let lastInjection = 0;
+
+  async function refresh(cwd: string) {
+    const paths = [
+      join(homedir(), ".pi/agent/AGENTS.md"),
+      join(cwd, "AGENTS.md"),
+    ];
+
+    rules = [];
+    for (const p of paths) {
+      if (!existsSync(p)) continue;
+      try {
+        const content = await readFile(p, "utf-8");
+        rules.push(...parse(content));
+      } catch {
+        // skip
+      }
+    }
+
+    every = resolveEvery();
+    calls = 0;
+    totalTokens = 0;
+    currentRule = null;
+    shown = new Map();
+    lastInjection = 0;
+  }
+
+  function show(ctx: any) {
+    const ago = calls - lastInjection;
+    const active = currentRule !== null;
+    ctx.ui.setStatus(
+      "mood",
+      statusLine(totalTokens, ago, active, currentRule),
+    );
+  }
+
+  pi.on("session_start", async (event, ctx) => {
+    await refresh(ctx.cwd);
+
+    const entries = ctx.sessionManager.getEntries() as any[];
+
+    let assistantCount = 0;
+    let lastMoodAt = 0;
+    let foundMood = false;
+
+    for (const e of entries) {
+      if (e.customType === "mood") {
+        foundMood = true;
+        lastMoodAt = assistantCount;
+        const text = e.content as string;
+        const matching = rules.find((r) => text.startsWith(r.heading));
+        if (matching) currentRule = matching;
+      }
+      if (e.role === "assistant") assistantCount++;
+    }
+
+    if (foundMood) {
+      calls = assistantCount;
+      lastInjection = lastMoodAt;
+      totalTokens = entries
+        .filter((e: any) => e.customType === "mood")
+        .reduce(
+          (s: number, e: any) =>
+            s +
+            estimateTokens({
+              role: "custom",
+              content: [{ type: "text", text: e.content }],
+            }),
+          0,
+        );
+    }
+
+    show(ctx);
+  });
+
+  pi.on("context", async (event, ctx) => {
+    if (rules.length === 0) return;
+    if (!currentRule) {
+      currentRule = weightedPick(rules, shown);
+      shown.set(currentRule, (shown.get(currentRule) ?? 0) + 1);
+    }
+    calls++;
+
+    if (calls % every === 0 || calls === 1) {
+      currentRule = weightedPick(rules, shown);
+      shown.set(currentRule, (shown.get(currentRule) ?? 0) + 1);
+      lastInjection = calls;
+
+      const text = `${currentRule.heading}\n\n${currentRule.body}`;
+
+      totalTokens += estimateTokens({
+        role: "custom",
+        content: [{ type: "text", text }],
+      });
+
+      pi.sendMessage(
+        { customType: "mood", content: text, display: false },
+        { deliverAs: "steer" },
+      );
+
+      event.messages.push({
+        role: "system",
+        content: [{ type: "text", text }],
+      });
+    }
+
+    show(ctx);
+
+    if (calls % every === 0 || calls === 1) {
+      return { messages: event.messages };
+    }
+  });
+}

package/package.json

@@ -0,0 +1,12 @@
+{
+  "name": "pi-mood",
+  "version": "0.1.0",
+  "description": "Periodic rule reminders from AGENTS.md — weighted probabilistic injection via context event",
+  "keywords": ["pi-package"],
+  "peerDependencies": {
+    "@earendil-works/pi-coding-agent": "*"
+  },
+  "pi": {
+    "extensions": ["./mood.ts"]
+  }
+}

package/test.ts

@@ -0,0 +1,159 @@
+// Test helpers
+let passed = 0;
+let failed = 0;
+
+function assert(cond: boolean, msg: string) {
+  if (cond) { passed++; }
+  else { failed++; console.error(`FAIL: ${msg}`); }
+}
+
+function eq<T>(a: T, b: T, msg: string) {
+  if (JSON.stringify(a) === JSON.stringify(b)) { passed++; }
+  else {
+    failed++;
+    console.error(`FAIL: ${msg}`);
+    console.error(`  expected: ${JSON.stringify(b)}`);
+    console.error(`  got:      ${JSON.stringify(a)}`);
+  }
+}
+
+// Parser under test
+function parse(content: string): { heading: string; weight: number; body: string }[] {
+  const lines = content.split("\n");
+  const rules: { heading: string; weight: number; body: string }[] = [];
+  const stack: { heading: string; weight: number; body: string[]; level: number }[] = [];
+
+  function popUntil(level: number) {
+    while (stack.length > 0 && stack[stack.length - 1].level >= level) {
+      const s = stack.pop()!;
+      const body = s.body.join("\n").trim();
+      if (body.length > 0 && s.weight > 0) {
+        rules.push({ heading: s.heading, weight: s.weight, body });
+      }
+    }
+  }
+
+  for (const line of lines) {
+    const m = line.match(/^(#{1,6})\s+(.+)/);
+    if (m) {
+      const level = m[1].length;
+      let heading = m[2].trim();
+      let weight = 0;
+      const w = heading.match(/\s*@(\d+)\s*$/);
+      if (w) {
+        weight = Math.max(1, parseInt(w[1], 10));
+        heading = heading.slice(0, heading.length - w[0].length).trim();
+      }
+
+      popUntil(level);
+
+      const section = { heading, weight, body: [] as string[], level };
+      const cleanHeading = "#".repeat(level) + " " + heading;
+      for (const s of stack) s.body.push(cleanHeading);
+      stack.push(section);
+    } else {
+      for (const s of stack) s.body.push(line);
+    }
+  }
+  popUntil(0);
+
+  return rules;
+}
+
+// ===== Tests =====
+
+// Flat - only weighted rules appear
+{
+  const r = parse("## A @3\nbody A\n## B\nbody B\n## C @5\nbody C");
+  eq(r.length, 2, "only weighted rules");
+  eq(r[0].heading, "A", "A heading");
+  eq(r[0].weight, 3, "A weight");
+  eq(r[0].body, "body A", "A body");
+  eq(r[1].heading, "C", "C heading");
+  eq(r[1].weight, 5, "C weight");
+  eq(r[1].body, "body C", "C body");
+}
+
+// Nested - parent includes child heading + body
+{
+  const r = parse("## Process @3\nproc body\n### Sub @2\nsub body\n## Code @5\ncode");
+  eq(r.length, 3, "three rules");
+  eq(r[0].heading, "Sub", "Sub first (popped before Process)");
+  eq(r[0].body, "sub body", "Sub body");
+  eq(r[1].heading, "Process", "Process second");
+  eq(r[1].body, "proc body\n### Sub\nsub body", "Process includes sub heading + body");
+  eq(r[2].heading, "Code", "Code last");
+}
+
+// @N stripped from child heading in parent body
+{
+  const r = parse("## Parent @3\np body\n### Child @4\nc body");
+  eq(r.length, 2, "two rules");
+  assert(r[1].body.includes("### Child"), "parent body has child heading");
+  assert(!r[1].body.includes("@4"), "parent body does NOT have @4");
+}
+
+// Weight required - no @N = not a rule
+{
+  const r = parse("## A\nno weight\n## B @2\nwith weight");
+  eq(r.length, 1, "only B");
+  eq(r[0].heading, "B", "B");
+}
+
+// Empty body skipped
+{
+  const r = parse("## A @2\n## B @3\nbody B");
+  eq(r.length, 1, "A skipped (empty body)");
+  eq(r[0].heading, "B", "B");
+}
+
+// Top-level # Title without @N is not a rule, but doesn't break
+{
+  const r = parse("# Title\n## Rule @3\nbody");
+  eq(r.length, 1, "one rule, Title ignored");
+  eq(r[0].heading, "Rule", "Rule");
+}
+
+// Whitespace in body handled
+{
+  const r = parse("## A @2\n\nbody\n\n\n");
+  eq(r.length, 1, "one rule");
+  eq(r[0].body, "body", "body trimmed");
+}
+
+// @N at end of heading with various spacing
+{
+  const r = parse("## A@3\nbody\n## B @5\nbody\n## C  @2\nbody");
+  eq(r[0].heading, "A", "A without @3");
+  eq(r[0].weight, 3, "A weight 3");
+  eq(r[1].heading, "B", "B");
+  eq(r[1].weight, 5, "B weight 5");
+  eq(r[2].heading, "C", "C with extra space");
+  eq(r[2].weight, 2, "C weight 2");
+}
+
+// Deep nesting
+{
+  const r = parse("## A @5\na\n### B @3\nb\n#### C @2\nc\n## D @4\nd");
+  eq(r.length, 4, "4 rules");
+  eq(r[0].heading, "C", "deepest first");
+  eq(r[1].heading, "B", "mid");
+  eq(r[2].heading, "A", "shallow");
+  assert(r[2].body.includes("### B") && r[2].body.includes("#### C"), "A includes B and C");
+}
+
+// EOF - unterminated last section
+{
+  const r = parse("## A @2\nbody");
+  eq(r.length, 1, "last section flushed by popUntil(0)");
+}
+
+// No rules at all
+{
+  const r = parse("just text\nno headings");
+  eq(r.length, 0, "no rules");
+}
+
+// ===== Report =====
+console.log(`\n${passed} passed, ${failed} failed`);
+process.exit(failed > 0 ? 1 : 0);