pi-continuous-learning 0.3.0

package/src/confidence.ts

@@ -0,0 +1,103 @@
+/**
+ * Pure functions for instinct confidence scoring.
+ * No I/O - all functions take plain values and return plain values.
+ */
+
+// ---------------------------------------------------------------------------
+// Constants
+// ---------------------------------------------------------------------------
+
+const CLAMP_MIN = 0.1;
+const CLAMP_MAX = 0.9;
+
+// initialConfidence brackets
+const INITIAL_LOW = 0.3;
+const INITIAL_MED = 0.5;
+const INITIAL_HIGH = 0.7;
+const INITIAL_VERY_HIGH = 0.85;
+
+const OBS_BRACKET_LOW_MAX = 2;
+const OBS_BRACKET_MED_MAX = 5;
+const OBS_BRACKET_HIGH_MAX = 10;
+
+// adjustConfidence deltas
+const DELTA_CONFIRMED = 0.05;
+const DELTA_CONTRADICTED = -0.15;
+const DELTA_INACTIVE = 0;
+
+// applyPassiveDecay
+const DECAY_PER_WEEK = 0.02;
+const MS_PER_WEEK = 7 * 24 * 60 * 60 * 1000;
+
+// ---------------------------------------------------------------------------
+// Types
+// ---------------------------------------------------------------------------
+
+export type FeedbackOutcome = "confirmed" | "contradicted" | "inactive";
+
+export interface ConfidenceResult {
+  confidence: number;
+  flaggedForRemoval: boolean;
+}
+
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+
+function clamp(value: number): number {
+  return Math.max(CLAMP_MIN, Math.min(CLAMP_MAX, value));
+}
+
+function toResult(raw: number): ConfidenceResult {
+  const flaggedForRemoval = raw < CLAMP_MIN;
+  return { confidence: clamp(raw), flaggedForRemoval };
+}
+
+// ---------------------------------------------------------------------------
+// Public API
+// ---------------------------------------------------------------------------
+
+/**
+ * Returns the initial confidence score for a newly discovered instinct
+ * based on how many observations support it.
+ */
+export function initialConfidence(observationCount: number): number {
+  if (observationCount <= OBS_BRACKET_LOW_MAX) return INITIAL_LOW;
+  if (observationCount <= OBS_BRACKET_MED_MAX) return INITIAL_MED;
+  if (observationCount <= OBS_BRACKET_HIGH_MAX) return INITIAL_HIGH;
+  return INITIAL_VERY_HIGH;
+}
+
+/**
+ * Adjusts confidence based on a feedback outcome from the observer loop.
+ * Returns the clamped confidence and a flag indicating if removal is warranted.
+ */
+export function adjustConfidence(
+  current: number,
+  outcome: FeedbackOutcome,
+): ConfidenceResult {
+  const deltas: Record<FeedbackOutcome, number> = {
+    confirmed: DELTA_CONFIRMED,
+    contradicted: DELTA_CONTRADICTED,
+    inactive: DELTA_INACTIVE,
+  };
+  const raw = current + deltas[outcome];
+  return toResult(raw);
+}
+
+/**
+ * Applies passive time-based decay of -0.02 per week since lastUpdated.
+ * Future lastUpdated values produce zero decay.
+ */
+export function applyPassiveDecay(
+  confidence: number,
+  lastUpdated: string,
+): ConfidenceResult {
+  const now = Date.now();
+  const updatedAt = new Date(lastUpdated).getTime();
+  const elapsedMs = Math.max(0, now - updatedAt);
+  const weeksElapsed = elapsedMs / MS_PER_WEEK;
+  const decay = weeksElapsed * DECAY_PER_WEEK;
+  const raw = confidence - decay;
+  return toResult(raw);
+}

package/src/config.ts

