pi-continuous-learning 0.3.0 → 0.5.0

package/src/cli/analyze.ts

@@ -37,13 +37,14 @@ import {
 import { readAgentsMd } from "../agents-md.js";
 import { homedir } from "node:os";
 import type { InstalledSkill } from "../types.js";
+import { AnalyzeLogger, type ProjectRunStats, type RunSummary } from "./analyze-logger.js";
 
 // ---------------------------------------------------------------------------
-// Lockfile guard — ensures only one instance runs at a time
+// Lockfile guard - ensures only one instance runs at a time
 // ---------------------------------------------------------------------------
 
 const LOCKFILE_NAME = "analyze.lock";
-const LOCK_STALE_MS = 10 * 60 * 1000; // 10 minutes — stale lock threshold
+const LOCK_STALE_MS = 10 * 60 * 1000; // 10 minutes - stale lock threshold
 
 function getLockfilePath(baseDir: string): string {
   return join(baseDir, LOCKFILE_NAME);
@@ -64,12 +65,12 @@ function acquireLock(baseDir: string): boolean {
         if (age < LOCK_STALE_MS) {
           return false; // Process alive and lock is fresh
         }
-        // Process alive but lock is stale — treat as abandoned
+        // Process alive but lock is stale - treat as abandoned
       } catch {
-        // Process is dead — lock is orphaned, safe to take over
+        // Process is dead - lock is orphaned, safe to take over
       }
     } catch {
-      // Malformed lockfile — remove and proceed
+      // Malformed lockfile - remove and proceed
     }
   }
 
@@ -86,7 +87,7 @@ function releaseLock(baseDir: string): void {
   try {
     if (existsSync(lockPath)) unlinkSync(lockPath);
   } catch {
-    // Best effort — don't crash on cleanup
+    // Best effort - don't crash on cleanup
   }
 }
 
