qlogicagent 0.2.1 → 0.4.0

package/dist/orchestration/skill-improvement.d.ts

@@ -1,59 +0,0 @@
-/**
- * Skill self-learning: decides whether a completed turn should
- * trigger skill creation or improvement instructions.
- */
-export interface SkillTurnResult {
-    ok: boolean;
-    /** Number of tool invocations in this turn */
-    toolCallCount: number;
-    /** Number of distinct tool names used */
-    distinctToolCount: number;
-    /** Was a multi-step orchestration (≥2 rounds) used? */
-    multiStep: boolean;
-    /** Did the turn involve a sidechain? */
-    hasSidechain: boolean;
-    /** Optional user feedback signal (positive/negative/none) */
-    feedback?: "positive" | "negative" | null;
-    /** Skill name if an existing skill was used */
-    existingSkillName?: string | null;
-}
-export interface SkillCreateInstruction {
-    type: "skill.create";
-    /** Suggested skill name derived from tool usage pattern */
-    suggestedName: string;
-    /** Short description of what the skill does */
-    description: string;
-    /** Tool names involved */
-    tools: string[];
-    /** Number of orchestration steps */
-    stepCount: number;
-}
-export interface SkillImproveInstruction {
-    type: "skill.improve";
-    /** Existing skill to improve */
-    skillName: string;
-    /** Reason for improvement */
-    reason: string;
-}
-export type SkillInstruction = SkillCreateInstruction | SkillImproveInstruction;
-/**
- * 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 declare function shouldCreateSkill(result: SkillTurnResult): boolean;
-export declare function shouldImproveSkill(result: SkillTurnResult): boolean;
-/**
- * Build a skill instruction from a turn result, or null if none is warranted.
- */
-export declare function buildSkillInstruction(result: SkillTurnResult, context: {
-    tools: string[];
-    suggestedName?: string;
-}): SkillInstruction | null;

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.d.ts

@@ -1,98 +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.
- */
-/** Minimal skill profile for similarity comparison. */
-export interface SkillSimilarityProfile {
-    skillKey: string;
-    title: string;
-    tools: readonly string[];
-    stepCount?: number;
-}
-/** Result of a pairwise similarity comparison. */
-export interface SimilarityScore {
-    /** Overall similarity [0, 1]. */
-    overall: number;
-    /** Tool-set Jaccard index [0, 1]. */
-    toolJaccard: number;
-    /** Title bigram similarity [0, 1]. */
-    titleSimilarity: number;
-    /** Step-count proximity [0, 1]. */
-    stepProximity: number;
-}
-/** A candidate detected as similar during pre-creation check. */
-export interface SimilarSkillMatch {
-    existingSkillKey: string;
-    score: SimilarityScore;
-}
-/** Policy for similarity thresholds. */
-export interface SkillSimilarityPolicy {
-    /**
-     * Overall similarity threshold to block creation and emit "improve"
-     * instead. Default: 0.75.
-     */
-    blockCreationThreshold: number;
-    /**
-     * Overall similarity threshold to flag for curator review.
-     * Default: 0.55.
-     */
-    curatorReviewThreshold: number;
-    /** Weight of toolJaccard in overall score. Default: 0.60. */
-    toolWeight: number;
-    /** Weight of titleSimilarity in overall score. Default: 0.30. */
-    titleWeight: number;
-    /** Weight of stepProximity in overall score. Default: 0.10. */
-    stepWeight: number;
-}
-export declare const DEFAULT_SKILL_SIMILARITY_POLICY: SkillSimilarityPolicy;
-/**
- * Compute Jaccard index between two tool sets.
- * Returns 0 if both sets are empty.
- */
-export declare function toolSetJaccard(toolsA: readonly string[], toolsB: readonly string[]): number;
-/**
- * Compute character-bigram similarity between two strings.
- * Uses Dice coefficient of bigram sets.
- */
-export declare function bigramSimilarity(a: string, b: string): number;
-/**
- * Compute step-count proximity [0, 1].
- * Returns 1 when counts are identical, decreases with difference.
- */
-export declare function stepCountProximity(stepsA: number | undefined, stepsB: number | undefined): number;
-/**
- * Compute overall similarity between two skill profiles.
- */
-export declare function computeSimilarity(a: SkillSimilarityProfile, b: SkillSimilarityProfile, policy?: Partial<SkillSimilarityPolicy>): SimilarityScore;
-/**
- * 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 declare function findSimilarSkills(newSkill: SkillSimilarityProfile, existingSkills: readonly SkillSimilarityProfile[], policy?: Partial<SkillSimilarityPolicy>): SimilarSkillMatch[];
-/**
- * Determine creation decision based on similarity matches.
- */
-export type SimilarityDecision = {
-    action: "create";
-    reason: string;
-} | {
-    action: "improve";
-    targetSkillKey: string;
-    reason: string;
-} | {
-    action: "flag-for-review";
-    targetSkillKey: string;
-    reason: string;
-};
-export declare function decideSimilarityAction(matches: readonly SimilarSkillMatch[], policy?: Partial<SkillSimilarityPolicy>): SimilarityDecision;

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.d.ts