@@ -0,0 +1,111 @@
+/**
+ * Configuration module for pi-continuous-learning.
+ * Loads user settings from ~/.pi/continuous-learning/config.json with defaults.
+ */
+
+import * as fs from "node:fs";
+import * as os from "node:os";
+import * as path from "node:path";
+import { Type, type Static } from "@sinclair/typebox";
+import { Value } from "@sinclair/typebox/value";
+import type { Config } from "./types.js";
+
+// ---------------------------------------------------------------------------
+// Constants
+// ---------------------------------------------------------------------------
+
+/**
+ * Maps instinct domain names to human-readable purposes.
+ * Used by findSkillShadows() to detect when an instinct is covered by an installed Pi skill.
+ */
+export const SKILL_DOMAINS: Record<string, string> = {
+  git: "version control and git workflows",
+  testing: "test writing and test frameworks",
+  debugging: "error analysis and debugging",
+  workflow: "development workflow and automation",
+  typescript: "TypeScript language and type system",
+  css: "CSS and styling",
+  design: "UI design and component patterns",
+  security: "security practices and vulnerability prevention",
+  performance: "performance optimization",
+  documentation: "documentation writing and standards",
+};
+
+export const CONFIG_PATH = path.join(
+  os.homedir(),
+  ".pi",
+  "continuous-learning",
+  "config.json"
+);
+
+export const DEFAULT_CONFIG: Config = {
+  run_interval_minutes: 5,
+  min_observations_to_analyze: 20,
+  min_confidence: 0.5,
+  max_instincts: 20,
+  max_injection_chars: 4000,
+  model: "claude-haiku-4-5",
+  timeout_seconds: 120,
+  active_hours_start: 8,
+  active_hours_end: 23,
+  max_idle_seconds: 1800,
+};
+
+// ---------------------------------------------------------------------------
+// TypeBox schema for partial config overrides (runtime validation)
+// ---------------------------------------------------------------------------
+
+const PartialConfigSchema = Type.Partial(
+  Type.Object({
+    run_interval_minutes: Type.Number(),
+    min_observations_to_analyze: Type.Number(),
+    min_confidence: Type.Number(),
+    max_instincts: Type.Number(),
+    max_injection_chars: Type.Number(),
+    model: Type.String(),
+    timeout_seconds: Type.Number(),
+    active_hours_start: Type.Number(),
+    active_hours_end: Type.Number(),
+    max_idle_seconds: Type.Number(),
+  })
+);
+
+type PartialConfig = Static<typeof PartialConfigSchema>;
+
+// ---------------------------------------------------------------------------
+// loadConfig
+// ---------------------------------------------------------------------------
+
+/**
+ * Loads config from ~/.pi/continuous-learning/config.json.
+ * Returns defaults when file is absent or contains invalid JSON.
+ * Merges partial overrides with defaults (overrides win).
+ */
+export function loadConfig(): Config {
+  if (!fs.existsSync(CONFIG_PATH)) {
+    return { ...DEFAULT_CONFIG };
+  }
+
+  let raw: string;
+  try {
+    raw = fs.readFileSync(CONFIG_PATH, "utf-8") as string;
+  } catch (err) {
+    console.warn(`[pi-continuous-learning] Failed to read config.json: ${String(err)}`);
+    return { ...DEFAULT_CONFIG };
+  }
+
+  let parsed: unknown;
+  try {
+    parsed = JSON.parse(raw);
+  } catch (err) {
+    console.warn(
+      `[pi-continuous-learning] Invalid JSON in config.json: ${String(err)}. Using defaults.`
+    );
+    return { ...DEFAULT_CONFIG };
+  }
+
+  // Validate and extract only known config fields (runtime boundary check)
+  const cleaned = Value.Clean(PartialConfigSchema, parsed) as PartialConfig;
+
+  return { ...DEFAULT_CONFIG, ...cleaned };
+}

package/src/error-logger.ts

