qlogicagent 0.2.1 → 0.3.0

package/dist/orchestration/skill-consolidation.js

@@ -1,220 +0,0 @@
-/**
- * Skill consolidation strategy — pure decision logic for
- * the Autonomous Curator's LLM-driven skill merging phase.
- *
- * This module:
- * 1. Detects prefix clusters among skill names.
- * 2. Builds the consolidation prompt for the LLM review agent.
- * 3. Parses structured LLM output into actionable merge/prune plans.
- * 4. Reconciles LLM intent against ground truth (existing skills).
- *
- * No I/O — the caller invokes the LLM and applies the results.
- */
-/**
- * Detect prefix clusters among skill names.
- *
- * A cluster is ≥2 skills sharing a common hyphenated prefix of ≥2 chars.
- * E.g. `["pr-review", "pr-merge", "pr-label"]` → cluster `"pr"`.
- */
-export function detectPrefixClusters(skillNames, minClusterSize = 2) {
-    const prefixMap = new Map();
-    for (const name of skillNames) {
-        const dashIdx = name.indexOf("-");
-        if (dashIdx < 2)
-            continue;
-        const prefix = name.slice(0, dashIdx);
-        const existing = prefixMap.get(prefix);
-        if (existing) {
-            existing.push(name);
-        }
-        else {
-            prefixMap.set(prefix, [name]);
-        }
-    }
-    const clusters = [];
-    for (const [prefix, skills] of prefixMap) {
-        if (skills.length >= minClusterSize) {
-            clusters.push({ prefix, skills: skills.sort() });
-        }
-    }
-    return clusters.sort((a, b) => b.skills.length - a.skills.length);
-}
-// ── LLM prompt construction ────────────────────────────────────────
-/**
- * Build the consolidation review prompt for the LLM curator agent.
- *
- * The prompt instructs the model to:
- * 1. Identify prefix clusters and overlapping skills.
- * 2. Propose umbrella consolidations.
- * 3. Mark redundant/trivial skills for pruning (archive, not delete).
- * 4. Output a structured YAML block.
- */
-export function buildConsolidationPrompt(candidates, existingUmbrellas, clusters) {
-    const candidateList = candidates.map((c) => `- **${c.name}** (${c.state}, uses: ${c.useCount}, tools: ${c.tools})${c.lastActivityAt ? ` last active: ${c.lastActivityAt}` : ""}`).join("\n");
-    const umbrellaList = existingUmbrellas.length > 0
-        ? existingUmbrellas.map((u) => `- ${u}`).join("\n")
-        : "(none)";
-    const clusterList = clusters.length > 0
-        ? clusters.map((c) => `- **${c.prefix}-***: ${c.skills.join(", ")}`).join("\n")
-        : "(no clusters detected)";
-    return `You are the Autonomous Curator for a skill library.
-
-## Goal
-
-Transform narrow, session-specific skills into a well-organized library of
-class-level umbrella skills. A collection of hundreds of narrow skills is FAILURE.
-
-## Ground Rules
-
-1. **NEVER delete** — only archive (prune). Archived skills can be restored.
-2. **Do NOT touch pinned or bundled skills** — they are already filtered out.
-3. **Identify prefix clusters** and merge them into umbrella skills.
-4. **Move session-specific details** into the umbrella's references/ folder.
-5. **Preserve unique value** — only merge if the source is genuinely redundant
-   or a subset of the target.
-
-## Detected Prefix Clusters
-
-${clusterList}
-
-## Existing Umbrella Skills
-
-${umbrellaList}
-
-## Candidate Skills for Review
-
-${candidateList}
-
-## Required Output Format
-
-Respond with EXACTLY this YAML block (no extra text outside the block):
-
-\`\`\`yaml
-consolidations:
-  - source: "skill-name-a"
-    target: "umbrella-skill"
-    reason: "subset of umbrella functionality"
-  - source: "skill-name-b"
-    target: "new-umbrella-name"
-    reason: "cluster merge"
-
-prunings:
-  - skill: "skill-name-c"
-    reason: "trivial single-use, no ongoing value"
-\`\`\`
-
-If no consolidations or prunings are warranted, use empty lists.
-Respond ONLY with the YAML block.`;
-}
-// ── LLM output parsing ─────────────────────────────────────────────
-/**
- * Parse the LLM's structured YAML response into a ConsolidationPlan.
- *
- * Tolerant: handles minor formatting variations, ignores unknown fields.
- */
-export function parseConsolidationOutput(llmOutput, knownSkills) {
-    const consolidations = [];
-    const prunings = [];
-    const hallucinations = [];
-    // Extract YAML block if wrapped in ```yaml ... ```
-    const yamlMatch = llmOutput.match(/```(?:yaml)?\s*\n([\s\S]*?)```/);
-    const yaml = yamlMatch ? yamlMatch[1] : llmOutput;
-    // Parse consolidations
-    const consolidationBlock = yaml.match(/consolidations:\s*\n((?:\s+-[\s\S]*?)?)(?=prunings:|$)/);
-    if (consolidationBlock?.[1]) {
-        const entries = consolidationBlock[1].matchAll(/- source:\s*"([^"]+)"\s*\n\s*target:\s*"([^"]+)"\s*\n\s*reason:\s*"([^"]+)"/g);
-        for (const [, source, target, reason] of entries) {
-            if (!knownSkills.has(source)) {
-                hallucinations.push(source);
-                continue;
-            }
-            consolidations.push({
-                sourceSkill: source,
-                targetUmbrella: target,
-                targetExists: knownSkills.has(target),
-                reason,
-            });
-        }
-    }
-    // Parse prunings
-    const pruningBlock = yaml.match(/prunings:\s*\n([\s\S]*?)$/);
-    if (pruningBlock?.[1]) {
-        const entries = pruningBlock[1].matchAll(/- skill:\s*"([^"]+)"\s*\n\s*reason:\s*"([^"]+)"/g);
-        for (const [, skill, reason] of entries) {
-            if (!knownSkills.has(skill)) {
-                hallucinations.push(skill);
-                continue;
-            }
-            prunings.push({ skillName: skill, reason });
-        }
-    }
-    return { consolidations, prunings, hallucinations };
-}
-// ── Reconciliation ─────────────────────────────────────────────────
-/**
- * Reconcile the LLM's consolidation plan against ground truth.
- *
- * Validates that:
- * - Source skills exist and aren't already consolidated in this plan.
- * - Target umbrellas either exist or are new (will be created).
- * - Pruning targets aren't also being consolidated.
- */
-export function reconcileConsolidationPlan(plan, knownSkills) {
-    const validConsolidations = [];
-    const validPrunings = [];
-    const rejected = [];
-    const consolidatedSources = new Set();
-    for (const c of plan.consolidations) {
-        if (!knownSkills.has(c.sourceSkill)) {
-            rejected.push({
-                action: `consolidate ${c.sourceSkill} → ${c.targetUmbrella}`,
-                reason: `source skill "${c.sourceSkill}" not found`,
-            });
-            continue;
-        }
-        if (consolidatedSources.has(c.sourceSkill)) {
-            rejected.push({
-                action: `consolidate ${c.sourceSkill} → ${c.targetUmbrella}`,
-                reason: `source skill "${c.sourceSkill}" already consolidated in this plan`,
-            });
-            continue;
-        }
-        if (c.sourceSkill === c.targetUmbrella) {
-            rejected.push({
-                action: `consolidate ${c.sourceSkill} → ${c.targetUmbrella}`,
-                reason: "source and target are the same skill",
-            });
-            continue;
-        }
-        consolidatedSources.add(c.sourceSkill);
-        validConsolidations.push(c);
-    }
-    for (const p of plan.prunings) {
-        if (!knownSkills.has(p.skillName)) {
-            rejected.push({
-                action: `prune ${p.skillName}`,
-                reason: `skill "${p.skillName}" not found`,
-            });
-            continue;
-        }
-        if (consolidatedSources.has(p.skillName)) {
-            rejected.push({
-                action: `prune ${p.skillName}`,
-                reason: `skill "${p.skillName}" is being consolidated, not pruned`,
-            });
-            continue;
-        }
-        validPrunings.push(p);
-    }
-    return { validConsolidations, validPrunings, rejected };
-}
-/**
- * Build a human-readable summary from a curator run report.
- */
-export function buildCuratorRunSummary(report) {
-    const parts = [];
-    parts.push(`Curator run at ${report.runAt} (${report.durationSeconds.toFixed(1)}s)`);
-    parts.push(`Auto: ${report.autoTransitionsChecked} checked, ${report.autoMarkedStale} stale, ${report.autoArchived} archived, ${report.autoReactivated} reactivated`);
-    parts.push(`LLM: ${report.consolidationsAccepted} consolidated, ${report.pruningsAccepted} pruned, ${report.actionsRejected} rejected, ${report.hallucinations} hallucinated`);
-    return parts.join("; ");
-}

