pi-continuous-learning 0.5.1 → 0.7.0

package/src/cli/analyze.ts

@@ -7,36 +7,36 @@ import {
   unlinkSync,
 } from "node:fs";
 import { join } from "node:path";
-import {
-  createAgentSession,
-  SessionManager,
-  AuthStorage,
-  ModelRegistry,
-  DefaultResourceLoader,
-} from "@mariozechner/pi-coding-agent";
+import { AuthStorage } from "@mariozechner/pi-coding-agent";
 import { getModel } from "@mariozechner/pi-ai";
 
 import { loadConfig, DEFAULT_CONFIG } from "../config.js";
-import type { ProjectEntry } from "../types.js";
+import type { InstalledSkill, ProjectEntry } from "../types.js";
 import {
   getBaseDir,
   getProjectsRegistryPath,
   getObservationsPath,
   getProjectDir,
+  getProjectInstinctsDir,
+  getGlobalInstinctsDir,
 } from "../storage.js";
 import { countObservations } from "../observations.js";
 import { runDecayPass } from "../instinct-decay.js";
-import { buildAnalyzerUserPrompt, tailObservationsSince } from "../prompts/analyzer-user.js";
-import { buildAnalyzerSystemPrompt } from "./analyze-prompt.js";
+import { runCleanupPass } from "../instinct-cleanup.js";
+import { tailObservationsSince } from "../prompts/analyzer-user.js";
+import { buildSingleShotSystemPrompt } from "../prompts/analyzer-system-single-shot.js";
+import { buildSingleShotUserPrompt } from "../prompts/analyzer-user-single-shot.js";
+import {
+  runSingleShot,
+  buildInstinctFromChange,
+} from "./analyze-single-shot.js";
 import {
-  createInstinctListTool,
-  createInstinctReadTool,
-  createInstinctWriteTool,
-  createInstinctDeleteTool,
-} from "../instinct-tools.js";
+  loadProjectInstincts,
+  loadGlobalInstincts,
+  saveInstinct,
+} from "../instinct-store.js";
 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";
 
 // ---------------------------------------------------------------------------