@@ -0,0 +1,130 @@
+/**
+ * Error logging utility for pi-continuous-learning.
+ * Writes structured error entries to projects/<id>/analyzer.log.
+ * All write failures are silently swallowed - the logger must never throw.
+ */
+
+import { appendFileSync, mkdirSync } from "node:fs";
+import { join, dirname } from "node:path";
+import { getProjectDir, getBaseDir } from "./storage.js";
+
+// ---------------------------------------------------------------------------
+// Constants
+// ---------------------------------------------------------------------------
+
+const LOG_FILENAME = "analyzer.log";
+const PREFIX = "[pi-continuous-learning]";
+
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+
+/**
+ * Returns the absolute path to the analyzer log for the given project.
+ * Exported for testing.
+ */
+export function getLogPath(projectId: string, baseDir?: string): string {
+  return join(getProjectDir(projectId, baseDir ?? getBaseDir()), LOG_FILENAME);
+}
+
+function formatError(context: string, error: unknown): string {
+  const timestamp = new Date().toISOString();
+  const message = error instanceof Error ? error.message : String(error);
+  const stack =
+    error instanceof Error && error.stack
+      ? `\nStack: ${error.stack}`
+      : "";
+  return `[${timestamp}] [${context}] Error: ${message}${stack}\n`;
+}
+
+// ---------------------------------------------------------------------------
+// Public API
+// ---------------------------------------------------------------------------
+
+/**
+ * Logs an error to `projects/<projectId>/analyzer.log`.
+ *
+ * When `projectId` is null (e.g. session_start failed before project detection),
+ * falls back to `console.warn` only.
+ *
+ * Never throws - all I/O failures are silently swallowed.
+ */
+export function logError(
+  projectId: string | null,
+  context: string,
+  error: unknown,
+  baseDir?: string
+): void {
+  const line = formatError(context, error);
+
+  if (projectId === null) {
+    console.warn(`${PREFIX} ${context}: ${line.trim()}`);
+    return;
+  }
+
+  const logPath = getLogPath(projectId, baseDir);
+  try {
+    mkdirSync(dirname(logPath), { recursive: true });
+    appendFileSync(logPath, line, "utf-8");
+  } catch {
+    // Cannot log the logger failing - fall back to console
+    console.warn(`${PREFIX} ${context}: ${line.trim()}`);
+  }
+}
+
+/**
+ * Logs a warning (non-error) message to the analyzer log.
+ * Used for subprocess stderr output and other non-fatal warnings.
+ *
+ * Never throws - all I/O failures are silently swallowed.
+ */
+export function logWarning(
+  projectId: string | null,
+  context: string,
+  message: string,
+  baseDir?: string
+): void {
+  const timestamp = new Date().toISOString();
+  const line = `[${timestamp}] [${context}] Warning: ${message}\n`;
+
+  if (projectId === null) {
+    console.warn(`${PREFIX} ${context}: ${message}`);
+    return;
+  }
+
+  const logPath = getLogPath(projectId, baseDir);
+  try {
+    mkdirSync(dirname(logPath), { recursive: true });
+    appendFileSync(logPath, line, "utf-8");
+  } catch {
+    console.warn(`${PREFIX} ${context}: ${message}`);
+  }
+}
+
+/**
+ * Logs an informational message to the analyzer log.
+ * Used for tracking analyzer lifecycle events (started, completed, skipped).
+ *
+ * Never throws - all I/O failures are silently swallowed.
+ */
+export function logInfo(
+  projectId: string | null,
+  context: string,
+  message: string,
+  baseDir?: string
+): void {
+  const timestamp = new Date().toISOString();
+  const line = `[${timestamp}] [${context}] Info: ${message}\n`;
+
+  if (projectId === null) {
+    return;
+  }
+
+  const logPath = getLogPath(projectId, baseDir);
+  try {
+    mkdirSync(dirname(logPath), { recursive: true });
+    appendFileSync(logPath, line, "utf-8");
+  } catch {
+    // silently swallow
+  }
+}

package/src/index.ts