@@ -1,73 +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 interface StreamingToolCall {
-    id: string;
-    function: {
-        name: string;
-        arguments: string;
-    };
-}
-export interface StreamingToolResult<T = unknown> {
-    toolCallId: string;
-    toolName: string;
-    result: T;
-    ok: boolean;
-    startedAt: number;
-    completedAt: number;
-    error?: string;
-}
-export interface StreamingToolExecutorConfig {
-    /** Maximum concurrent tool executions (default: 8) */
-    maxConcurrency: number;
-    /** Abort signal for cancellation */
-    abortSignal?: AbortSignal;
-}
-export type ToolExecutorFn<T = unknown> = (toolCall: StreamingToolCall, abortSignal?: AbortSignal) => Promise<T>;
-/**
- * Streaming tool executor that dispatches tool calls immediately as they complete
- * during LLM streaming output, rather than waiting for the full response.
- *
- * Usage:
- * ```ts
- * const executor = createStreamingToolExecutor(executeFn, { maxConcurrency: 4 });
- * // During streaming, as each tool block completes:
- * executor.addTool(toolCall);
- * // Periodically collect completed results:
- * const results = executor.getCompletedResults();
- * // After streaming ends, wait for all remaining:
- * const allResults = await executor.flush();
- * ```
- */
-export interface StreamingToolExecutor<T = unknown> {
-    /** Add a tool call for immediate execution. Returns false if at capacity. */
-    addTool(toolCall: StreamingToolCall): boolean;
-    /** Get results that have completed since last call (non-blocking). */
-    getCompletedResults(): StreamingToolResult<T>[];
-    /** Wait for all pending tool calls to complete and return all results. */
-    flush(): Promise<StreamingToolResult<T>[]>;
-    /** Number of currently executing tool calls. */
-    readonly pendingCount: number;
-    /** Total number of tool calls dispatched. */
-    readonly dispatchedCount: number;
-    /** Whether the executor has been aborted. */
-    readonly aborted: boolean;
-}
-export declare function createStreamingToolExecutor<T = unknown>(executeFn: ToolExecutorFn<T>, config?: Partial<StreamingToolExecutorConfig>): StreamingToolExecutor<T>;
-/**
- * Determine if a tool call can be dispatched immediately during streaming
- * based on its manifest properties.
- */
-export declare function canDispatchDuringStreaming(toolCall: StreamingToolCall, manifest?: {
-    approvalMode?: "user-confirm" | "pre-authorized";
-    requiresApproval?: boolean;
-    serialOnly?: boolean;
-    parallelSafe?: boolean;
-}): boolean;

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;
-}