skill-tree 0.1.0 → 0.1.2

package/dist/{chunk-5QGJJCVX.mjs → chunk-INKVOZXK.mjs}

@@ -13751,6 +13751,509 @@ function conditionalHook(filter, handler) {
   };
 }
 
+// src/learning/providers/cognitive-core.ts
+var CognitiveCoreProvider = class {
+  constructor(options) {
+    this.name = "cognitive-core";
+    this.description = "Advanced learning using cognitive-core with batch extraction and feedback";
+    this.capabilities = {
+      accumulating: true,
+      feedbackEnabled: true,
+      persistent: true,
+      minTrajectories: 5,
+      supportedKinds: ["skill", "strategy", "pattern", "error-fix"]
+    };
+    this.initialized = false;
+    // ID mapping: playbook.id <-> candidate.id
+    // For cognitive-core, we use playbook.id as the candidate.id directly
+    this.playbookIdCache = /* @__PURE__ */ new Map();
+    this.factory = options.factory;
+    this.config = {
+      storagePath: options.storagePath ?? "./.cognitive-core",
+      minTrajectories: options.minTrajectories ?? 5,
+      deduplicationThreshold: options.deduplicationThreshold ?? 0.85,
+      creditStrategy: options.creditStrategy ?? "simple",
+      convertToReAct: options.convertToReAct ?? true
+    };
+    this.memory = this.factory.createMemorySystem(this.config.storagePath);
+    this.pipeline = this.factory.createLearningPipeline(this.memory, {
+      creditStrategy: this.config.creditStrategy,
+      minTrajectories: this.config.minTrajectories,
+      deduplicationThreshold: this.config.deduplicationThreshold
+    });
+  }
+  /**
+   * Initialize the provider (load persisted state)
+   */
+  async initialize() {
+    if (this.initialized) return;
+    await this.memory.init();
+    this.initialized = true;
+  }
+  /**
+   * Shutdown cleanly (persist state, release resources)
+   */
+  async shutdown() {
+    await this.memory.close();
+    this.initialized = false;
+  }
+  /**
+   * Analyze a trajectory and accumulate for batch learning.
+   * Returns empty candidates until flush() or batch threshold.
+   */
+  async analyze(trajectory, options) {
+    await this.initialize();
+    const startTime = Date.now();
+    const ccTrajectory = this.convertTrajectory(trajectory, options);
+    await this.pipeline.processTrajectory(ccTrajectory);
+    let candidates = [];
+    let updates = [];
+    let demotions = [];
+    let antiPatterns = [];
+    if (options?.forceImmediate || this.pipeline.shouldRunBatch()) {
+      const batchResult = await this.runBatchExtraction(options);
+      candidates = batchResult.candidates;
+      updates = batchResult.updates ?? [];
+      demotions = batchResult.demotions ?? [];
+      antiPatterns = batchResult.antiPatterns ?? [];
+    }
+    return {
+      candidates,
+      updates: updates.length > 0 ? updates : void 0,
+      demotions: demotions.length > 0 ? demotions : void 0,
+      antiPatterns: antiPatterns.length > 0 ? antiPatterns : void 0,
+      providerState: {
+        pendingCount: this.pipeline.getAccumulatedCount(),
+        readyForFlush: this.pipeline.shouldRunBatch()
+      },
+      metadata: {
+        trajectoriesAnalyzed: 1,
+        durationMs: Date.now() - startTime
+      }
+    };
+  }
+  /**
+   * Analyze multiple trajectories together.
+   * Enables better cross-trajectory pattern detection.
+   */
+  async analyzeBatch(trajectories, options) {
+    await this.initialize();
+    const startTime = Date.now();
+    for (const trajectory of trajectories) {
+      const ccTrajectory = this.convertTrajectory(trajectory, options);
+      await this.pipeline.processTrajectory(ccTrajectory);
+    }
+    const batchResult = await this.runBatchExtraction(options);
+    return {
+      candidates: batchResult.candidates,
+      updates: batchResult.updates,
+      demotions: batchResult.demotions,
+      antiPatterns: batchResult.antiPatterns,
+      providerState: {
+        pendingCount: this.pipeline.getAccumulatedCount(),
+        readyForFlush: this.pipeline.shouldRunBatch()
+      },
+      metadata: {
+        trajectoriesAnalyzed: trajectories.length,
+        durationMs: Date.now() - startTime
+      }
+    };
+  }
+  /**
+   * Force extraction from accumulated trajectories.
+   */
+  async flush(options) {
+    await this.initialize();
+    const startTime = Date.now();
+    const pendingCount = this.pipeline.getAccumulatedCount();
+    const batchResult = await this.runBatchExtraction(options);
+    return {
+      ...batchResult,
+      metadata: {
+        trajectoriesAnalyzed: pendingCount,
+        durationMs: Date.now() - startTime
+      }
+    };
+  }
+  /**
+   * Record outcome when a candidate/playbook is applied.
+   * Updates playbook confidence and may generate refinements.
+   */
+  async recordOutcome(feedback) {
+    await this.initialize();
+    const playbookId = feedback.candidateId;
+    const playbook = await this.memory.playbooks.get(playbookId);
+    if (!playbook) {
+      return { recorded: false };
+    }
+    await this.memory.recordPlaybookUsage(
+      playbookId,
+      feedback.trajectoryId,
+      feedback.success,
+      feedback.context,
+      feedback.failureMode
+    );
+    const updates = [];
+    const antiPatterns = [];
+    if (feedback.success) {
+      updates.push({
+        candidateId: playbookId,
+        incrementSuccess: true,
+        confidenceAdjustment: 0.05
+        // Slight boost on success
+      });
+    } else {
+      updates.push({
+        candidateId: playbookId,
+        incrementFailure: true,
+        confidenceAdjustment: -0.1
+        // Decrease confidence on failure
+      });
+      if (feedback.context || feedback.failureMode) {
+        antiPatterns.push({
+          id: `anti-${playbookId}-${Date.now()}`,
+          candidateId: playbookId,
+          pattern: feedback.context ?? "Unknown context",
+          reason: feedback.failureMode ?? "Unknown failure mode",
+          discoveredFrom: feedback.trajectoryId,
+          createdAt: /* @__PURE__ */ new Date()
+        });
+      }
+    }
+    return {
+      recorded: true,
+      updates: updates.length > 0 ? updates : void 0,
+      antiPatterns: antiPatterns.length > 0 ? antiPatterns : void 0
+    };
+  }
+  /**
+   * Check if a candidate is a duplicate based on playbook similarity
+   */
+  isDuplicate(candidate, existing) {
+    if (existing.some((e) => e.id === candidate.id)) {
+      return true;
+    }
+    for (const e of existing) {
+      const similarity = this.computeSimilarity(candidate, e);
+      if (similarity > this.config.deduplicationThreshold) {
+        return true;
+      }
+    }
+    return false;
+  }
+  /**
+   * Compute similarity between two candidates
+   */
+  computeSimilarity(a, b) {
+    if (a.kind !== b.kind) return 0.1;
+    const nameA = this.tokenize(a.name);
+    const nameB = this.tokenize(b.name);
+    const nameSimilarity = this.jaccardSimilarity(nameA, nameB);
+    let contentSimilarity = 0;
+    if (a.content.kind === "skill" && b.content.kind === "skill") {
+      const aWords = this.tokenize(a.content.problem + " " + a.content.solution);
+      const bWords = this.tokenize(b.content.problem + " " + b.content.solution);
+      contentSimilarity = this.jaccardSimilarity(aWords, bWords);
+    }
+    return nameSimilarity * 0.3 + contentSimilarity * 0.7;
+  }
+  // ==========================================================================
+  // Private Methods
+  // ==========================================================================
+  /**
+   * Run batch extraction and convert results to LearningCandidates
+   */
+  async runBatchExtraction(options) {
+    await this.pipeline.runBatchLearning();
+    const allPlaybooks = await this.memory.playbooks.getAll();
+    const candidates = [];
+    const updates = [];
+    const demotions = [];
+    const antiPatterns = [];
+    const minConfidence = options?.minConfidence ?? 0;
+    const requestedKinds = options?.kinds;
+    for (const playbook of allPlaybooks) {
+      if (!this.playbookIdCache.has(playbook.id)) {
+        const candidate = this.playbookToCandidate(playbook);
+        if (candidate.confidence < minConfidence) {
+          continue;
+        }
+        if (requestedKinds && !requestedKinds.includes(candidate.kind)) {
+          continue;
+        }
+        candidates.push(candidate);
+        this.playbookIdCache.set(playbook.id, true);
+      }
+      const successRate = playbook.evolution.successCount + playbook.evolution.failureCount > 0 ? playbook.evolution.successCount / (playbook.evolution.successCount + playbook.evolution.failureCount) : 1;
+      if (successRate < 0.3 && playbook.evolution.successCount + playbook.evolution.failureCount >= 3) {
+        demotions.push({
+          candidateId: playbook.id,
+          reason: `Low success rate: ${Math.round(successRate * 100)}%`,
+          newConfidence: successRate,
+          deprecate: successRate < 0.1
+        });
+      }
+      for (const antiPattern of playbook.applicability.antiPatterns) {
+        antiPatterns.push({
+          id: `anti-${playbook.id}-${antiPattern.slice(0, 10)}`,
+          candidateId: playbook.id,
+          pattern: antiPattern,
+          reason: "Learned from playbook applicability",
+          discoveredFrom: playbook.evolution.createdFrom[0] ?? "unknown",
+          createdAt: playbook.createdAt
+        });
+      }
+    }
+    return {
+      candidates,
+      updates: updates.length > 0 ? updates : void 0,
+      demotions: demotions.length > 0 ? demotions : void 0,
+      antiPatterns: antiPatterns.length > 0 ? antiPatterns : void 0,
+      providerState: {
+        pendingCount: this.pipeline.getAccumulatedCount(),
+        readyForFlush: this.pipeline.shouldRunBatch()
+      }
+    };
+  }
+  /**
+   * Convert a skill-tree Trajectory to cognitive-core Trajectory format
+   */
+  convertTrajectory(trajectory, options) {
+    const firstUserTurn = trajectory.turns.find((t) => t.role === "user");
+    let taskDescription = firstUserTurn?.content ?? "Unknown task";
+    if (options?.context) {
+      taskDescription = `${taskDescription}
+
+Context: ${options.context}`;
+    }
+    const task = this.factory.createTask({
+      id: trajectory.sessionId,
+      domain: trajectory.metadata.projectName ?? "general",
+      description: taskDescription,
+      context: trajectory.metadata.custom ?? {}
+    });
+    const [startTurn, endTurn] = options?.turnRange ?? [0, trajectory.turns.length - 1];
+    const turnsToProcess = trajectory.turns.slice(startTurn, endTurn + 1);
+    const steps = [];
+    if (this.config.convertToReAct) {
+      for (let i = 0; i < turnsToProcess.length; i++) {
+        const turn = turnsToProcess[i];
+        if (turn.role === "assistant") {
+          const step = this.turnToStep(turn, turnsToProcess, i);
+          if (step) {
+            steps.push(step);
+          }
+        }
+      }
+    }
+    const outcome = {
+      success: trajectory.outcome?.success ?? false,
+      partialScore: trajectory.outcome?.success ? 1 : 0,
+      solution: trajectory.outcome?.summary ?? "",
+      errorInfo: trajectory.outcome?.errors?.join("; ")
+    };
+    return this.factory.createTrajectory({
+      id: trajectory.sessionId,
+      task,
+      steps,
+      outcome,
+      agentId: trajectory.metadata.agentType ?? "skill-tree",
+      metadata: trajectory.metadata.custom ?? {}
+    });
+  }
+  /**
+   * Convert an assistant turn to a cognitive-core Step
+   */
+  turnToStep(turn, allTurns, turnIndex) {
+    let observation = "";
+    const nextTurn = allTurns[turnIndex + 1];
+    if (nextTurn?.role === "tool" && nextTurn.toolResults?.length) {
+      observation = nextTurn.toolResults.map((r) => r.output).join("\n");
+    } else if (nextTurn?.role === "user") {
+      observation = nextTurn.content.slice(0, 500);
+    }
+    let action = "";
+    if (turn.toolCalls?.length) {
+      action = turn.toolCalls.map((tc) => `${tc.name}(${JSON.stringify(tc.input).slice(0, 200)})`).join("; ");
+    } else {
+      action = turn.content.slice(0, 300);
+    }
+    const thought = turn.toolCalls?.length ? turn.content.slice(0, 500) : void 0;
+    return this.factory.createStep({
+      thought,
+      action,
+      observation
+    });
+  }
+  /**
+   * Convert a cognitive-core Playbook to a LearningCandidate
+   */
+  playbookToCandidate(playbook) {
+    const kind = this.inferKind(playbook);
+    const content = this.createContentForKind(kind, playbook);
+    const attribution = playbook.evolution.createdFrom.map(
+      (trajectoryId, i) => ({
+        turnIndex: i,
+        score: 1 / Math.max(1, playbook.evolution.createdFrom.length),
+        reasoning: `Derived from trajectory ${trajectoryId}`
+      })
+    );
+    return {
+      kind,
+      id: playbook.id,
+      name: playbook.name,
+      content,
+      confidence: playbook.confidence,
+      attribution,
+      source: {
+        provider: this.name,
+        trajectoryId: playbook.evolution.createdFrom[0] ?? "unknown",
+        turnRange: [0, 0],
+        // Playbooks don't track specific turn ranges
+        extractedAt: playbook.createdAt,
+        metadata: {
+          version: playbook.evolution.version,
+          successCount: playbook.evolution.successCount,
+          failureCount: playbook.evolution.failureCount,
+          complexity: playbook.complexity
+        }
+      },
+      embedding: playbook.embedding,
+      // Pass through embedding if present
+      tags: playbook.applicability.domains,
+      reasoning: playbook.guidance.strategy
+    };
+  }
+  /**
+   * Create appropriate content type for the inferred kind
+   */
+  createContentForKind(kind, playbook) {
+    switch (kind) {
+      case "strategy":
+        return {
+          kind: "strategy",
+          situation: playbook.applicability.situations.join(". "),
+          suggestion: playbook.guidance.strategy,
+          parameters: playbook.guidance.codeExample ? { example: playbook.guidance.codeExample } : void 0
+        };
+      case "pattern":
+        return {
+          kind: "pattern",
+          pattern: playbook.applicability.triggers[0] ?? playbook.name,
+          description: playbook.guidance.strategy,
+          examples: playbook.applicability.situations
+        };
+      case "error-fix":
+        return {
+          kind: "error-fix",
+          errorPattern: playbook.applicability.triggers.join(" | "),
+          fix: playbook.guidance.strategy + (playbook.guidance.steps?.length ? "\n\nSteps:\n" + playbook.guidance.steps.map((s, i) => `${i + 1}. ${s}`).join("\n") : ""),
+          frequency: playbook.evolution.successCount + playbook.evolution.failureCount,
+          errorExamples: playbook.applicability.triggers
+        };
+      case "skill":
+      default:
+        return {
+          kind: "skill",
+          problem: playbook.applicability.situations.join(". "),
+          solution: playbook.guidance.strategy + (playbook.guidance.steps?.length ? "\n\nSteps:\n" + playbook.guidance.steps.map((s, i) => `${i + 1}. ${s}`).join("\n") : ""),
+          verification: playbook.verification.successIndicators.join(". "),
+          triggers: this.extractTriggers(playbook),
+          examples: []
+          // Playbooks don't have direct examples
+        };
+    }
+  }
+  /**
+   * Infer the kind of learning from a playbook
+   */
+  inferKind(playbook) {
+    const hasErrorTriggers = playbook.applicability.triggers.some(
+      (t) => t.toLowerCase().includes("error") || /^[A-Z]{2,}\d+/.test(t)
+    );
+    if (hasErrorTriggers) {
+      return "error-fix";
+    }
+    const strategy = playbook.guidance.strategy.toLowerCase();
+    if (strategy.includes("approach") || strategy.includes("strategy") || strategy.includes("when you see")) {
+      return "strategy";
+    }
+    if (playbook.applicability.situations.some((s) => s.includes("pattern"))) {
+      return "pattern";
+    }
+    return "skill";
+  }
+  /**
+   * Extract triggers from playbook applicability
+   */
+  extractTriggers(playbook) {
+    const triggers = [];
+    for (const situation of playbook.applicability.situations) {
+      triggers.push({
+        type: "context",
+        value: situation,
+        description: "Situation trigger"
+      });
+    }
+    for (const trigger of playbook.applicability.triggers) {
+      let type = "keyword";
+      if (trigger.toLowerCase().includes("error") || /^[A-Z]{2,}\d+/.test(trigger)) {
+        type = "error";
+      } else if (trigger.startsWith("/") || trigger.includes("*")) {
+        type = "pattern";
+      }
+      triggers.push({
+        type,
+        value: trigger,
+        description: "Explicit trigger"
+      });
+    }
+    return triggers;
+  }
+  /**
+   * Tokenize text into words
+   */
+  tokenize(text) {
+    return text.toLowerCase().split(/\W+/).filter((w) => w.length > 2);
+  }
+  /**
+   * Compute Jaccard similarity between two arrays
+   */
+  jaccardSimilarity(a, b) {
+    const setA = new Set(a);
+    const setB = new Set(b);
+    const intersection = new Set([...setA].filter((x) => setB.has(x)));
+    const union = /* @__PURE__ */ new Set([...setA, ...setB]);
+    return union.size === 0 ? 0 : intersection.size / union.size;
+  }
+};
+function createCognitiveCoreProvider(options) {
+  return new CognitiveCoreProvider(options);
+}
+async function createDefaultCognitiveCoreFactory() {
+  const cc = await import("cognitive-core");
+  return {
+    createMemorySystem(storagePath) {
+      return cc.createMemorySystem(storagePath);
+    },
+    createLearningPipeline(memory, config) {
+      return cc.createLearningPipeline(
+        memory,
+        config
+      );
+    },
+    createTrajectory(params) {
+      return cc.createTrajectory(params);
+    },
+    createTask(params) {
+      return cc.createTask(params);
+    },
+    createStep(params) {
+      return cc.createStep(params);
+    }
+  };
+}
+
 // src/sync/git-sync-adapter.ts
 import * as fs8 from "fs";
 import * as path8 from "path";
@@ -15364,6 +15867,9 @@ export {
   createMetricsHook,
   combineHandlers,
   conditionalHook,
+  CognitiveCoreProvider,
+  createCognitiveCoreProvider,
+  createDefaultCognitiveCoreFactory,
   ConflictStore,
   createConflictStore,
   GitSyncAdapter,