@@ -0,0 +1,144 @@
+/**
+ * Pi Continuous Learning Extension - Entry Point
+ *
+ * Observes coding sessions, records events as observations, and injects
+ * learned instincts into the agent's system prompt. Background analysis
+ * runs via a separate standalone script (src/cli/analyze.ts).
+ */
+
+import type { ExtensionAPI, ExtensionCommandContext } from "@mariozechner/pi-coding-agent";
+import { loadSkills } from "@mariozechner/pi-coding-agent";
+
+import { loadConfig } from "./config.js";
+import { detectProject } from "./project.js";
+import { ensureStorageLayout } from "./storage.js";
+import { cleanOldArchives } from "./observations.js";
+import { handleToolStart, handleToolEnd } from "./tool-observer.js";
+import { handleBeforeAgentStart, handleAgentEnd } from "./prompt-observer.js";
+import {
+  handleBeforeAgentStartInjection,
+  handleAgentEndClearInstincts,
+} from "./instinct-injector.js";
+import { handleInstinctStatus, COMMAND_NAME as STATUS_CMD } from "./instinct-status.js";
+import { handleInstinctExport, COMMAND_NAME as EXPORT_CMD } from "./instinct-export.js";
+import { handleInstinctImport, COMMAND_NAME as IMPORT_CMD } from "./instinct-import.js";
+import { handleInstinctPromote, COMMAND_NAME as PROMOTE_CMD } from "./instinct-promote.js";
+import { handleInstinctEvolve, COMMAND_NAME as EVOLVE_CMD } from "./instinct-evolve.js";
+import { handleInstinctProjects, COMMAND_NAME as PROJECTS_CMD } from "./instinct-projects.js";
+import { registerAllTools } from "./instinct-tools.js";
+import { logError } from "./error-logger.js";
+import type { Config, InstalledSkill, ProjectEntry } from "./types.js";
+
+export default function (pi: ExtensionAPI): void {
+  let config: Config | null = null;
+  let project: ProjectEntry | null = null;
+  let installedSkills: InstalledSkill[] = [];
+
+  pi.on("session_start", async (_event, ctx) => {
+    try {
+      config = loadConfig();
+      project = await detectProject(pi, ctx.cwd);
+      ensureStorageLayout(project);
+      cleanOldArchives(project.id);
+
+      try {
+        const result = loadSkills({ cwd: ctx.cwd });
+        installedSkills = result.skills.map((s) => ({ name: s.name, description: s.description }));
+      } catch {
+        installedSkills = [];
+      }
+
+      registerAllTools(pi, project.id, project.name);
+    } catch (err) {
+      logError(project?.id ?? null, "session_start", err);
+    }
+  });
+
+  pi.on("session_shutdown", (_event, _ctx) => {
+    // No cleanup needed — analyzer runs as external process
+  });
+
+  pi.on("before_agent_start", (event, ctx) => {
+    try {
+      if (!project || !config) return;
+      handleBeforeAgentStart(event, ctx, project);
+      return handleBeforeAgentStartInjection(event, ctx, config, project.id) ?? undefined;
+    } catch (err) {
+      logError(project?.id ?? null, "before_agent_start", err);
+    }
+  });
+
+  pi.on("agent_start", (_event, _ctx) => {});
+
+  pi.on("agent_end", (event, ctx) => {
+    try {
+      if (!project) return;
+      handleAgentEnd(event, ctx, project);
+      handleAgentEndClearInstincts(event, ctx);
+    } catch (err) {
+      logError(project?.id ?? null, "agent_end", err);
+    }
+  });
+
+  pi.on("tool_execution_start", (event, ctx) => {
+    try {
+      if (!project) return;
+      handleToolStart(event, ctx, project);
+    } catch (err) {
+      logError(project?.id ?? null, "tool_execution_start", err);
+    }
+  });
+
+  pi.on("tool_execution_end", (event, ctx) => {
+    try {
+      if (!project) return;
+      handleToolEnd(event, ctx, project);
+    } catch (err) {
+      logError(project?.id ?? null, "tool_execution_end", err);
+    }
+  });
+
+  pi.registerCommand(STATUS_CMD, {
+    description: "Show all instincts grouped by domain with confidence scores",
+    handler: (args: string, ctx: ExtensionCommandContext) =>
+      handleInstinctStatus(args, ctx, project?.id),
+  });
+
+  pi.registerCommand(EXPORT_CMD, {
+    description: "Export instincts to a JSON file",
+    handler: (args: string, ctx: ExtensionCommandContext) =>
+      handleInstinctExport(args, ctx, project?.id),
+  });
+
+  pi.registerCommand(IMPORT_CMD, {
+    description: "Import instincts from a JSON file",
+    handler: (args: string, ctx: ExtensionCommandContext) =>
+      handleInstinctImport(args, ctx, project?.id),
+  });
+
+  pi.registerCommand(PROMOTE_CMD, {
+    description: "Promote project instincts to global scope",
+    handler: (args: string, ctx: ExtensionCommandContext) =>
+      handleInstinctPromote(args, ctx, project?.id),
+  });
+
+  pi.registerCommand(EVOLVE_CMD, {
+    description: "Analyze instincts and suggest improvements (LLM-powered)",
+    handler: (args: string, ctx: ExtensionCommandContext) =>
+      handleInstinctEvolve(
+        args,
+        ctx,
+        pi,
+        project?.id,
+        undefined,
+        project?.root ?? null,
+        installedSkills
+      ),
+  });
+
+  pi.registerCommand(PROJECTS_CMD, {
+    description: "List all known projects and their instinct counts",
+    handler: (args: string, ctx: ExtensionCommandContext) =>
+      handleInstinctProjects(args, ctx),
+  });
+}