package/dist/orchestration/skill-improvement.js

@@ -1,66 +0,0 @@
-/**
- * Skill self-learning: decides whether a completed turn should
- * trigger skill creation or improvement instructions.
- */
-// ── Decision logic ─────────────────────────────────────────────────
-/**
- * Minimum tool call count to consider a turn "complex enough"
- * to warrant creating a reusable skill.
- */
-const MIN_TOOL_CALLS_FOR_SKILL = 3;
-/**
- * Minimum distinct tools to suggest a new skill.
- */
-const MIN_DISTINCT_TOOLS_FOR_SKILL = 2;
-/**
- * Determine whether a completed turn should produce a skill instruction.
- *
- * A new skill is suggested when:
- * - The turn succeeded
- * - It involved multi-step orchestration
- * - It used ≥3 tool calls across ≥2 distinct tools
- * - No existing skill was already applied
- *
- * An improvement is suggested when:
- * - The turn used an existing skill but got negative feedback
- */
-export function shouldCreateSkill(result) {
-    if (!result.ok)
-        return false;
-    if (result.existingSkillName)
-        return false;
-    if (!result.multiStep)
-        return false;
-    if (result.toolCallCount < MIN_TOOL_CALLS_FOR_SKILL)
-        return false;
-    if (result.distinctToolCount < MIN_DISTINCT_TOOLS_FOR_SKILL)
-        return false;
-    return true;
-}
-export function shouldImproveSkill(result) {
-    if (!result.existingSkillName)
-        return false;
-    return result.feedback === "negative";
-}
-/**
- * Build a skill instruction from a turn result, or null if none is warranted.
- */
-export function buildSkillInstruction(result, context) {
-    if (shouldImproveSkill(result)) {
-        return {
-            type: "skill.improve",
-            skillName: result.existingSkillName,
-            reason: "negative user feedback on existing skill execution",
-        };
-    }
-    if (shouldCreateSkill(result)) {
-        return {
-            type: "skill.create",
-            suggestedName: context.suggestedName ?? `auto-skill-${context.tools.slice(0, 3).join("-")}`,
-            description: `Multi-step orchestration using ${context.tools.join(", ")}`,
-            tools: context.tools,
-            stepCount: result.toolCallCount,
-        };
-    }
-    return null;
-}

