chainlesschain 0.45.75 → 0.45.77

package/src/lib/learning/skill-synthesizer.js

@@ -0,0 +1,315 @@
+/**
+ * SkillSynthesizer — Automatically creates SKILL.md files from
+ * successful complex execution trajectories.
+ *
+ * Trigger conditions (all must be met):
+ *   1. tool_count >= minToolCount (default 5)
+ *   2. outcome_score >= minScore (default 0.7)
+ *   3. synthesized_skill IS NULL
+ *   4. At least minSimilar similar trajectories exist
+ *
+ * Process:
+ *   1. Find eligible trajectories
+ *   2. Check for duplicates (tool chain fingerprint)
+ *   3. Send to LLM for pattern extraction
+ *   4. Generate SKILL.md
+ *   5. Write to workspace skill layer
+ */
+
+import fs from "fs";
+import path from "path";
+
+// ── _deps for test injection ────────────────────────────
+
+const _deps = { fs, path };
+
+// ── Helpers ─────────────────────────────────────────────
+
+/**
+ * Extract unique tool names from a tool chain.
+ * @param {Array<{tool:string}>} toolChain
+ * @returns {string[]}
+ */
+export function extractToolNames(toolChain) {
+  return [...new Set((toolChain || []).map((t) => t.tool))];
+}
+
+/**
+ * Compute tool chain fingerprint (sorted tool name set).
+ * Used for deduplication.
+ * @param {Array<{tool:string}>} toolChain
+ * @returns {string}
+ */
+export function toolChainFingerprint(toolChain) {
+  return extractToolNames(toolChain).sort().join(",");
+}
+
+/**
+ * Check if two fingerprints overlap by at least threshold.
+ * Uses Jaccard index on the tool sets.
+ * @param {string} fp1
+ * @param {string} fp2
+ * @param {number} [threshold=0.7]
+ * @returns {boolean}
+ */
+export function fingerprintsOverlap(fp1, fp2, threshold = 0.7) {
+  const set1 = new Set(fp1.split(",").filter(Boolean));
+  const set2 = new Set(fp2.split(",").filter(Boolean));
+  const intersection = [...set1].filter((t) => set2.has(t)).length;
+  const union = new Set([...set1, ...set2]).size;
+  return union > 0 ? intersection / union >= threshold : false;
+}
+
+/**
+ * Generate a kebab-case skill name from user intent.
+ * @param {string} userIntent
+ * @returns {string}
+ */
+export function generateSkillName(userIntent) {
+  if (!userIntent) return "auto-learned-skill";
+  return (
+    userIntent
+      .toLowerCase()
+      .replace(/[^a-z0-9\u4e00-\u9fff\s-]/g, "")
+      .trim()
+      .split(/\s+/)
+      .slice(0, 4)
+      .join("-") || "auto-learned-skill"
+  );
+}
+
+// ── LLM prompt template ─────────────────────────────────
+
+/**
+ * Build the LLM prompt for pattern extraction.
+ * @param {object} trajectory
+ * @returns {Array<{role:string, content:string}>}
+ */
+export function buildExtractionPrompt(trajectory) {
+  const toolSteps = (trajectory.toolChain || [])
+    .map(
+      (t, i) =>
+        `  ${i + 1}. ${t.tool}(${JSON.stringify(t.args || {}).slice(0, 200)}) → ${t.status} (${t.durationMs || 0}ms)`,
+    )
+    .join("\n");
+
+  return [
+    {
+      role: "system",
+      content: `You are a skill extraction expert. Analyze execution trajectories and extract reusable workflow patterns.
+Output ONLY valid JSON with these fields:
+{
+  "name": "kebab-case-name",
+  "description": "One-line description",
+  "procedure": ["Step 1", "Step 2", ...],
+  "pitfalls": ["Pitfall 1: description", ...],
+  "verification": "How to confirm success",
+  "tools": ["tool_name_1", "tool_name_2"]
+}
+If the trajectory is too specific or not reusable, respond with: {"not_applicable": true}`,
+    },
+    {
+      role: "user",
+      content: `## Execution Trajectory
+User intent: ${trajectory.userIntent || "unknown"}
+Tool chain:
+${toolSteps}
+Final response: ${(trajectory.finalResponse || "").slice(0, 500)}`,
+    },
+  ];
+}
+
+/**
+ * Generate SKILL.md content from extracted pattern.
+ * @param {object} pattern — { name, description, procedure, pitfalls, verification, tools }
+ * @param {string} trajectoryId
+ * @param {number} [confidence=0.7]
+ * @returns {string}
+ */
+export function generateSkillMd(pattern, trajectoryId, confidence = 0.7) {
+  const tools = (pattern.tools || []).join(", ");
+  const procedure = (pattern.procedure || [])
+    .map((step, i) => `${i + 1}. ${step}`)
+    .join("\n");
+  const pitfalls = (pattern.pitfalls || []).map((p) => `- ${p}`).join("\n");
+
+  return `---
+name: ${pattern.name}
+description: ${pattern.description || "Auto-learned skill"}
+version: 1.0.0
+category: auto-learned
+tags: [auto-synthesized]
+tools: [${tools}]
+---
+
+## Procedure
+${procedure || "1. Follow the extracted workflow"}
+
+## Pitfalls
+${pitfalls || "- None identified yet"}
+
+## Verification
+${pattern.verification || "Verify the task completed successfully"}
+
+## Metadata
+- Source: trajectory
+- Trajectory ID: ${trajectoryId}
+- Confidence: ${confidence}
+- Created by: learning-loop
+`;
+}
+
+// ── SkillSynthesizer class ──────────────────────────────
+
+export class SkillSynthesizer {
+  /**
+   * @param {import("better-sqlite3").Database} db
+   * @param {function} llmChat — async (messages) => string (LLM response)
+   * @param {import("./trajectory-store.js").TrajectoryStore} trajectoryStore
+   * @param {{minToolCount?:number, minScore?:number, minSimilar?:number, outputDir?:string}} [config]
+   */
+  constructor(db, llmChat, trajectoryStore, config = {}) {
+    this.db = db;
+    this.llmChat = llmChat;
+    this.trajectoryStore = trajectoryStore;
+    this.minToolCount = config.minToolCount ?? 5;
+    this.minScore = config.minScore ?? 0.7;
+    this.minSimilar = config.minSimilar ?? 2;
+    this.outputDir = config.outputDir || null;
+  }
+
+  /**
+   * Scan for eligible trajectories and synthesize skills.
+   * @returns {Promise<{created: string[], skipped: string[]}>}
+   */
+  async synthesize() {
+    const candidates = this.trajectoryStore.findComplexUnprocessed({
+      minToolCount: this.minToolCount,
+      minScore: this.minScore,
+      limit: 10,
+    });
+
+    const created = [];
+    const skipped = [];
+
+    for (const traj of candidates) {
+      try {
+        // Check similarity count
+        const toolNames = extractToolNames(traj.toolChain);
+        const similar = this.trajectoryStore.findSimilar(toolNames, {
+          minSimilarity: 0.5,
+          excludeId: traj.id,
+        });
+
+        if (similar.length < this.minSimilar) {
+          skipped.push(
+            `${traj.id}: insufficient similar trajectories (${similar.length}/${this.minSimilar})`,
+          );
+          continue;
+        }
+
+        // Check dedup against existing synthesized skills
+        const fp = toolChainFingerprint(traj.toolChain);
+        if (this._isDuplicate(fp)) {
+          skipped.push(`${traj.id}: duplicate fingerprint`);
+          continue;
+        }
+
+        // Extract pattern via LLM
+        const pattern = await this._extractPattern(traj);
+        if (!pattern || pattern.not_applicable) {
+          skipped.push(`${traj.id}: LLM deemed not applicable`);
+          continue;
+        }
+
+        // Generate and persist
+        const skillName = pattern.name || generateSkillName(traj.userIntent);
+        const content = generateSkillMd(
+          pattern,
+          traj.id,
+          traj.outcomeScore || 0.7,
+        );
+
+        if (this.outputDir) {
+          await this._persistSkill(skillName, content);
+        }
+
+        // Mark trajectory as synthesized
+        this.trajectoryStore.markSynthesized(traj.id, skillName);
+        created.push(skillName);
+      } catch (err) {
+        skipped.push(`${traj.id}: error - ${err.message}`);
+      }
+    }
+
+    return { created, skipped };
+  }
+
+  /**
+   * Extract pattern from a single trajectory via LLM.
+   * @param {object} trajectory
+   * @returns {Promise<object|null>}
+   */
+  async _extractPattern(trajectory) {
+    if (!this.llmChat) return null;
+
+    const messages = buildExtractionPrompt(trajectory);
+    const response = await this.llmChat(messages);
+
+    try {
+      // Try to parse JSON from response
+      const jsonMatch = response.match(/\{[\s\S]*\}/);
+      if (!jsonMatch) return null;
+      return JSON.parse(jsonMatch[0]);
+    } catch {
+      return null;
+    }
+  }
+
+  /**
+   * Check if a fingerprint matches any already-synthesized trajectory.
+   * @param {string} fingerprint
+   * @returns {boolean}
+   */
+  _isDuplicate(fingerprint) {
+    // Check against already-synthesized trajectories
+    const synthesized = this.db
+      .prepare(
+        "SELECT tool_chain FROM learning_trajectories WHERE synthesized_skill IS NOT NULL",
+      )
+      .all();
+
+    for (const row of synthesized) {
+      let chain;
+      try {
+        chain = JSON.parse(row.tool_chain);
+      } catch {
+        continue;
+      }
+      const existingFp = toolChainFingerprint(chain);
+      if (fingerprintsOverlap(fingerprint, existingFp)) {
+        return true;
+      }
+    }
+
+    return false;
+  }
+
+  /**
+   * Write SKILL.md to the output directory.
+   * @param {string} skillName
+   * @param {string} content
+   * @returns {Promise<{skillDir:string, skillFile:string}>}
+   */
+  async _persistSkill(skillName, content) {
+    const skillDir = _deps.path.join(this.outputDir, skillName);
+    const skillFile = _deps.path.join(skillDir, "SKILL.md");
+
+    await _deps.fs.promises.mkdir(skillDir, { recursive: true });
+    await _deps.fs.promises.writeFile(skillFile, content, "utf-8");
+
+    return { skillDir, skillFile };
+  }
+}
+
+export { _deps };