package/src/instinct-decay.ts

@@ -0,0 +1,117 @@
+/**
+ * Passive confidence decay for instincts.
+ * Applied at the start of each analysis run to age out stale instincts.
+ *
+ * Decay: -0.02 per week since updated_at, clamped to [0.1, 0.9].
+ * Instincts dropping below 0.1 are flagged for removal.
+ *
+ * US-031: Passive Confidence Decay
+ */
+
+import { applyPassiveDecay } from "./confidence.js";
+import { listInstincts, saveInstinct } from "./instinct-store.js";
+import {
+  getBaseDir,
+  getProjectInstinctsDir,
+  getGlobalInstinctsDir,
+} from "./storage.js";
+import type { Instinct } from "./types.js";
+
+// ---------------------------------------------------------------------------
+// Constants
+// ---------------------------------------------------------------------------
+
+/**
+ * Minimum confidence change required to persist the instinct back to disk.
+ * Prevents excessive writes for negligibly small elapsed times.
+ * At 5-minute analysis intervals, elapsed decay is ~0.000002 - well below this.
+ */
+const DECAY_CHANGE_THRESHOLD = 0.001;
+
+// ---------------------------------------------------------------------------
+// Public API
+// ---------------------------------------------------------------------------
+
+/**
+ * Applies passive decay to a single instinct.
+ *
+ * Returns the updated instinct (with adjusted confidence and refreshed
+ * updated_at) when the decay is significant, or null if no meaningful
+ * change occurred.
+ *
+ * Does not mutate the input instinct.
+ */
+export function applyDecayToInstinct(instinct: Instinct): Instinct | null {
+  const result = applyPassiveDecay(instinct.confidence, instinct.updated_at);
+
+  const decayAmount = Math.abs(result.confidence - instinct.confidence);
+  const flagChanged =
+    Boolean(result.flaggedForRemoval) !== Boolean(instinct.flagged_for_removal);
+
+  if (decayAmount < DECAY_CHANGE_THRESHOLD && !flagChanged) {
+    return null;
+  }
+
+  const updated: Instinct = {
+    ...instinct,
+    confidence: result.confidence,
+    updated_at: new Date().toISOString(),
+  };
+
+  // Set or clear flagged_for_removal using delete pattern (exactOptionalPropertyTypes)
+  if (result.flaggedForRemoval) {
+    (updated as Partial<Instinct>).flagged_for_removal = true;
+  } else {
+    delete (updated as Partial<Instinct>).flagged_for_removal;
+  }
+
+  return updated;
+}
+
+/**
+ * Applies decay to all instincts found in a directory.
+ * Saves any instincts with meaningful confidence changes.
+ *
+ * @param dir - Directory containing .md instinct files
+ * @returns Number of instincts updated on disk
+ */
+export function applyDecayInDir(dir: string): number {
+  const instincts = listInstincts(dir);
+  let updatedCount = 0;
+
+  for (const instinct of instincts) {
+    const updated = applyDecayToInstinct(instinct);
+    if (updated !== null) {
+      saveInstinct(updated, dir);
+      updatedCount++;
+    }
+  }
+
+  return updatedCount;
+}
+
+/**
+ * Runs a full decay pass over personal instincts for a project and globally.
+ * Called at the start of each analysis run, before the Haiku subprocess
+ * applies feedback adjustments.
+ *
+ * @param projectId - Project ID to decay (skipped when null/undefined)
+ * @param baseDir - Base storage directory (defaults to ~/.pi/continuous-learning/)
+ * @returns Total number of instincts updated across both scopes
+ */
+export function runDecayPass(
+  projectId?: string | null,
+  baseDir = getBaseDir()
+): number {
+  let total = 0;
+
+  if (projectId) {
+    const projectDir = getProjectInstinctsDir(projectId, "personal", baseDir);
+    total += applyDecayInDir(projectDir);
+  }
+
+  const globalDir = getGlobalInstinctsDir("personal", baseDir);
+  total += applyDecayInDir(globalDir);
+
+  return total;
+}