package/dist/orchestration/skill-similarity.js

@@ -1,131 +0,0 @@
-/**
- * Skill similarity — pure strategy for detecting near-duplicate skills
- * before creation and during curator consolidation reviews.
- *
- * Computes multi-signal similarity between skills:
- * 1. Tool-set Jaccard overlap (primary signal for auto-generated skills)
- * 2. Title/description cosine bigram similarity (complementary signal)
- * 3. Step-count proximity (minor signal for workflow complexity)
- *
- * No I/O — all functions are pure.
- */
-export const DEFAULT_SKILL_SIMILARITY_POLICY = {
-    blockCreationThreshold: 0.75,
-    curatorReviewThreshold: 0.55,
-    toolWeight: 0.60,
-    titleWeight: 0.30,
-    stepWeight: 0.10,
-};
-// ── Core similarity functions ──────────────────────────────────────
-/**
- * Compute Jaccard index between two tool sets.
- * Returns 0 if both sets are empty.
- */
-export function toolSetJaccard(toolsA, toolsB) {
-    const setA = new Set(toolsA.map((t) => t.toLowerCase()));
-    const setB = new Set(toolsB.map((t) => t.toLowerCase()));
-    if (setA.size === 0 && setB.size === 0)
-        return 0;
-    let intersection = 0;
-    for (const t of setA) {
-        if (setB.has(t))
-            intersection++;
-    }
-    const union = setA.size + setB.size - intersection;
-    return union === 0 ? 0 : intersection / union;
-}
-/**
- * Compute character-bigram similarity between two strings.
- * Uses Dice coefficient of bigram sets.
- */
-export function bigramSimilarity(a, b) {
-    const bigramsA = extractBigrams(a.toLowerCase());
-    const bigramsB = extractBigrams(b.toLowerCase());
-    if (bigramsA.size === 0 && bigramsB.size === 0)
-        return 0;
-    if (bigramsA.size === 0 || bigramsB.size === 0)
-        return 0;
-    let intersection = 0;
-    for (const bg of bigramsA) {
-        if (bigramsB.has(bg))
-            intersection++;
-    }
-    // Dice coefficient = 2 * |intersection| / (|A| + |B|)
-    return (2 * intersection) / (bigramsA.size + bigramsB.size);
-}
-function extractBigrams(s) {
-    const bigrams = new Set();
-    const normalized = s.replace(/[^a-z0-9\u4e00-\u9fff]/g, " ").trim();
-    for (let i = 0; i < normalized.length - 1; i++) {
-        bigrams.add(normalized.slice(i, i + 2));
-    }
-    return bigrams;
-}
-/**
- * Compute step-count proximity [0, 1].
- * Returns 1 when counts are identical, decreases with difference.
- */
-export function stepCountProximity(stepsA, stepsB) {
-    if (stepsA == null || stepsB == null)
-        return 0.5; // neutral if unknown
-    if (stepsA === 0 && stepsB === 0)
-        return 1;
-    const diff = Math.abs(stepsA - stepsB);
-    const max = Math.max(stepsA, stepsB);
-    return 1 - diff / max;
-}
-// ── Composite similarity ───────────────────────────────────────────
-/**
- * Compute overall similarity between two skill profiles.
- */
-export function computeSimilarity(a, b, policy) {
-    const resolved = { ...DEFAULT_SKILL_SIMILARITY_POLICY, ...policy };
-    const toolJaccard = toolSetJaccard(a.tools, b.tools);
-    const titleSimilarity = bigramSimilarity(a.title, b.title);
-    const stepProximity = stepCountProximity(a.stepCount, b.stepCount);
-    const overall = resolved.toolWeight * toolJaccard +
-        resolved.titleWeight * titleSimilarity +
-        resolved.stepWeight * stepProximity;
-    return { overall, toolJaccard, titleSimilarity, stepProximity };
-}
-// ── Pre-creation duplicate check ───────────────────────────────────
-/**
- * Check a new skill candidate against existing skills for similarity.
- *
- * Returns all existing skills above curatorReviewThreshold, sorted
- * by descending similarity. The caller should:
- * - Block creation if any match ≥ blockCreationThreshold (emit improve instead)
- * - Tag for curator review if match ≥ curatorReviewThreshold
- */
-export function findSimilarSkills(newSkill, existingSkills, policy) {
-    const resolved = { ...DEFAULT_SKILL_SIMILARITY_POLICY, ...policy };
-    const matches = [];
-    for (const existing of existingSkills) {
-        if (existing.skillKey === newSkill.skillKey)
-            continue; // skip self
-        const score = computeSimilarity(newSkill, existing, resolved);
-        if (score.overall >= resolved.curatorReviewThreshold) {
-            matches.push({ existingSkillKey: existing.skillKey, score });
-        }
-    }
-    return matches.sort((a, b) => b.score.overall - a.score.overall);
-}
-export function decideSimilarityAction(matches, policy) {
-    const resolved = { ...DEFAULT_SKILL_SIMILARITY_POLICY, ...policy };
-    if (matches.length === 0) {
-        return { action: "create", reason: "no similar skills found" };
-    }
-    const top = matches[0];
-    if (top.score.overall >= resolved.blockCreationThreshold) {
-        return {
-            action: "improve",
-            targetSkillKey: top.existingSkillKey,
-            reason: `similarity ${(top.score.overall * 100).toFixed(0)}% ≥ creation threshold ${(resolved.blockCreationThreshold * 100).toFixed(0)}% (tool overlap: ${(top.score.toolJaccard * 100).toFixed(0)}%)`,
-        };
-    }
-    return {
-        action: "flag-for-review",
-        targetSkillKey: top.existingSkillKey,
-        reason: `similarity ${(top.score.overall * 100).toFixed(0)}% between review and creation thresholds`,
-    };
-}