@@ -59,7 +59,6 @@ function acquireLock(baseDir: string): boolean {
       const lock = JSON.parse(content) as { pid: number; started_at: string };
       const age = Date.now() - new Date(lock.started_at).getTime();
 
-      // Check if the owning process is still alive
       try {
         process.kill(lock.pid, 0); // signal 0 = existence check, no actual signal
         if (age < LOCK_STALE_MS) {
@@ -104,72 +103,6 @@ function startGlobalTimeout(timeoutMs: number, logger: AnalyzeLogger): void {
   }, 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
 // ---------------------------------------------------------------------------
@@ -237,10 +170,13 @@ async function analyzeProject(
 
   const obsPath = getObservationsPath(project.id, baseDir);
   const sinceLineCount = meta.last_observation_line_count ?? 0;
-  const { lines: newObsLines, totalLineCount } = tailObservationsSince(obsPath, sinceLineCount);
+  const { lines: newObsLines, totalLineCount, rawLineCount } = tailObservationsSince(
+    obsPath,
+    sinceLineCount
+  );
 
   if (newObsLines.length === 0) {
-    return { ran: false, skippedReason: "no new observation lines" };
+    return { ran: false, skippedReason: "no new observation lines after preprocessing" };
   }
 
   const obsCount = countObservations(project.id, baseDir);
@@ -249,11 +185,15 @@ async function analyzeProject(
   }
 
   const startTime = Date.now();
-  logger.projectStart(project.id, project.name, newObsLines.length, obsCount);
+  logger.projectStart(project.id, project.name, rawLineCount, obsCount);
 
+  runCleanupPass(project.id, config, baseDir);
   runDecayPass(project.id, baseDir);
 
-  const instinctsDir = join(getProjectDir(project.id, baseDir), "instincts", "personal");
+  // Load current instincts inline - no tool calls needed
+  const projectInstincts = loadProjectInstincts(project.id, baseDir);
+  const globalInstincts = loadGlobalInstincts(baseDir);
+  const allInstincts = [...projectInstincts, ...globalInstincts];
 
   const agentsMdProject = readAgentsMd(join(project.root, "AGENTS.md"));
   const agentsMdGlobal = readAgentsMd(join(homedir(), ".pi", "agent", "AGENTS.md"));
@@ -270,68 +210,98 @@ async function analyzeProject(
     // Skills loading is best-effort - continue without them
   }
 
-  const userPrompt = buildAnalyzerUserPrompt(obsPath, instinctsDir, project, {
+  const userPrompt = buildSingleShotUserPrompt(project, allInstincts, newObsLines, {
     agentsMdProject,
     agentsMdGlobal,
     installedSkills,
-    observationLines: newObsLines,
   });
 
   const authStorage = AuthStorage.create();
-  const modelRegistry = new ModelRegistry(authStorage);
   const modelId = (config.model || DEFAULT_CONFIG.model) as Parameters<typeof getModel>[1];
   const model = getModel("anthropic", modelId);
+  const apiKey = await authStorage.getApiKey("anthropic");
 
-  // Track instinct operations
-  const instinctCounts: InstinctOpCounts = { created: 0, updated: 0, deleted: 0 };
-  const trackedTools = wrapInstinctToolsWithTracking(project.id, project.name, baseDir, instinctCounts);
+  if (!apiKey) {
+    throw new Error("No Anthropic API key configured. Set via auth.json or ANTHROPIC_API_KEY.");
+  }
 
-  const customTools = [
-    trackedTools.listTool,
-    trackedTools.readTool,
-    trackedTools.writeTool,
-    trackedTools.deleteTool,
-  ];
+  const context = {
+    systemPrompt: buildSingleShotSystemPrompt(),
+    messages: [
+      { role: "user" as const, content: userPrompt, timestamp: Date.now() },
+    ],
+  };
 
-  const loader = new DefaultResourceLoader({
-    systemPromptOverride: () => buildAnalyzerSystemPrompt(),
-  });
-  await loader.reload();
-
-  const { session } = await createAgentSession({
-    model,
-    authStorage,
-    modelRegistry,
-    sessionManager: SessionManager.inMemory(),
-    customTools,
-    resourceLoader: loader,
-  });
+  const timeoutMs = (config.timeout_seconds ?? DEFAULT_CONFIG.timeout_seconds) * 1000;
+  const abortController = new AbortController();
+  const timeoutHandle = setTimeout(() => abortController.abort(), timeoutMs);
+
+  const instinctCounts = { created: 0, updated: 0, deleted: 0 };
+  const projectInstinctsDir = getProjectInstinctsDir(project.id, "personal", baseDir);
+  const globalInstinctsDir = getGlobalInstinctsDir("personal", baseDir);
 
+  let singleShotMessage;
   try {
-    await session.prompt(userPrompt);
+    const result = await runSingleShot(context, model, apiKey, abortController.signal);
+    singleShotMessage = result.message;
+
+    // Enforce creation rate limit: only the first N create actions per run are applied.
+    const maxNewInstincts = config.max_new_instincts_per_run ?? DEFAULT_CONFIG.max_new_instincts_per_run;
+    let createsRemaining = maxNewInstincts;
+
+    for (const change of result.changes) {
+      if (change.action === "delete") {
+        const id = change.id;
+        if (!id) continue;
+        const dir = change.scope === "global" ? globalInstinctsDir : projectInstinctsDir;
+        const filePath = join(dir, `${id}.md`);
+        if (existsSync(filePath)) {
+          unlinkSync(filePath);
+          instinctCounts.deleted++;
+        }
+      } else if (change.action === "create") {
+        if (createsRemaining <= 0) continue; // rate limit reached
+        const existing = allInstincts.find((i) => i.id === change.instinct?.id) ?? null;
+        const instinct = buildInstinctFromChange(change, existing, project.id, allInstincts);
+        if (!instinct) continue;
+
+        const dir = instinct.scope === "global" ? globalInstinctsDir : projectInstinctsDir;
+        saveInstinct(instinct, dir);
+        instinctCounts.created++;
+        createsRemaining--;
+      } else {
+        // update
+        const existing = allInstincts.find((i) => i.id === change.instinct?.id) ?? null;
+        const instinct = buildInstinctFromChange(change, existing, project.id, allInstincts);
+        if (!instinct) continue;
+
+        const dir = instinct.scope === "global" ? globalInstinctsDir : projectInstinctsDir;
+        saveInstinct(instinct, dir);
+        instinctCounts.updated++;
+      }
+    }
   } finally {
-    session.dispose();
+    clearTimeout(timeoutHandle);
   }
 
-  // Collect stats after session completes
-  const sessionStats = session.getSessionStats();
+  const usage = singleShotMessage!.usage;
   const durationMs = Date.now() - startTime;
 
   const stats: ProjectRunStats = {
     project_id: project.id,
     project_name: project.name,
     duration_ms: durationMs,
-    observations_processed: newObsLines.length,
+    observations_processed: rawLineCount,
     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,
+    tokens_input: usage.input,
+    tokens_output: usage.output,
+    tokens_cache_read: usage.cacheRead,
+    tokens_cache_write: usage.cacheWrite,
+    tokens_total: usage.totalTokens,
+    cost_usd: usage.cost.total,
     model: modelId,
   };
 
@@ -420,7 +390,6 @@ async function main(): Promise<void> {
 
 main().catch((err) => {
   releaseLock(getBaseDir());
-  // Last-resort logging - config may not have loaded
   const logger = new AnalyzeLogger();
   logger.error("Fatal error", err);
   process.exit(1);

package/src/command-scaffold.ts

@@ -0,0 +1,105 @@
+/**
+ * Command scaffolding from instinct clusters.
+ *
+ * When 3+ related instincts in the same domain form an actionable workflow,
+ * generates a Pi slash command scaffold that codifies the pattern.
+ */
+
+import type { Instinct } from "./types.js";
+import type { DomainCluster } from "./graduation.js";
+
+// ---------------------------------------------------------------------------
+// Types
+// ---------------------------------------------------------------------------
+
+export interface CommandScaffold {
+  name: string;
+  description: string;
+  domain: string;
+  content: string;
+  sourceInstinctIds: string[];
+}
+
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+
+function toCommandName(domain: string): string {
+  return domain.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "");
+}
+
+function formatInstinctAsStep(instinct: Instinct, index: number): string {
+  return [
+    `${index + 1}. **${instinct.title}**`,
+    `   - Trigger: ${instinct.trigger}`,
+    `   - Action: ${instinct.action}`,
+    "",
+  ].join("\n");
+}
+
+// ---------------------------------------------------------------------------
+// Public API
+// ---------------------------------------------------------------------------
+
+/**
+ * Generates a command scaffold from a domain cluster of instincts.
+ * The scaffold describes a slash command that encodes the workflow
+ * distilled from the instinct cluster.
+ */
+export function generateCommandScaffold(cluster: DomainCluster): CommandScaffold {
+  const name = toCommandName(cluster.domain);
+  const sortedInstincts = [...cluster.instincts].sort(
+    (a, b) => b.confidence - a.confidence
+  );
+
+  const description = `Learned ${cluster.domain} workflow from coding sessions. ` +
+    `Encodes ${sortedInstincts.length} steps distilled from instinct observations.`;
+
+  const steps = sortedInstincts.map((inst, i) => formatInstinctAsStep(inst, i));
+
+  const content = [
+    `# /${name} Command`,
+    "",
+    `> Auto-generated from ${sortedInstincts.length} graduated instincts in the "${cluster.domain}" domain.`,
+    "",
+    `## Description`,
+    "",
+    description,
+    "",
+    `## Command: \`/${name}\``,
+    "",
+    `When invoked, this command should guide the agent through these steps:`,
+    "",
+    ...steps,
+    `## Implementation Notes`,
+    "",
+    `Register this command in your Pi extension's \`index.ts\`:`,
+    "",
+    "```typescript",
+    `pi.registerCommand("${name}", {`,
+    `  description: "${description.replace(/"/g, '\\"')}",`,
+    `  handler: async (args, ctx) => {`,
+    `    // TODO: Implement ${name} workflow`,
+    `  },`,
+    `});`,
+    "```",
+    "",
+  ].join("\n");
+
+  return {
+    name,
+    description,
+    domain: cluster.domain,
+    content,
+    sourceInstinctIds: sortedInstincts.map((i) => i.id),
+  };
+}
+
+/**
+ * Generates command scaffolds for all qualifying clusters.
+ */
+export function generateAllCommandScaffolds(
+  clusters: DomainCluster[]
+): CommandScaffold[] {
+  return clusters.map(generateCommandScaffold);
+}

package/src/confidence.ts

@@ -26,7 +26,8 @@ const DELTA_CONTRADICTED = -0.15;
 const DELTA_INACTIVE = 0;
 
 // applyPassiveDecay
-const DECAY_PER_WEEK = 0.02;
+// Increased from 0.02 to 0.05: at 0.5 confidence, reaches 0.1 in ~8 weeks instead of 20.
+const DECAY_PER_WEEK = 0.05;
 const MS_PER_WEEK = 7 * 24 * 60 * 60 * 1000;
 
 // ---------------------------------------------------------------------------

package/src/config.ts

@@ -38,6 +38,34 @@ export const CONFIG_PATH = path.join(
   "config.json"
 );
 
+// ---------------------------------------------------------------------------
+// Graduation maturity criteria
+// ---------------------------------------------------------------------------
+
+/** Minimum age in days before an instinct is eligible for graduation. */
+export const GRADUATION_MIN_AGE_DAYS = 7;
+
+/** Minimum confidence to qualify for graduation. */
+export const GRADUATION_MIN_CONFIDENCE = 0.75;
+
+/** Minimum confirmed_count to qualify for graduation. */
+export const GRADUATION_MIN_CONFIRMED = 3;
+
+/** Maximum contradicted_count allowed for graduation. */
+export const GRADUATION_MAX_CONTRADICTED = 1;
+
+/** Minimum related instincts in same domain to propose a skill scaffold. */
+export const GRADUATION_SKILL_CLUSTER_SIZE = 3;
+
+/** Minimum related instincts in same domain to propose a command scaffold. */
+export const GRADUATION_COMMAND_CLUSTER_SIZE = 3;
+
+/** Maximum instinct age in days before TTL cull (aggressive decay / deletion). */
+export const GRADUATION_TTL_MAX_DAYS = 28;
+
+/** Confidence threshold below which TTL-expired instincts are deleted outright. */
+export const GRADUATION_TTL_CULL_CONFIDENCE = 0.3;
+
 export const DEFAULT_CONFIG: Config = {
   run_interval_minutes: 5,
   min_observations_to_analyze: 20,
@@ -49,6 +77,12 @@ export const DEFAULT_CONFIG: Config = {
   active_hours_start: 8,
   active_hours_end: 23,
   max_idle_seconds: 1800,
+  // Volume control defaults
+  max_total_instincts_per_project: 30,
+  max_total_instincts_global: 20,
+  max_new_instincts_per_run: 3,
+  flagged_cleanup_days: 7,
+  instinct_ttl_days: 28,
 };
 
 // ---------------------------------------------------------------------------
@@ -68,6 +102,12 @@ const PartialConfigSchema = Type.Partial(
     active_hours_end: Type.Number(),
     max_idle_seconds: Type.Number(),
     log_path: Type.String(),
+    // Volume control
+    max_total_instincts_per_project: Type.Number(),
+    max_total_instincts_global: Type.Number(),
+    max_new_instincts_per_run: Type.Number(),
+    flagged_cleanup_days: Type.Number(),
+    instinct_ttl_days: Type.Number(),
   })
 );