package/src/instinct-evolve.ts

@@ -0,0 +1,44 @@
+import type { ExtensionAPI, ExtensionCommandContext } from "@mariozechner/pi-coding-agent";
+import type { InstalledSkill } from "./types.js";
+import { homedir } from "node:os";
+import { join } from "node:path";
+import { getBaseDir } from "./storage.js";
+import { readAgentsMd } from "./agents-md.js";
+import { loadProjectInstincts, loadGlobalInstincts } from "./instinct-store.js";
+import { filterInstincts } from "./instinct-loader.js";
+import { buildEvolvePrompt } from "./prompts/evolve-prompt.js";
+
+const MAX_EVOLVE_INSTINCTS = 100;
+
+export const COMMAND_NAME = "instinct-evolve";
+
+export async function handleInstinctEvolve(
+  _args: string,
+  ctx: ExtensionCommandContext,
+  pi: ExtensionAPI,
+  projectId?: string | null,
+  baseDir?: string,
+  projectRoot?: string | null,
+  installedSkills?: InstalledSkill[]
+): Promise<void> {
+  const effectiveBase = baseDir ?? getBaseDir();
+  const projectInstincts = projectId ? loadProjectInstincts(projectId, effectiveBase) : [];
+  const globalInstincts = loadGlobalInstincts(effectiveBase);
+  const allInstincts = filterInstincts(
+    [...projectInstincts, ...globalInstincts],
+    0.1,
+    MAX_EVOLVE_INSTINCTS
+  );
+
+  if (allInstincts.length === 0) {
+    ctx.ui.notify("No instincts to analyze. Keep using pi to accumulate instincts first.", "info");
+    return;
+  }
+
+  const agentsMdProject =
+    projectRoot != null ? readAgentsMd(join(projectRoot, "AGENTS.md")) : null;
+  const agentsMdGlobal = readAgentsMd(join(homedir(), ".pi", "agent", "AGENTS.md"));
+
+  const prompt = buildEvolvePrompt(allInstincts, agentsMdProject, agentsMdGlobal, installedSkills);
+  pi.sendUserMessage(prompt, { deliverAs: "followUp" });
+}