package/src/lib/learning/trajectory-store.js

@@ -0,0 +1,409 @@
+/**
+ * TrajectoryStore — Records complete execution trajectories for the
+ * autonomous learning loop.
+ *
+ * A trajectory captures the full chain:
+ *   user intent → tool calls (with args/results) → final response
+ *
+ * Consumed by:
+ *   - OutcomeFeedback (P1) — backfills outcome_score
+ *   - SkillSynthesizer (P2) — finds complex high-quality patterns
+ *   - SkillImprover (P2) — finds similar trajectories for comparison
+ *   - ReflectionEngine (P3) — periodic review
+ */
+
+import { ensureLearningTables } from "./learning-tables.js";
+
+// ── Helpers ──────────────────────────────────────────────
+
+function generateId() {
+  const hex = () =>
+    Math.floor(Math.random() * 0x10000)
+      .toString(16)
+      .padStart(4, "0");
+  return `${hex()}${hex()}-${hex()}-${hex()}-${hex()}-${hex()}${hex()}${hex()}`;
+}
+
+/**
+ * Classify complexity based on tool call count.
+ * @param {number} toolCount
+ * @returns {"simple"|"moderate"|"complex"}
+ */
+export function classifyComplexity(toolCount) {
+  if (toolCount <= 2) return "simple";
+  if (toolCount <= 5) return "moderate";
+  return "complex";
+}
+
+// ── _deps (for test injection, per CLI convention) ──────
+
+const _deps = { generateId };
+
+// ── TrajectoryStore ─────────────────────────────────────
+
+export class TrajectoryStore {
+  /**
+   * @param {import("better-sqlite3").Database} db
+   */
+  constructor(db) {
+    this.db = db;
+    ensureLearningTables(db);
+  }
+
+  // ── Write path ──────────────────────────────────────
+
+  /**
+   * Start recording a new trajectory (called on UserPromptSubmit).
+   * @param {string} sessionId
+   * @param {string} userIntent — the user's raw input
+   * @returns {string} trajectoryId
+   */
+  startTrajectory(sessionId, userIntent) {
+    const id = _deps.generateId();
+    this.db
+      .prepare(
+        `INSERT INTO learning_trajectories (id, session_id, user_intent, tool_chain, tool_count, complexity_level)
+         VALUES (?, ?, ?, '[]', 0, 'simple')`,
+      )
+      .run(id, sessionId, userIntent || "");
+    return id;
+  }
+
+  /**
+   * Append a tool call record to the trajectory (called on PostToolUse).
+   * @param {string} trajectoryId
+   * @param {{tool:string, args:any, result:any, durationMs:number, status:string}} record
+   */
+  appendToolCall(trajectoryId, record) {
+    if (!trajectoryId) return;
+
+    const row = this.db
+      .prepare(
+        "SELECT tool_chain, tool_count FROM learning_trajectories WHERE id = ?",
+      )
+      .get(trajectoryId);
+    if (!row) return;
+
+    let chain;
+    try {
+      chain = JSON.parse(row.tool_chain);
+    } catch {
+      chain = [];
+    }
+
+    // Truncate large results to keep DB lean (max 500 chars)
+    const truncatedResult =
+      typeof record.result === "string" && record.result.length > 500
+        ? record.result.slice(0, 500) + "...[truncated]"
+        : typeof record.result === "object"
+          ? JSON.stringify(record.result).slice(0, 500)
+          : String(record.result ?? "");
+
+    chain.push({
+      tool: record.tool,
+      args: record.args,
+      result: truncatedResult,
+      durationMs: record.durationMs || 0,
+      status: record.status || "completed",
+    });
+
+    const newCount = chain.length;
+    this.db
+      .prepare(
+        `UPDATE learning_trajectories
+         SET tool_chain = ?, tool_count = ?, complexity_level = ?
+         WHERE id = ?`,
+      )
+      .run(
+        JSON.stringify(chain),
+        newCount,
+        classifyComplexity(newCount),
+        trajectoryId,
+      );
+  }
+
+  /**
+   * Mark trajectory as complete (called on response-complete event).
+   * @param {string} trajectoryId
+   * @param {{finalResponse?:string, tags?:string[]}} data
+   * @returns {object|null} the completed trajectory row
+   */
+  completeTrajectory(trajectoryId, data = {}) {
+    if (!trajectoryId) return null;
+
+    this.db
+      .prepare(
+        `UPDATE learning_trajectories
+         SET final_response = ?, completed_at = datetime('now')
+         WHERE id = ?`,
+      )
+      .run(data.finalResponse || "", trajectoryId);
+
+    // Insert tags
+    if (Array.isArray(data.tags) && data.tags.length > 0) {
+      const insert = this.db.prepare(
+        "INSERT OR IGNORE INTO learning_trajectory_tags (trajectory_id, tag) VALUES (?, ?)",
+      );
+      for (const tag of data.tags) {
+        insert.run(trajectoryId, tag);
+      }
+    }
+
+    return this.getTrajectory(trajectoryId);
+  }
+
+  /**
+   * Backfill outcome score (called by OutcomeFeedback).
+   * @param {string} trajectoryId
+   * @param {number} score 0-1
+   * @param {"auto"|"user"|"reflection"} source
+   */
+  setOutcomeScore(trajectoryId, score, source) {
+    if (!trajectoryId) return;
+    const clamped = Math.max(0, Math.min(1, score));
+    this.db
+      .prepare(
+        `UPDATE learning_trajectories
+         SET outcome_score = ?, outcome_source = ?
+         WHERE id = ?`,
+      )
+      .run(clamped, source || "auto", trajectoryId);
+  }
+
+  /**
+   * Mark that a skill was synthesized from this trajectory.
+   * @param {string} trajectoryId
+   * @param {string} skillName
+   */
+  markSynthesized(trajectoryId, skillName) {
+    if (!trajectoryId) return;
+    this.db
+      .prepare(
+        "UPDATE learning_trajectories SET synthesized_skill = ? WHERE id = ?",
+      )
+      .run(skillName, trajectoryId);
+  }
+
+  // ── Read path ───────────────────────────────────────
+
+  /**
+   * Get a single trajectory by ID.
+   * @param {string} id
+   * @returns {object|null}
+   */
+  getTrajectory(id) {
+    const row = this.db
+      .prepare("SELECT * FROM learning_trajectories WHERE id = ?")
+      .get(id);
+    return row ? this._hydrate(row) : null;
+  }
+
+  /**
+   * List trajectories for a session.
+   * @param {string} sessionId
+   * @param {{limit?:number}} options
+   * @returns {object[]}
+   */
+  listBySession(sessionId, options = {}) {
+    const limit = options.limit || 50;
+    const rows = this.db
+      .prepare(
+        `SELECT * FROM learning_trajectories
+         WHERE session_id = ?
+         ORDER BY created_at DESC
+         LIMIT ?`,
+      )
+      .all(sessionId, limit);
+    return rows.map((r) => this._hydrate(r));
+  }
+
+  /**
+   * Find complex, high-score, un-synthesized trajectories.
+   * Used by SkillSynthesizer to find candidates.
+   * @param {{minToolCount?:number, minScore?:number, limit?:number}} options
+   * @returns {object[]}
+   */
+  findComplexUnprocessed(options = {}) {
+    const minToolCount = options.minToolCount ?? 5;
+    const minScore = options.minScore ?? 0.7;
+    const limit = options.limit ?? 10;
+
+    const rows = this.db
+      .prepare(
+        `SELECT * FROM learning_trajectories
+         WHERE tool_count >= ?
+           AND outcome_score >= ?
+           AND synthesized_skill IS NULL
+           AND completed_at IS NOT NULL
+         ORDER BY outcome_score DESC, tool_count DESC
+         LIMIT ?`,
+      )
+      .all(minToolCount, minScore, limit);
+    return rows.map((r) => this._hydrate(r));
+  }
+
+  /**
+   * Find trajectories with similar tool usage patterns.
+   * Similarity = Jaccard index of tool name sets.
+   * @param {string[]} toolNames — tool names to match against
+   * @param {{minSimilarity?:number, limit?:number, excludeId?:string}} options
+   * @returns {object[]}
+   */
+  findSimilar(toolNames, options = {}) {
+    const minSimilarity = options.minSimilarity ?? 0.5;
+    const limit = options.limit ?? 20;
+    const excludeId = options.excludeId || null;
+
+    // Fetch all completed trajectories (bounded)
+    const rows = this.db
+      .prepare(
+        `SELECT * FROM learning_trajectories
+         WHERE completed_at IS NOT NULL
+         ORDER BY created_at DESC
+         LIMIT 200`,
+      )
+      .all();
+
+    const inputSet = new Set(toolNames);
+    const results = [];
+
+    for (const row of rows) {
+      if (excludeId && row.id === excludeId) continue;
+
+      let chain;
+      try {
+        chain = JSON.parse(row.tool_chain);
+      } catch {
+        continue;
+      }
+
+      const rowTools = new Set(chain.map((t) => t.tool));
+      const intersection = [...inputSet].filter((t) => rowTools.has(t)).length;
+      const union = new Set([...inputSet, ...rowTools]).size;
+      const similarity = union > 0 ? intersection / union : 0;
+
+      if (similarity >= minSimilarity) {
+        results.push({ ...this._hydrate(row), similarity });
+      }
+    }
+
+    results.sort((a, b) => b.similarity - a.similarity);
+    return results.slice(0, limit);
+  }
+
+  /**
+   * Get recent trajectories (for CLI display).
+   * @param {{limit?:number, sessionId?:string}} options
+   * @returns {object[]}
+   */
+  getRecent(options = {}) {
+    const limit = options.limit || 20;
+    if (options.sessionId) {
+      return this.listBySession(options.sessionId, { limit });
+    }
+    const rows = this.db
+      .prepare(
+        `SELECT * FROM learning_trajectories
+         ORDER BY created_at DESC
+         LIMIT ?`,
+      )
+      .all(limit);
+    return rows.map((r) => this._hydrate(r));
+  }
+
+  /**
+   * Get basic stats.
+   * @returns {{total:number, complex:number, scored:number, synthesized:number}}
+   */
+  getStats() {
+    const total = this.db
+      .prepare("SELECT COUNT(*) as c FROM learning_trajectories")
+      .get().c;
+    const complex = this.db
+      .prepare(
+        "SELECT COUNT(*) as c FROM learning_trajectories WHERE complexity_level = 'complex'",
+      )
+      .get().c;
+    const scored = this.db
+      .prepare(
+        "SELECT COUNT(*) as c FROM learning_trajectories WHERE outcome_score IS NOT NULL",
+      )
+      .get().c;
+    const synthesized = this.db
+      .prepare(
+        "SELECT COUNT(*) as c FROM learning_trajectories WHERE synthesized_skill IS NOT NULL",
+      )
+      .get().c;
+    return { total, complex, scored, synthesized };
+  }
+
+  // ── Maintenance ─────────────────────────────────────
+
+  /**
+   * Delete trajectories older than retentionDays.
+   * @param {number} [retentionDays=90]
+   * @returns {number} deleted count
+   */
+  cleanup(retentionDays = 90) {
+    // Delete tags first (FK-like cleanup)
+    this.db
+      .prepare(
+        `DELETE FROM learning_trajectory_tags
+         WHERE trajectory_id IN (
+           SELECT id FROM learning_trajectories
+           WHERE created_at < datetime('now', ?)
+         )`,
+      )
+      .run(`-${retentionDays} days`);
+
+    const result = this.db
+      .prepare(
+        `DELETE FROM learning_trajectories
+         WHERE created_at < datetime('now', ?)`,
+      )
+      .run(`-${retentionDays} days`);
+
+    return result.changes;
+  }
+
+  // ── Internal ────────────────────────────────────────
+
+  /**
+   * Hydrate a DB row: parse JSON fields, attach tags.
+   * @param {object} row
+   * @returns {object}
+   */
+  _hydrate(row) {
+    let toolChain;
+    try {
+      toolChain = JSON.parse(row.tool_chain);
+    } catch {
+      toolChain = [];
+    }
+
+    const tags = this.db
+      .prepare(
+        "SELECT tag FROM learning_trajectory_tags WHERE trajectory_id = ?",
+      )
+      .all(row.id)
+      .map((r) => r.tag);
+
+    return {
+      id: row.id,
+      sessionId: row.session_id,
+      userIntent: row.user_intent,
+      toolChain,
+      toolCount: row.tool_count,
+      finalResponse: row.final_response,
+      outcomeScore: row.outcome_score,
+      outcomeSource: row.outcome_source,
+      complexityLevel: row.complexity_level,
+      synthesizedSkill: row.synthesized_skill,
+      createdAt: row.created_at,
+      completedAt: row.completed_at,
+      tags,
+    };
+  }
+}
+
+export { _deps };