package/dist/orchestration/streaming-tool-executor.js

@@ -1,96 +0,0 @@
-/**
- * StreamingToolExecutor — Executes tool calls as they arrive during LLM streaming.
- *
- * Aligned with Claude Code's StreamingToolExecutor pattern:
- * - As each complete tool_use block arrives during streaming, immediately dispatch execution
- * - Don't wait for the full LLM response to finish before starting tool execution
- * - Results queue up and can be collected at any time
- *
- * This reduces perceived latency by overlapping LLM generation time with tool execution time.
- */
-export function createStreamingToolExecutor(executeFn, config = {}) {
-    const maxConcurrency = Math.max(1, config.maxConcurrency ?? 8);
-    const abortSignal = config.abortSignal;
-    const pending = [];
-    const completedQueue = [];
-    let dispatchedCount = 0;
-    let aborted = false;
-    if (abortSignal) {
-        abortSignal.addEventListener("abort", () => { aborted = true; }, { once: true });
-    }
-    function addTool(toolCall) {
-        if (aborted)
-            return false;
-        if (pending.length >= maxConcurrency)
-            return false;
-        dispatchedCount += 1;
-        const startedAt = Date.now();
-        const entry = {
-            toolCallId: toolCall.id,
-            toolName: toolCall.function.name,
-            startedAt,
-            promise: executeFn(toolCall, abortSignal)
-                .then((result) => ({
-                toolCallId: toolCall.id,
-                toolName: toolCall.function.name,
-                result,
-                ok: true,
-                startedAt,
-                completedAt: Date.now(),
-            }))
-                .catch((err) => ({
-                toolCallId: toolCall.id,
-                toolName: toolCall.function.name,
-                result: undefined,
-                ok: false,
-                startedAt,
-                completedAt: Date.now(),
-                error: err instanceof Error ? err.message : String(err),
-            }))
-                .then((result) => {
-                // Move from pending to completed queue
-                const idx = pending.indexOf(entry);
-                if (idx >= 0)
-                    pending.splice(idx, 1);
-                completedQueue.push(result);
-                return result;
-            }),
-        };
-        pending.push(entry);
-        return true;
-    }
-    function getCompletedResults() {
-        const results = completedQueue.splice(0);
-        return results;
-    }
-    async function flush() {
-        if (pending.length > 0) {
-            await Promise.allSettled(pending.map((e) => e.promise));
-        }
-        return completedQueue.splice(0);
-    }
-    return {
-        addTool,
-        getCompletedResults,
-        flush,
-        get pendingCount() { return pending.length; },
-        get dispatchedCount() { return dispatchedCount; },
-        get aborted() { return aborted; },
-    };
-}
-/**
- * Determine if a tool call can be dispatched immediately during streaming
- * based on its manifest properties.
- */
-export function canDispatchDuringStreaming(toolCall, manifest) {
-    if (!manifest)
-        return false;
-    // Cannot dispatch during streaming if it requires user approval
-    if (manifest.approvalMode === "user-confirm" || manifest.requiresApproval)
-        return false;
-    // Cannot dispatch if explicitly serial-only
-    if (manifest.serialOnly)
-        return false;
-    // Safe to dispatch during streaming
-    return true;
-}