@@ -96,13 +97,79 @@ function releaseLock(baseDir: string): void {
 
 const DEFAULT_TIMEOUT_MS = 5 * 60 * 1000; // 5 minutes total
 
-function startGlobalTimeout(timeoutMs: number): void {
+function startGlobalTimeout(timeoutMs: number, logger: AnalyzeLogger): void {
   setTimeout(() => {
-    console.error("[analyze] Global timeout reached. Exiting.");
+    logger.error("Global timeout reached, forcing exit");
     process.exit(2);
   }, timeoutMs).unref();
 }
 
+// ---------------------------------------------------------------------------
+// Instinct operation tracking
+// ---------------------------------------------------------------------------
+
+interface InstinctOpCounts {
+  created: number;
+  updated: number;
+  deleted: number;
+}
+
+/**
+ * Wraps instinct tools to count create/update/delete operations.
+ * Returns new tool instances that increment the provided counts.
+ */
+function wrapInstinctToolsWithTracking(
+  projectId: string,
+  projectName: string,
+  baseDir: string,
+  counts: InstinctOpCounts
+) {
+  const writeTool = createInstinctWriteTool(projectId, projectName, baseDir);
+  const deleteTool = createInstinctDeleteTool(projectId, baseDir);
+
+  const trackedWrite = {
+    ...writeTool,
+    async execute(
+      toolCallId: string,
+      params: Parameters<typeof writeTool.execute>[1],
+      signal: AbortSignal | undefined,
+      onUpdate: unknown,
+      ctx: unknown
+    ) {
+      const result = await writeTool.execute(toolCallId, params, signal, onUpdate, ctx);
+      const details = result.details as { action?: string } | undefined;
+      if (details?.action === "created") {
+        counts.created++;
+      } else {
+        counts.updated++;
+      }
+      return result;
+    },
+  };
+
+  const trackedDelete = {
+    ...deleteTool,
+    async execute(
+      toolCallId: string,
+      params: Parameters<typeof deleteTool.execute>[1],
+      signal: AbortSignal | undefined,
+      onUpdate: unknown,
+      ctx: unknown
+    ) {
+      const result = await deleteTool.execute(toolCallId, params, signal, onUpdate, ctx);
+      counts.deleted++;
+      return result;
+    },
+  };
+
+  return {
+    listTool: createInstinctListTool(projectId, baseDir),
+    readTool: createInstinctReadTool(projectId, baseDir),
+    writeTool: trackedWrite,
+    deleteTool: trackedDelete,
+  };
+}
+
 // ---------------------------------------------------------------------------
 // Per-project analysis
 // ---------------------------------------------------------------------------
@@ -150,27 +217,39 @@ function hasNewObservations(projectId: string, meta: ProjectMeta, baseDir: strin
   return true;
 }
 
+interface AnalyzeResult {
+  readonly ran: boolean;
+  readonly stats?: ProjectRunStats;
+  readonly skippedReason?: string;
+}
+
 async function analyzeProject(
   project: ProjectEntry,
   config: ReturnType<typeof loadConfig>,
-  baseDir: string
-): Promise<boolean> {
+  baseDir: string,
+  logger: AnalyzeLogger
+): Promise<AnalyzeResult> {
   const meta = loadProjectMeta(project.id, baseDir);
 
-  if (!hasNewObservations(project.id, meta, baseDir)) return false;
+  if (!hasNewObservations(project.id, meta, baseDir)) {
+    return { ran: false, skippedReason: "no new observations" };
+  }
 
   const obsPath = getObservationsPath(project.id, baseDir);
   const sinceLineCount = meta.last_observation_line_count ?? 0;
   const { lines: newObsLines, totalLineCount } = tailObservationsSince(obsPath, sinceLineCount);
 
-  if (newObsLines.length === 0) return false;
+  if (newObsLines.length === 0) {
+    return { ran: false, skippedReason: "no new observation lines" };
+  }
 
   const obsCount = countObservations(project.id, baseDir);
-  if (obsCount < config.min_observations_to_analyze) return false;
+  if (obsCount < config.min_observations_to_analyze) {
+    return { ran: false, skippedReason: `below threshold (${obsCount}/${config.min_observations_to_analyze})` };
+  }
 
-  console.log(
-    `[analyze] Processing ${project.name} (${project.id}): ${newObsLines.length} new observations (${obsCount} total)`
-  );
+  const startTime = Date.now();
+  logger.projectStart(project.id, project.name, newObsLines.length, obsCount);
 
   runDecayPass(project.id, baseDir);
 
@@ -188,7 +267,7 @@ async function analyzeProject(
       description: s.description,
     }));
   } catch {
-    // Skills loading is best-effort — continue without them
+    // Skills loading is best-effort - continue without them
   }
 
   const userPrompt = buildAnalyzerUserPrompt(obsPath, instinctsDir, project, {
@@ -203,11 +282,15 @@ async function analyzeProject(
   const modelId = (config.model || DEFAULT_CONFIG.model) as Parameters<typeof getModel>[1];
   const model = getModel("anthropic", modelId);
 
+  // Track instinct operations
+  const instinctCounts: InstinctOpCounts = { created: 0, updated: 0, deleted: 0 };
+  const trackedTools = wrapInstinctToolsWithTracking(project.id, project.name, baseDir, instinctCounts);
+
   const customTools = [
-    createInstinctListTool(project.id, baseDir),
-    createInstinctReadTool(project.id, baseDir),
-    createInstinctWriteTool(project.id, project.name, baseDir),
-    createInstinctDeleteTool(project.id, baseDir),
+    trackedTools.listTool,
+    trackedTools.readTool,
+    trackedTools.writeTool,
+    trackedTools.deleteTool,
   ];
 
   const loader = new DefaultResourceLoader({
@@ -230,13 +313,37 @@ async function analyzeProject(
     session.dispose();
   }
 
+  // Collect stats after session completes
+  const sessionStats = session.getSessionStats();
+  const durationMs = Date.now() - startTime;
+
+  const stats: ProjectRunStats = {
+    project_id: project.id,
+    project_name: project.name,
+    duration_ms: durationMs,
+    observations_processed: newObsLines.length,
+    observations_total: obsCount,
+    instincts_created: instinctCounts.created,
+    instincts_updated: instinctCounts.updated,
+    instincts_deleted: instinctCounts.deleted,
+    tokens_input: sessionStats.tokens.input,
+    tokens_output: sessionStats.tokens.output,
+    tokens_cache_read: sessionStats.tokens.cacheRead,
+    tokens_cache_write: sessionStats.tokens.cacheWrite,
+    tokens_total: sessionStats.tokens.total,
+    cost_usd: sessionStats.cost,
+    model: modelId,
+  };
+
+  logger.projectComplete(stats);
+
   saveProjectMeta(
     project.id,
     { ...meta, last_analyzed_at: new Date().toISOString(), last_observation_line_count: totalLineCount },
     baseDir
   );
-  console.log(`[analyze] Completed ${project.name}`);
-  return true;
+
+  return { ran: true, stats };
 }
 
 // ---------------------------------------------------------------------------
@@ -245,35 +352,67 @@ async function analyzeProject(
 
 async function main(): Promise<void> {
   const baseDir = getBaseDir();
+  const config = loadConfig();
+  const logger = new AnalyzeLogger(config.log_path);
 
   if (!acquireLock(baseDir)) {
-    console.log("[analyze] Another instance is already running. Exiting.");
+    logger.info("Another instance is already running, exiting");
     process.exit(0);
   }
 
-  startGlobalTimeout(DEFAULT_TIMEOUT_MS);
+  startGlobalTimeout(DEFAULT_TIMEOUT_MS, logger);
+
+  const runStart = Date.now();
 
   try {
-    const config = loadConfig();
     const registry = loadProjectsRegistry(baseDir);
     const projects = Object.values(registry);
 
     if (projects.length === 0) {
-      console.log("[analyze] No projects registered. Use pi with the continuous-learning extension first.");
+      logger.info("No projects registered");
       return;
     }
 
+    logger.runStart(projects.length);
+
     let processed = 0;
+    let skipped = 0;
+    let errored = 0;
+    const allProjectStats: ProjectRunStats[] = [];
+
     for (const project of projects) {
       try {
-        const didRun = await analyzeProject(project, config, baseDir);
-        if (didRun) processed++;
+        const result = await analyzeProject(project, config, baseDir, logger);
+        if (result.ran && result.stats) {
+          processed++;
+          allProjectStats.push(result.stats);
+        } else {
+          skipped++;
+          if (result.skippedReason) {
+            logger.projectSkipped(project.id, project.name, result.skippedReason);
+          }
+        }
       } catch (err) {
-        console.error(`[analyze] Error processing ${project.name}: ${String(err)}`);
+        errored++;
+        logger.projectError(project.id, project.name, err);
       }
     }
 
-    console.log(`[analyze] Done. Processed ${processed}/${projects.length} project(s).`);
+    const summary: RunSummary = {
+      total_duration_ms: Date.now() - runStart,
+      projects_processed: processed,
+      projects_skipped: skipped,
+      projects_errored: errored,
+      projects_total: projects.length,
+      total_tokens: allProjectStats.reduce((sum, s) => sum + s.tokens_total, 0),
+      total_cost_usd: allProjectStats.reduce((sum, s) => sum + s.cost_usd, 0),
+      total_instincts_created: allProjectStats.reduce((sum, s) => sum + s.instincts_created, 0),
+      total_instincts_updated: allProjectStats.reduce((sum, s) => sum + s.instincts_updated, 0),
+      total_instincts_deleted: allProjectStats.reduce((sum, s) => sum + s.instincts_deleted, 0),
+      project_stats: allProjectStats,
+    };
+
+    logger.runComplete(summary);
   } finally {
     releaseLock(baseDir);
   }
@@ -281,6 +420,8 @@ async function main(): Promise<void> {
 
 main().catch((err) => {
   releaseLock(getBaseDir());
-  console.error(`[analyze] Fatal error: ${String(err)}`);
+  // Last-resort logging - config may not have loaded
+  const logger = new AnalyzeLogger();
+  logger.error("Fatal error", err);
   process.exit(1);
 });

package/src/config.ts

@@ -67,6 +67,7 @@ const PartialConfigSchema = Type.Partial(
     active_hours_start: Type.Number(),
     active_hours_end: Type.Number(),
     max_idle_seconds: Type.Number(),
+    log_path: Type.String(),
   })
 );
 

package/src/index.ts

@@ -15,6 +15,13 @@ 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 {
+  handleTurnStart,
+  handleTurnEnd,
+  handleUserBash,
+  handleSessionCompact,
+  handleModelSelect,
+} from "./session-observer.js";
 import {
   handleBeforeAgentStartInjection,
   handleAgentEndClearInstincts,
@@ -98,6 +105,51 @@ export default function (pi: ExtensionAPI): void {
     }
   });
 
+  pi.on("turn_start", (event, ctx) => {
+    try {
+      if (!project) return;
+      handleTurnStart(event, ctx, project);
+    } catch (err) {
+      logError(project?.id ?? null, "turn_start", err);
+    }
+  });
+
+  pi.on("turn_end", (event, ctx) => {
+    try {
+      if (!project) return;
+      handleTurnEnd(event, ctx, project);
+    } catch (err) {
+      logError(project?.id ?? null, "turn_end", err);
+    }
+  });
+
+  pi.on("user_bash", (event, ctx) => {
+    try {
+      if (!project) return;
+      handleUserBash(event, ctx, project);
+    } catch (err) {
+      logError(project?.id ?? null, "user_bash", err);
+    }
+  });
+
+  pi.on("session_compact", (event, ctx) => {
+    try {
+      if (!project) return;
+      handleSessionCompact(event, ctx, project);
+    } catch (err) {
+      logError(project?.id ?? null, "session_compact", err);
+    }
+  });
+
+  pi.on("model_select", (event, ctx) => {
+    try {
+      if (!project) return;
+      handleModelSelect(event, ctx, project);
+    } catch (err) {
+      logError(project?.id ?? null, "model_select", err);
+    }
+  });
+
   pi.registerCommand(STATUS_CMD, {
     description: "Show all instincts grouped by domain with confidence scores",
     handler: (args: string, ctx: ExtensionCommandContext) =>

package/src/prompt-observer.ts

@@ -76,12 +76,16 @@ export function handleAgentEnd(
   try {
     if (shouldSkipObservation()) return;
 
+    const contextUsage = ctx.getContextUsage();
+    const tokensUsed = contextUsage?.tokens ?? undefined;
+
     const observation: Observation = {
       timestamp: new Date().toISOString(),
       event: "agent_end",
       session: getSessionId(ctx),
       project_id: project.id,
       project_name: project.name,
+      ...(tokensUsed != null ? { tokens_used: tokensUsed } : {}),
       ...buildActiveInstincts(),
     };
 

package/src/session-observer.ts

@@ -0,0 +1,185 @@
+import type { ExtensionContext } from "@mariozechner/pi-coding-agent";
+
+import { getCurrentActiveInstincts } from "./active-instincts.js";
+import { appendObservation } from "./observations.js";
+import { scrubSecrets } from "./scrubber.js";
+import { logError } from "./error-logger.js";
+import type { Observation, ProjectEntry } from "./types.js";
+
+export interface TurnStartEvent {
+  type: "turn_start";
+  turnIndex: number;
+  timestamp: number;
+}
+
+export interface TurnEndEvent {
+  type: "turn_end";
+  turnIndex: number;
+  message: unknown;
+  toolResults: unknown[];
+}
+
+export interface UserBashEvent {
+  type: "user_bash";
+  command: string;
+  excludeFromContext: boolean;
+  cwd: string;
+}
+
+export interface SessionCompactEvent {
+  type: "session_compact";
+  compactionEntry: unknown;
+  fromExtension: boolean;
+}
+
+export interface ModelSelectEvent {
+  type: "model_select";
+  model: { id?: string; name?: string };
+  previousModel: { id?: string; name?: string } | undefined;
+  source: "set" | "cycle" | "restore";
+}
+
+function getSessionId(ctx: ExtensionContext): string {
+  return ctx.sessionManager.getSessionId();
+}
+
+function buildActiveInstincts(): Pick<Observation, "active_instincts"> {
+  const ids = getCurrentActiveInstincts();
+  return ids.length > 0 ? { active_instincts: ids } : {};
+}
+
+export function handleTurnStart(
+  event: TurnStartEvent,
+  ctx: ExtensionContext,
+  project: ProjectEntry,
+  baseDir?: string
+): void {
+  try {
+    const observation: Observation = {
+      timestamp: new Date().toISOString(),
+      event: "turn_start",
+      session: getSessionId(ctx),
+      project_id: project.id,
+      project_name: project.name,
+      turn_index: event.turnIndex,
+      ...buildActiveInstincts(),
+    };
+
+    appendObservation(observation, project.id, baseDir);
+  } catch (err) {
+    logError(project.id, "session-observer:handleTurnStart", err, baseDir);
+  }
+}
+
+export function handleTurnEnd(
+  event: TurnEndEvent,
+  ctx: ExtensionContext,
+  project: ProjectEntry,
+  baseDir?: string
+): void {
+  try {
+    const toolCount = event.toolResults?.length ?? 0;
+    const errorCount = Array.isArray(event.toolResults)
+      ? event.toolResults.filter((r: unknown) => {
+          if (r && typeof r === "object" && "isError" in r) {
+            return (r as { isError: boolean }).isError;
+          }
+          return false;
+        }).length
+      : 0;
+
+    const contextUsage = ctx.getContextUsage();
+    const tokensUsed = contextUsage?.tokens ?? undefined;
+
+    const observation: Observation = {
+      timestamp: new Date().toISOString(),
+      event: "turn_end",
+      session: getSessionId(ctx),
+      project_id: project.id,
+      project_name: project.name,
+      turn_index: event.turnIndex,
+      tool_count: toolCount,
+      error_count: errorCount,
+      ...(tokensUsed != null ? { tokens_used: tokensUsed } : {}),
+      ...buildActiveInstincts(),
+    };
+
+    appendObservation(observation, project.id, baseDir);
+  } catch (err) {
+    logError(project.id, "session-observer:handleTurnEnd", err, baseDir);
+  }
+}
+
+export function handleUserBash(
+  event: UserBashEvent,
+  ctx: ExtensionContext,
+  project: ProjectEntry,
+  baseDir?: string
+): void {
+  try {
+    const observation: Observation = {
+      timestamp: new Date().toISOString(),
+      event: "user_bash",
+      session: getSessionId(ctx),
+      project_id: project.id,
+      project_name: project.name,
+      command: scrubSecrets(event.command),
+      cwd: event.cwd,
+      ...buildActiveInstincts(),
+    };
+
+    appendObservation(observation, project.id, baseDir);
+  } catch (err) {
+    logError(project.id, "session-observer:handleUserBash", err, baseDir);
+  }
+}
+
+export function handleSessionCompact(
+  event: SessionCompactEvent,
+  ctx: ExtensionContext,
+  project: ProjectEntry,
+  baseDir?: string
+): void {
+  try {
+    const observation: Observation = {
+      timestamp: new Date().toISOString(),
+      event: "session_compact",
+      session: getSessionId(ctx),
+      project_id: project.id,
+      project_name: project.name,
+      from_extension: event.fromExtension,
+      ...buildActiveInstincts(),
+    };
+
+    appendObservation(observation, project.id, baseDir);
+  } catch (err) {
+    logError(project.id, "session-observer:handleSessionCompact", err, baseDir);
+  }
+}
+
+export function handleModelSelect(
+  event: ModelSelectEvent,
+  ctx: ExtensionContext,
+  project: ProjectEntry,
+  baseDir?: string
+): void {
+  try {
+    const modelName = event.model?.id ?? event.model?.name ?? "unknown";
+    const previousModelName = event.previousModel?.id ?? event.previousModel?.name;
+
+    const observation: Observation = {
+      timestamp: new Date().toISOString(),
+      event: "model_select",
+      session: getSessionId(ctx),
+      project_id: project.id,
+      project_name: project.name,
+      model: modelName,
+      ...(previousModelName ? { previous_model: previousModelName } : {}),
+      model_change_source: event.source,
+    };
+
+    appendObservation(observation, project.id, baseDir);
+  } catch (err) {
+    logError(project.id, "session-observer:handleModelSelect", err, baseDir);
+  }
+}

package/src/types.ts

@@ -11,7 +11,12 @@ export type ObservationEvent =
   | "tool_start"
   | "tool_complete"
   | "user_prompt"
-  | "agent_end";
+  | "agent_end"
+  | "turn_start"
+  | "turn_end"
+  | "user_bash"
+  | "session_compact"
+  | "model_select";
 
 export interface Observation {
   timestamp: string; // ISO 8601 UTC
@@ -24,6 +29,16 @@ export interface Observation {
   output?: string;
   is_error?: boolean;
   active_instincts?: string[];
+  turn_index?: number;
+  tool_count?: number;
+  error_count?: number;
+  tokens_used?: number;
+  command?: string;
+  cwd?: string;
+  from_extension?: boolean;
+  model?: string;
+  previous_model?: string;
+  model_change_source?: string;
 }
 
 // ---------------------------------------------------------------------------
@@ -87,4 +102,5 @@ export interface Config {
   active_hours_start: number; // 0-23
   active_hours_end: number; // 0-23
   max_idle_seconds: number;
+  log_path?: string; // Override analyzer log location (default: ~/.pi/continuous-learning/analyzer.log)
 }