@artale/pi-pai 4.5.0 → 4.6.0

package/src/lifeos-pai-core.ts

@@ -0,0 +1,608 @@
+/**
+ * PAI Core Extension for Pi
+ *
+ * Ports the key PAI capabilities to Pi's extension system:
+ * - Voice notifications (optional TTS integration)
+ * - Security validation (blocks dangerous commands)
+ * - Session lifecycle (startup greeting, shutdown logging)
+ * - PRD work tracking (Algorithm methodology support)
+ * - Learning signal capture (cross-session improvement)
+ * - Telos Life OS (goals, projects, wisdom tracking)
+ * - PAI Algorithm session management
+ * - Content analysis and research tools
+ *
+ * Based on PAI v4.0.3 — https://github.com/danielmiessler/PAI
+ */
+
+import type { ExtensionAPI } from "@mariozechner/pi-coding-agent";
+import { Type } from "@sinclair/typebox";
+import { existsSync, mkdirSync, writeFileSync, readFileSync, appendFileSync, readdirSync } from "fs";
+import { homedir } from "os";
+import { join } from "path";
+
+// ─── Configuration via environment variables ────────────────
+const PAI_PI_DIR = process.env.PAI_PI_DIR || join(homedir(), ".config", "PAI-pi");
+const MEMORY_DIR = join(PAI_PI_DIR, "memory");
+const WORK_DIR = join(MEMORY_DIR, "work");
+const LEARNING_DIR = join(MEMORY_DIR, "learning");
+const STATE_DIR = join(MEMORY_DIR, "state");
+
+// Voice configuration — set these env vars to enable TTS
+const VOICE_ENDPOINT = process.env.PAI_VOICE_ENDPOINT || "http://localhost:8888/notify";
+const VOICE_ID = process.env.PAI_VOICE_ID || "";
+const VOICE_ENABLED = process.env.PAI_VOICE_ENABLED === "true";
+
+const STATE_FILE = join(STATE_DIR, "last-session.json");
+
+// Ensure directories exist
+for (const dir of [MEMORY_DIR, WORK_DIR, LEARNING_DIR, STATE_DIR]) {
+  if (!existsSync(dir)) mkdirSync(dir, { recursive: true });
+}
+
+const DANGEROUS_PATTERNS = [
+  /rm\s+(-rf?|--recursive)\s+[\/~]/,
+  /rm\s+-rf?\s+\./,
+  /git\s+push\s+.*--force/,
+  /git\s+reset\s+--hard/,
+  /git\s+clean\s+-f/,
+  /git\s+checkout\s+\./,
+  /drop\s+table/i,
+  /truncate\s+table/i,
+  /:\(\)\{ :\|:& \};:/,
+  /mkfs\./,
+  /dd\s+if=/,
+];
+
+const sendVoiceNotification = async (message: string): Promise<boolean> => {
+  if (!VOICE_ENABLED || !VOICE_ID) return false;
+
+  try {
+    const response = await fetch(VOICE_ENDPOINT, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+      },
+      body: JSON.stringify({
+        message,
+        voice_id: VOICE_ID,
+        voice_enabled: true,
+      }),
+    });
+    return response.ok;
+  } catch {
+    return false;
+  }
+};
+
+export default function (pi: ExtensionAPI) {
+  // ─── Voice Notification Tool ─────────────────────────
+  pi.registerTool({
+    name: "voice_notify",
+    label: "Voice",
+    description: "Send a voice notification via TTS server (requires PAI_VOICE_ENDPOINT and PAI_VOICE_ID env vars)",
+    parameters: Type.Object({
+      message: Type.String({ description: "Text to speak" }),
+    }),
+    async execute(_toolCallId, params) {
+      if (!VOICE_ENABLED || !VOICE_ID) {
+        return { details: undefined, content: [{ type: "text", text: "Voice disabled (set PAI_VOICE_ENABLED=true and PAI_VOICE_ID)" }] };
+      }
+
+      const sent = await sendVoiceNotification(params.message);
+      return sent
+        ? { details: undefined, content: [{ type: "text", text: `Voice: "${params.message}"` }] }
+        : { details: undefined, content: [{ type: "text", text: "Voice server unavailable" }] };
+    },
+  });
+
+  // ─── Security: Block dangerous commands ──────────────
+  pi.on("tool_call", async (event) => {
+    const { isToolCallEventType } = await import("@mariozechner/pi-coding-agent");
+    if (!isToolCallEventType("bash", event)) return;
+    const cmd = (event as { input?: { command?: string } }).input?.command || "";
+
+    for (const pattern of DANGEROUS_PATTERNS) {
+      if (pattern.test(cmd)) {
+        return {
+          block: true,
+          reason: `BLOCKED: Dangerous command detected. Pattern: ${pattern.source}. Ask before proceeding.`,
+        };
+      }
+    }
+  });
+
+  // ─── Session Start: Voice (non-blocking) ─────────────
+  pi.on("session_start", async () => {
+    void sendVoiceNotification("PAI online. Ready for work.");
+  });
+
+  // ─── Session Shutdown: Capture learnings ─────────────
+  pi.on("session_shutdown", async () => {
+    const timestamp = new Date().toISOString();
+    const logPath = join(LEARNING_DIR, "session-log.jsonl");
+    const sessionName = pi.getSessionName() || "unnamed";
+
+    const entry = {
+      timestamp,
+      event: "session_end",
+      sessionName,
+    };
+
+    try {
+      appendFileSync(logPath, JSON.stringify(entry) + "\n");
+      writeFileSync(STATE_FILE, JSON.stringify({ ...entry, active: false }, null, 2));
+    } catch {
+      // Best effort
+    }
+  });
+
+  // ─── PRD Management Tool ─────────────────────────────
+  pi.registerTool({
+    name: "prd_create",
+    label: "PRD",
+    description: "Create a PRD (Product Requirements Document) for Algorithm work tracking",
+    parameters: Type.Object({
+      task: Type.String({ description: "8 word task description" }),
+      slug: Type.String({ description: "kebab-case slug for the work directory" }),
+      effort: Type.String({ description: "standard|extended|advanced|deep|comprehensive" }),
+      phase: Type.String({ description: "observe|think|plan|build|execute|verify|learn|complete" }),
+      criteria: Type.Optional(Type.Array(Type.String(), { description: "ISC criteria list" })),
+      progress: Type.Optional(Type.String({ description: "e.g. 3/8" })),
+    }),
+    async execute(_toolCallId, params) {
+      const workDir = join(WORK_DIR, params.slug);
+      if (!existsSync(workDir)) mkdirSync(workDir, { recursive: true });
+
+      const timestamp = new Date().toISOString();
+      const criteriaBlock = params.criteria
+        ? params.criteria.map((c, i) => `- [ ] ISC-${i + 1}: ${c}`).join("\n")
+        : "";
+
+      const content = `---
+ task: ${params.task}
+ slug: ${params.slug}
+ effort: ${params.effort}
+ phase: ${params.phase}
+ progress: ${params.progress || "0/0"}
+ started: ${timestamp}
+ updated: ${timestamp}
+ ---
+ 
+ ## Context
+ 
+ ${params.task}
+ 
+ ## Criteria
+ 
+ ${criteriaBlock}
+ 
+ ## Decisions
+ 
+ ## Verification
+ `;
+
+      const prdPath = join(workDir, "PRD.md");
+      writeFileSync(prdPath, content);
+
+      return {
+        details: { path: prdPath, slug: params.slug },
+        content: [{ type: "text", text: `PRD created at ${prdPath}` }],
+      };
+    },
+  });
+
+  // ─── PRD Update Tool ─────────────────────────────────
+  pi.registerTool({
+    name: "prd_update",
+    label: "PRD Update",
+    description: "Update PRD phase, progress, or mark criteria complete",
+    parameters: Type.Object({
+      slug: Type.String({ description: "PRD slug" }),
+      phase: Type.Optional(Type.String({ description: "New phase" })),
+      progress: Type.Optional(Type.String({ description: "e.g. 5/8" })),
+      complete_criteria: Type.Optional(
+        Type.Array(Type.Number(), { description: "ISC numbers to mark complete" })
+      ),
+    }),
+    async execute(_toolCallId, params) {
+      const prdPath = join(WORK_DIR, params.slug, "PRD.md");
+      if (!existsSync(prdPath)) {
+        return { details: undefined, content: [{ type: "text", text: `PRD not found: ${params.slug}` }] };
+      }
+
+      let content = readFileSync(prdPath, "utf-8");
+      const timestamp = new Date().toISOString();
+
+      if (params.phase) {
+        content = content.replace(/^phase: .+$/m, `phase: ${params.phase}`);
+      }
+      if (params.progress) {
+        content = content.replace(/^progress: .+$/m, `progress: ${params.progress}`);
+      }
+      content = content.replace(/^updated: .+$/m, `updated: ${timestamp}`);
+
+      if (params.complete_criteria) {
+        for (const num of params.complete_criteria) {
+          content = content.replace(
+            new RegExp(`^- \[ \] ISC-${num}:`, "m"),
+            `- [x] ISC-${num}:`
+          );
+        }
+      }
+
+      writeFileSync(prdPath, content);
+      return { details: undefined, content: [{ type: "text", text: `PRD updated: ${params.slug}` }] };
+    },
+  });
+
+  // ─── Learning Signal Tool ────────────────────────────
+  pi.registerTool({
+    name: "lifeos_capture_learning",
+    label: "Learn",
+    description: "Capture a learning signal or reflection from this session",
+    parameters: Type.Object({
+      signal_type: Type.String({ description: "rating|reflection|failure|pattern" }),
+      content: Type.String({ description: "The learning content" }),
+      score: Type.Optional(Type.Number({ description: "Rating 1-10 if applicable" })),
+    }),
+    async execute(_toolCallId, params) {
+      const timestamp = new Date().toISOString();
+      const entry = {
+        timestamp,
+        type: params.signal_type,
+        content: params.content,
+        score: params.score,
+        session: pi.getSessionName() || "unnamed",
+      };
+
+      const logPath = join(LEARNING_DIR, "signals.jsonl");
+      appendFileSync(logPath, JSON.stringify(entry) + "\n");
+
+      return {
+        details: entry,
+        content: [{ type: "text", text: `Learning captured: ${params.signal_type}` }],
+      };
+    },
+  });
+
+  // ─── Status Line ─────────────────────────────────────
+  pi.on("agent_start", async (_event, ctx) => {
+    ctx.ui.setStatus("pai", "PAI on Pi | LifeOS Core Scaffold");
+  });
+
+  // ─── Slash Commands ──────────────────────────────────
+  pi.registerCommand("algorithm", {
+    description: "Start an Algorithm session for complex work",
+    handler: async (_args, ctx) => {
+      ctx.ui.notify(
+        "Algorithm mode activated. Use the 7-phase methodology for this task.",
+        "info"
+      );
+      await pi.sendMessage({
+        customType: "pai-algorithm",
+        content: "Use ALGORITHM mode for the next task. Follow all 7 phases.",
+        details: undefined,
+      } as any, { triggerTurn: false });
+    },
+  });
+
+  pi.registerCommand("status", {
+    description: "Show PAI system status",
+    handler: async (_args, ctx) => {
+      const sessionCount = (() => {
+        try {
+          const logPath = join(LEARNING_DIR, "session-log.jsonl");
+          if (!existsSync(logPath)) return 0;
+          return readFileSync(logPath, "utf-8").trim().split("\n").length;
+        } catch {
+          return 0;
+        }
+      })();
+
+      const signalCount = (() => {
+        try {
+          const logPath = join(LEARNING_DIR, "signals.jsonl");
+          if (!existsSync(logPath)) return 0;
+          return readFileSync(logPath, "utf-8").trim().split("\n").length;
+        } catch {
+          return 0;
+        }
+      })();
+
+      ctx.ui.notify(
+        `PAI on Pi | Sessions: ${sessionCount} | Signals: ${signalCount}`,
+        "info"
+      );
+    },
+  });
+
+  pi.registerCommand("voice", {
+    description: "Send a voice notification",
+    handler: async (args, _ctx) => {
+      const message = args || "Hello from PAI";
+      if (!VOICE_ENABLED || !VOICE_ID) {
+        return;
+      }
+      void sendVoiceNotification(String(message));
+    },
+  });
+
+  // ══════════════════════════════════════════════════════
+  // Telos — Life OS (goals, projects, wisdom)
+  // ══════════════════════════════════════════════════════
+
+  const TELOS_DIR = join(PAI_PI_DIR, "telos");
+  if (!existsSync(TELOS_DIR)) mkdirSync(TELOS_DIR, { recursive: true });
+
+  function workDir(slug: string): string {
+    const d = join(WORK_DIR, slug);
+    if (!existsSync(d)) mkdirSync(d, { recursive: true });
+    return d;
+  }
+
+  function loadDir(dir: string): Record<string, string> {
+    const result: Record<string, string> = {};
+    if (!existsSync(dir)) return result;
+    for (const f of readdirSync(dir)) {
+      if (f.endsWith(".md")) {
+        const slug = f.replace(/\.md$/, "");
+        result[slug] = readFileSync(join(dir, f), "utf-8");
+      }
+    }
+    return result;
+  }
+
+  pi.registerTool({
+    name: "telos_goal",
+    label: "Goal",
+    description: "Create or update a Life OS goal with timeline, dependencies, and projects",
+    parameters: Type.Object({
+      title: Type.String({ description: "Goal title" }),
+      slug: Type.String({ description: "kebab-case slug" }),
+      deadline: Type.Optional(Type.String({ description: "Target date (ISO or relative)" })),
+      dependencies: Type.Optional(Type.Array(Type.String({ description: "Dependency slugs" }))),
+      projects: Type.Optional(Type.Array(Type.String({ description: "Project slugs serving this goal" }))),
+      status: Type.Optional(Type.Unsafe<"active" | "paused" | "completed" | "archived">({
+        type: "string",
+        enum: ["active", "paused", "completed", "archived"],
+        default: "active",
+      })),
+    }),
+    async execute(_callId, params) {
+      const dir = join(TELOS_DIR, params.slug);
+      if (!existsSync(dir)) mkdirSync(dir, { recursive: true });
+      const existing = existsSync(join(dir, "goal.md"))
+        ? readFileSync(join(dir, "goal.md"), "utf-8") : "";
+      const now = new Date().toISOString();
+      const created = existing.match(/^created: .+$/m)?.[0]?.replace(/^created: /, "") || now;
+      const content = `---
+slug: ${params.slug}
+title: ${params.title}
+status: ${params.status || "active"}
+deadline: ${params.deadline || "none"}
+created: ${created}
+updated: ${now}
+dependencies: ${JSON.stringify(params.dependencies || [])}
+projects: ${JSON.stringify(params.projects || [])}
+---
+
+# Goal: ${params.title}
+
+## Dependency Graph
+${(params.dependencies || []).map((d) => `- ${d}`).join("\n") || "None"}
+
+## Projects
+${(params.projects || []).map((p) => `- ${p}`).join("\n") || "None"}
+
+## Notes
+`;
+      writeFileSync(join(dir, "goal.md"), content);
+      return { content: [{ type: "text", text: `Goal saved: ${params.title} (${params.slug})` }], details: {} };
+    },
+  });
+
+  pi.registerTool({
+    name: "telos_wisdom",
+    label: "Wisdom",
+    description: "Record a wisdom entry — insight from experience, books, or reflection",
+    parameters: Type.Object({
+      insight: Type.String({ description: "The wisdom or insight" }),
+      source: Type.Optional(Type.String({ description: "Source (book, experience, person, etc.)" })),
+      tags: Type.Optional(Type.Array(Type.String({ description: "Category tags" }))),
+      impact: Type.Optional(Type.Unsafe<"low" | "medium" | "high" | "life-changing">({
+        type: "string",
+        enum: ["low", "medium", "high", "life-changing"],
+        default: "medium",
+      })),
+    }),
+    async execute(_callId, params) {
+      const logPath = join(TELOS_DIR, "wisdom.jsonl");
+      const entry = { timestamp: new Date().toISOString(), insight: params.insight, source: params.source || "", tags: params.tags || [], impact: params.impact || "medium" };
+      appendFileSync(logPath, JSON.stringify(entry) + "\n");
+      return { content: [{ type: "text", text: `Wisdom saved. Impact: ${params.impact}` }], details: {} };
+    },
+  });
+
+  pi.registerTool({
+    name: "telos_dashboard",
+    label: "Dashboard",
+    description: "Generate a Telos dashboard showing goals, projects, and recent wisdom",
+    parameters: Type.Object({
+      focus: Type.Optional(Type.Unsafe<"all" | "goals" | "wisdom" | "projects">({
+        type: "string",
+        enum: ["all", "goals", "wisdom", "projects"],
+        default: "all",
+      })),
+    }),
+    async execute(_callId, params) {
+      const goals = loadDir(TELOS_DIR);
+      const wisdomPath = join(TELOS_DIR, "wisdom.jsonl");
+      const wisdomEntries: Array<Record<string, string>> = [];
+      if (existsSync(wisdomPath)) {
+        const lines = readFileSync(wisdomPath, "utf-8").trim().split("\n");
+        for (const line of lines.slice(-10)) {
+          try { wisdomEntries.push(JSON.parse(line)); } catch { /* skip */ }
+        }
+      }
+      const sections: string[] = [];
+      if (params.focus === "all" || params.focus === "goals") {
+        sections.push("## Goals");
+        for (const [slug, content] of Object.entries(goals)) {
+          const title = content.match(/^title: (.+)$/m)?.[1] || slug;
+          const status = content.match(/^status: (.+)$/m)?.[1] || "?";
+          sections.push(`- **${title}** — ${status}`);
+        }
+      }
+      if (params.focus === "all" || params.focus === "wisdom") {
+        sections.push("\n## Recent Wisdom");
+        for (const w of wisdomEntries.reverse()) {
+          sections.push(`- [${w.impact}] ${w.insight}${w.source ? ` — ${w.source}` : ""}`);
+        }
+      }
+      return { content: [{ type: "text", text: sections.join("\n") || "No data yet." }], details: {} };
+    },
+  });
+
+  // ══════════════════════════════════════════════════════
+  // PAI Algorithm — session management
+  // ══════════════════════════════════════════════════════
+
+  pi.registerTool({
+    name: "algorithm_start",
+    label: "Algorithm",
+    description: "Start a PAI Algorithm session with structured PRD tracking",
+    parameters: Type.Object({
+      task: Type.String({ description: "Task description" }),
+      slug: Type.String({ description: "kebab-case slug for work directory" }),
+      effort: Type.Optional(Type.Unsafe<"standard" | "extended" | "advanced" | "deep" | "comprehensive">({
+        type: "string",
+        enum: ["standard", "extended", "advanced", "deep", "comprehensive"],
+        default: "standard",
+      })),
+      criteria: Type.Optional(Type.Array(Type.String({ description: "ISC criteria" }))),
+    }),
+    async execute(_callId, params) {
+      const dir = workDir(params.slug);
+      const prdPath = join(dir, "PRD.md");
+      if (existsSync(prdPath)) {
+        return { content: [{ type: "text", text: `PRD already exists at ${prdPath} — use algorithm_advance to update phase/progress instead.` }], details: {} };
+      }
+      const criteriaBlock = params.criteria
+        ? params.criteria.map((c, i) => `- [ ] ISC-${i + 1}: ${c}`).join("\n")
+        : "- [ ] ISC-1: TBD";
+      const content = `---
+task: ${params.task}
+slug: ${params.slug}
+effort: ${params.effort || "standard"}
+phase: observe
+progress: 0/${params.criteria?.length || 0}
+started: ${new Date().toISOString()}
+updated: ${new Date().toISOString()}
+---
+
+## Task
+${params.task}
+
+## Phases
+1. OBSERVE — Define ISC
+2. THINK — Risks, premortem
+3. PLAN — Design approach
+4. BUILD — Prepare artifacts
+5. EXECUTE — Mark ISC as they pass
+6. VERIFY — Test every ISC
+7. LEARN — Reflect
+
+## ISC
+${criteriaBlock}
+`;
+      writeFileSync(join(dir, "PRD.md"), content);
+      return { content: [{ type: "text", text: `Algorithm PRD: ${params.slug} — OBSERVE phase.` }], details: {} };
+    },
+  });
+
+  pi.registerTool({
+    name: "algorithm_advance",
+    label: "Advance",
+    description: "Advance the Algorithm phase or mark ISC complete",
+    parameters: Type.Object({
+      slug: Type.String({ description: "PRD slug" }),
+      phase: Type.Optional(Type.Unsafe<"observe" | "think" | "plan" | "build" | "execute" | "verify" | "learn" | "complete">({
+        type: "string",
+        enum: ["observe", "think", "plan", "build", "execute", "verify", "learn", "complete"],
+      })),
+      complete: Type.Optional(Type.Array(Type.Number({ description: "ISC numbers to mark done" }))),
+    }),
+    async execute(_callId, params) {
+      const prdPath = join(WORK_DIR, params.slug, "PRD.md");
+      if (!existsSync(prdPath)) {
+        return { content: [{ type: "text", text: `PRD not found: ${params.slug}` }], details: {} };
+      }
+      let content = readFileSync(prdPath, "utf-8");
+      const now = new Date().toISOString();
+      content = content.replace(/^updated: .+$/m, `updated: ${now}`);
+      if (params.phase) {
+        content = content.replace(/^phase: .+$/m, `phase: ${params.phase}`);
+      }
+      if (params.complete) {
+        for (const n of params.complete) {
+          content = content.replace(new RegExp(`^- \\[ \\] ISC-${n}:`, "m"), `- [x] ISC-${n}:`);
+        }
+        const done = (content.match(/- \[x\] ISC-/g) || []).length;
+        const total = (content.match(/- \[ \] ISC-/g) || []).length + done;
+        content = content.replace(/^progress: .+$/m, `progress: ${done}/${total}`);
+      }
+      writeFileSync(prdPath, content);
+      return { content: [{ type: "text", text: `PRD updated: ${params.slug} → ${params.phase || "progress"}` }], details: {} };
+    },
+  });
+
+  // ══════════════════════════════════════════════════════
+  // Content analysis + research
+  // ══════════════════════════════════════════════════════
+
+  pi.registerTool({
+    name: "content_analyze",
+    label: "Analyze",
+    description: "Extract wisdom and key insights from any content (URL, text, file)",
+    parameters: Type.Object({
+      content: Type.String({ description: "Text content or URL to analyze" }),
+      focus: Type.Optional(Type.String({ description: "Specific angle to analyze for" })),
+    }),
+    async execute(_callId, params) {
+      workDir("analysis-" + Date.now().toString(36));
+      const truncated = params.content.length > 3000;
+      const body = truncated ? params.content.slice(0, 3000) : params.content;
+      const truncWarn = truncated ? ` (truncated from ${params.content.length} chars to 3000)` : "";
+      return { content: [{ type: "text", text: `Analyzing content${params.focus ? `, focusing on: ${params.focus}` : ""}${truncWarn}.\n\n## Content\n${body}\n\nExtract wisdom, key quotes, actionable insights, and cross-references.` }], details: {} };
+    },
+  });
+
+  pi.registerTool({
+    name: "research_start",
+    label: "Research",
+    description: "Start a structured research investigation",
+    parameters: Type.Object({
+      question: Type.String({ description: "Research question or topic" }),
+      sub_questions: Type.Optional(Type.Array(Type.String({ description: "Sub-questions to explore" }))),
+    }),
+    async execute(_callId, params) {
+      workDir("research-" + Date.now().toString(36));
+      return {
+        content: [{ type: "text", text: `Research on: ${params.question}\n\nDecompose into sub-questions, search across multiple angles, extract findings with sources, then synthesize.${params.sub_questions?.length ? `\n\nSub-questions:\n${params.sub_questions.map((q, i) => `${i + 1}. ${q}`).join("\n")}` : ""}` }],
+        details: {},
+      };
+    },
+  });
+
+  // ══════════════════════════════════════════════════════
+  // Commands
+  // ══════════════════════════════════════════════════════
+
+  pi.registerCommand("telos", {
+    description: "Life OS dashboard. Usage: /telos [goals|wisdom|all]",
+    handler: async (args, ctx) => {
+      const focus = (args || "all").toLowerCase();
+      ctx.ui.notify(`Telos dashboard — use telos_dashboard tool with focus=${focus}`, "info");
+    },
+  });
+}

package/agents/context_bundles/MON_14_unknown.jsonl

@@ -1 +0,0 @@
-{"operation": "prompt", "prompt": "<user_query>\nhi\n</user_query>", "timestamp": "2026-05-18T14:12:26.348907"}