qlogicagent 0.2.1 → 0.4.0

package/dist/skills/tools/agent-tool.js

@@ -1,142 +0,0 @@
-// ============================================================
-// Agent Tool — CC-aligned fork sub-agent with built-in registry.
-// Reference: claude-code-haha/src/tools/AgentTool/AgentTool.tsx
-//            claude-code-haha/src/tools/AgentTool/runAgent.ts
-//            claude-code-haha/src/tools/AgentTool/forkSubagent.ts
-//            claude-code-haha/src/tools/AgentTool/builtInAgents.ts
-// Category: system
-// ============================================================
-export const AGENT_TOOL_NAME = "agent";
-export const BUILT_IN_AGENT_TYPES = [
-    "general", "explore", "plan", "code", "research", "verify",
-];
-export const AGENT_TOOL_SCHEMA = {
-    type: "object",
-    properties: {
-        agent: {
-            type: "string",
-            enum: ["general", "explore", "plan", "code", "research", "verify"],
-            description: "Sub-agent type to fork:\n" +
-                "- general: Full tool access, any task\n" +
-                "- explore: Read-only codebase exploration (search, read, analyze)\n" +
-                "- plan: Planning mode (explore + produce plan, no writes)\n" +
-                "- code: Coding agent with full tool access\n" +
-                "- research: Web research and information gathering\n" +
-                "- verify: Run tests, check builds, validate changes",
-        },
-        prompt: {
-            type: "string",
-            description: "Detailed task for the sub-agent. The sub-agent shares your conversation " +
-                "history as context (prompt cache shared). Be specific about what " +
-                "information to return in the final response.",
-        },
-        description: {
-            type: "string",
-            description: "Short description (3-7 words) for status tracking.",
-        },
-        maxTurns: {
-            type: "number",
-            description: "Max turns for the sub-agent. Defaults: general=200, explore=50, plan=80, code=200, research=30, verify=40.",
-        },
-        background: {
-            type: "boolean",
-            description: "If true, runs in background and returns a task_id. Poll with task tool. Default: false.",
-        },
-    },
-    required: ["agent", "prompt"],
-    additionalProperties: false,
-};
-/** Maximum fork depth for in-memory agents. */
-export const MAX_FORK_DEPTH = 4;
-export function createAgentTool(deps) {
-    return {
-        name: AGENT_TOOL_NAME,
-        label: "Sub-Agent",
-        description: "Fork a sub-agent to handle complex tasks autonomously. " +
-            "Sub-agents share your conversation context (prompt cache) and " +
-            "have isolated tool state. Use for: parallel research, code exploration, " +
-            "testing, delegating large tasks to specialized agents.",
-        parameters: AGENT_TOOL_SCHEMA,
-        searchHint: "fork subagent delegate spawn child parallel worker",
-        isConcurrencySafe: true,
-        execute: async (_toolCallId, params) => {
-            // Validate prompt
-            if (!params.prompt || params.prompt.trim().length < 10) {
-                return {
-                    content: [{ type: "text", text: "Error: prompt must be at least 10 characters." }],
-                    details: { type: "agent", error: "prompt_too_short" },
-                };
-            }
-            // Validate agent type
-            if (!BUILT_IN_AGENT_TYPES.includes(params.agent)) {
-                return {
-                    content: [{
-                            type: "text",
-                            text: `Error: unknown agent "${params.agent}". Available: ${BUILT_IN_AGENT_TYPES.join(", ")}`,
-                        }],
-                    details: { type: "agent", error: "invalid_agent_type" },
-                };
-            }
-            // Fork depth guard
-            const depth = deps.currentForkDepth ?? 0;
-            if (depth >= MAX_FORK_DEPTH) {
-                return {
-                    content: [{
-                            type: "text",
-                            text: `Error: maximum fork depth (${MAX_FORK_DEPTH}) reached. Cannot spawn more sub-agents. Complete current work instead.`,
-                        }],
-                    details: { type: "agent", error: "max_depth_reached", depth },
-                };
-            }
-            try {
-                const result = await deps.forkAgent({
-                    agent: params.agent,
-                    prompt: params.prompt.trim(),
-                    description: params.description,
-                    maxTurns: params.maxTurns,
-                    background: params.background,
-                    abortSignal: deps.abortSignal,
-                });
-                // Background mode — return task reference
-                if (params.background && result.status === "running") {
-                    return {
-                        content: [{
-                                type: "text",
-                                text: `Sub-agent "${params.agent}" started in background.\nAgent ID: ${result.agentId}\nUse task tool with this ID to check status and get output.`,
-                            }],
-                        details: { type: "agent", agentId: result.agentId, status: "running", background: true },
-                    };
-                }
-                // Failed
-                if (result.status === "failed") {
-                    return {
-                        content: [{ type: "text", text: `Sub-agent failed: ${result.error || "unknown error"}` }],
-                        details: { type: "agent", agentId: result.agentId, status: "failed", error: result.error },
-                    };
-                }
-                // Completed — return output with metadata
-                const output = result.output || "(sub-agent returned no output)";
-                const suffix = result.maxTurnsReached
-                    ? "\n\n[Note: Sub-agent reached turn limit. Output may be incomplete.]"
-                    : "";
-                return {
-                    content: [{ type: "text", text: output + suffix }],
-                    details: {
-                        type: "agent",
-                        agentId: result.agentId,
-                        status: "completed",
-                        tokensUsed: result.tokensUsed,
-                        maxTurnsReached: result.maxTurnsReached,
-                    },
-                };
-            }
-            catch (err) {
-                const msg = err instanceof Error ? err.message : String(err);
-                return {
-                    content: [{ type: "text", text: `Sub-agent execution failed: ${msg}` }],
-                    details: { type: "agent", error: "execution_error", message: msg },
-                };
-            }
-        },
-    };
-}

package/dist/skills/tools/apply-patch-tool.d.ts

@@ -1,29 +0,0 @@
-import type { PortableTool } from "../portable-tool.js";
-export declare const APPLY_PATCH_TOOL_NAME: "apply_patch";
-export interface ApplyPatchToolParams {
-    input: string;
-}
-export declare const APPLY_PATCH_TOOL_SCHEMA: {
-    readonly type: "object";
-    readonly properties: {
-        readonly input: {
-            readonly type: "string";
-            readonly description: "Patch content using the *** Begin Patch / *** End Patch format.";
-        };
-    };
-    readonly required: readonly ["input"];
-};
-export interface ApplyPatchSummary {
-    added: string[];
-    modified: string[];
-    deleted: string[];
-}
-/** Deps injected by the host runtime for file patching. */
-export interface ApplyPatchToolDeps {
-    readFile(path: string): Promise<string>;
-    writeFile(path: string, content: string): Promise<void>;
-    deleteFile(path: string): Promise<void>;
-    fileExists(path: string): Promise<boolean>;
-    resolvePath(input: string): string;
-}
-export declare function createApplyPatchTool(deps: ApplyPatchToolDeps): PortableTool<ApplyPatchToolParams>;

package/dist/skills/tools/apply-patch-tool.js

@@ -1,184 +0,0 @@
-// ============================================================
-// Apply Patch Tool — apply unified diff patches to files.
-// Category: coding
-// ============================================================
-export const APPLY_PATCH_TOOL_NAME = "apply_patch";
-export const APPLY_PATCH_TOOL_SCHEMA = {
-    type: "object",
-    properties: {
-        input: {
-            type: "string",
-            description: "Patch content using the *** Begin Patch / *** End Patch format.",
-        },
-    },
-    required: ["input"],
-};
-function parsePatch(input) {
-    const lines = input.split("\n");
-    const ops = [];
-    let current = null;
-    let currentHunk = null;
-    let inPatch = false;
-    for (const line of lines) {
-        if (line.startsWith("*** Begin Patch")) {
-            inPatch = true;
-            continue;
-        }
-        if (line.startsWith("*** End Patch")) {
-            break;
-        }
-        if (!inPatch)
-            continue;
-        if (line.startsWith("*** Add File: ")) {
-            if (current)
-                ops.push(current);
-            current = { type: "add", path: line.slice("*** Add File: ".length).trim(), hunks: [] };
-            currentHunk = { contextBefore: [], removals: [], additions: [], contextAfter: [] };
-            current.hunks.push(currentHunk);
-        }
-        else if (line.startsWith("*** Update File: ")) {
-            if (current)
-                ops.push(current);
-            current = { type: "update", path: line.slice("*** Update File: ".length).trim(), hunks: [] };
-            currentHunk = null;
-        }
-        else if (line.startsWith("*** Delete File: ")) {
-            if (current)
-                ops.push(current);
-            current = { type: "delete", path: line.slice("*** Delete File: ".length).trim(), hunks: [] };
-            currentHunk = null;
-        }
-        else if (line.startsWith("*** Move to: ") && current) {
-            current.moveTo = line.slice("*** Move to: ".length).trim();
-        }
-        else if (line.startsWith("@@ ") && current) {
-            currentHunk = { contextBefore: [], removals: [], additions: [], contextAfter: [] };
-            current.hunks.push(currentHunk);
-        }
-        else if (currentHunk) {
-            if (line.startsWith("+")) {
-                currentHunk.additions.push(line.slice(1));
-            }
-            else if (line.startsWith("-")) {
-                currentHunk.removals.push(line.slice(1));
-            }
-            else {
-                // context line (space prefix or bare)
-                const ctx = line.startsWith(" ") ? line.slice(1) : line;
-                if (currentHunk.additions.length === 0 && currentHunk.removals.length === 0) {
-                    currentHunk.contextBefore.push(ctx);
-                }
-                else {
-                    currentHunk.contextAfter.push(ctx);
-                }
-            }
-        }
-    }
-    if (current)
-        ops.push(current);
-    return ops;
-}
-function applyHunksToContent(content, hunks) {
-    const lines = content.split("\n");
-    let result = [...lines];
-    for (const hunk of hunks) {
-        // Find context match position
-        let matchStart = -1;
-        if (hunk.contextBefore.length > 0) {
-            for (let i = 0; i <= result.length - hunk.contextBefore.length; i++) {
-                let matches = true;
-                for (let j = 0; j < hunk.contextBefore.length; j++) {
-                    if (result[i + j] !== hunk.contextBefore[j]) {
-                        matches = false;
-                        break;
-                    }
-                }
-                if (matches) {
-                    matchStart = i + hunk.contextBefore.length;
-                    break;
-                }
-            }
-        }
-        else {
-            matchStart = 0;
-        }
-        if (matchStart === -1)
-            continue;
-        // Remove old lines
-        if (hunk.removals.length > 0) {
-            result.splice(matchStart, hunk.removals.length, ...hunk.additions);
-        }
-        else {
-            result.splice(matchStart, 0, ...hunk.additions);
-        }
-    }
-    return result.join("\n");
-}
-export function createApplyPatchTool(deps) {
-    return {
-        name: APPLY_PATCH_TOOL_NAME,
-        label: "Apply Patch",
-        description: "Apply a patch to one or more files using the *** Begin Patch / *** End Patch format. " +
-            "Supports Add File, Update File, Delete File, and Move To operations.",
-        parameters: APPLY_PATCH_TOOL_SCHEMA,
-        execute: async (_toolCallId, params) => {
-            const ops = parsePatch(params.input);
-            if (ops.length === 0) {
-                return {
-                    content: [{ type: "text", text: "Error: No valid patch operations found. Ensure *** Begin Patch / *** End Patch markers are present." }],
-                };
-            }
-            const summary = { added: [], modified: [], deleted: [] };
-            const errors = [];
-            for (const op of ops) {
-                const resolved = deps.resolvePath(op.path);
-                try {
-                    switch (op.type) {
-                        case "add": {
-                            const newContent = op.hunks.flatMap((h) => [...h.additions]).join("\n");
-                            await deps.writeFile(resolved, newContent);
-                            summary.added.push(op.path);
-                            break;
-                        }
-                        case "update": {
-                            const existing = await deps.readFile(resolved);
-                            const patched = applyHunksToContent(existing, op.hunks);
-                            if (op.moveTo) {
-                                const dest = deps.resolvePath(op.moveTo);
-                                await deps.writeFile(dest, patched);
-                                await deps.deleteFile(resolved);
-                                summary.modified.push(`${op.path} → ${op.moveTo}`);
-                            }
-                            else {
-                                await deps.writeFile(resolved, patched);
-                                summary.modified.push(op.path);
-                            }
-                            break;
-                        }
-                        case "delete": {
-                            await deps.deleteFile(resolved);
-                            summary.deleted.push(op.path);
-                            break;
-                        }
-                    }
-                }
-                catch (err) {
-                    errors.push(`${op.type} ${op.path}: ${err instanceof Error ? err.message : String(err)}`);
-                }
-            }
-            const parts = [];
-            if (summary.added.length)
-                parts.push(`Added: ${summary.added.join(", ")}`);
-            if (summary.modified.length)
-                parts.push(`Modified: ${summary.modified.join(", ")}`);
-            if (summary.deleted.length)
-                parts.push(`Deleted: ${summary.deleted.join(", ")}`);
-            if (errors.length)
-                parts.push(`Errors: ${errors.join("; ")}`);
-            return {
-                content: [{ type: "text", text: parts.join("\n") || "No changes applied." }],
-                details: { type: "apply_patch", summary, errors },
-            };
-        },
-    };
-}

package/dist/skills/tools/ask-user-tool.d.ts

@@ -1,80 +0,0 @@
-import type { PortableTool } from "../portable-tool.js";
-export declare const ASK_USER_TOOL_NAME: "ask_user";
-export interface AskUserOption {
-    label: string;
-    description?: string;
-}
-export interface AskUserQuestion {
-    question: string;
-    header: string;
-    options?: AskUserOption[];
-    multiSelect?: boolean;
-}
-export interface AskUserToolParams {
-    questions: AskUserQuestion[];
-}
-export declare const ASK_USER_TOOL_SCHEMA: {
-    readonly type: "object";
-    readonly properties: {
-        readonly questions: {
-            readonly type: "array";
-            readonly minItems: 1;
-            readonly maxItems: 4;
-            readonly description: "1-4 clarifying questions to ask the user.";
-            readonly items: {
-                readonly type: "object";
-                readonly properties: {
-                    readonly question: {
-                        readonly type: "string";
-                        readonly description: "The question text. Should end with '?'.";
-                    };
-                    readonly header: {
-                        readonly type: "string";
-                        readonly description: "Short identifier/tag for this question (max 50 chars).";
-                    };
-                    readonly options: {
-                        readonly type: "array";
-                        readonly description: "2-4 options for the user to choose from. Omit for free text.";
-                        readonly items: {
-                            readonly type: "object";
-                            readonly properties: {
-                                readonly label: {
-                                    readonly type: "string";
-                                    readonly description: "Display label (1-5 words).";
-                                };
-                                readonly description: {
-                                    readonly type: "string";
-                                    readonly description: "Brief explanation of this option.";
-                                };
-                            };
-                            readonly required: readonly ["label"];
-                        };
-                    };
-                    readonly multiSelect: {
-                        readonly type: "boolean";
-                        readonly description: "Allow selecting multiple options (default: false).";
-                    };
-                };
-                readonly required: readonly ["question", "header"];
-            };
-        };
-    };
-    readonly required: readonly ["questions"];
-};
-export interface AskUserAnswer {
-    question: string;
-    answer: string;
-}
-/**
- * Host-provided user interaction backend.
- * The host renders the questions in the UI and collects answers.
- */
-export interface AskUserToolDeps {
-    /**
-     * Present questions to the user and collect answers.
-     * Returns a map of question text → answer text.
-     * If the user declines, returns null.
-     */
-    askUser(questions: AskUserQuestion[]): Promise<Record<string, string> | null>;
-}
-export declare function createAskUserTool(deps: AskUserToolDeps): PortableTool<AskUserToolParams>;

package/dist/skills/tools/ask-user-tool.js

@@ -1,121 +0,0 @@
-// ============================================================
-// Ask User Tool — ask the user clarifying questions.
-// Reference: claude-code-haha/src/tools/AskUserQuestionTool/AskUserQuestionTool.tsx
-// Category: interaction
-// ============================================================
-export const ASK_USER_TOOL_NAME = "ask_user";
-export const ASK_USER_TOOL_SCHEMA = {
-    type: "object",
-    properties: {
-        questions: {
-            type: "array",
-            minItems: 1,
-            maxItems: 4,
-            description: "1-4 clarifying questions to ask the user.",
-            items: {
-                type: "object",
-                properties: {
-                    question: {
-                        type: "string",
-                        description: "The question text. Should end with '?'.",
-                    },
-                    header: {
-                        type: "string",
-                        description: "Short identifier/tag for this question (max 50 chars).",
-                    },
-                    options: {
-                        type: "array",
-                        description: "2-4 options for the user to choose from. Omit for free text.",
-                        items: {
-                            type: "object",
-                            properties: {
-                                label: {
-                                    type: "string",
-                                    description: "Display label (1-5 words).",
-                                },
-                                description: {
-                                    type: "string",
-                                    description: "Brief explanation of this option.",
-                                },
-                            },
-                            required: ["label"],
-                        },
-                    },
-                    multiSelect: {
-                        type: "boolean",
-                        description: "Allow selecting multiple options (default: false).",
-                    },
-                },
-                required: ["question", "header"],
-            },
-        },
-    },
-    required: ["questions"],
-};
-export function createAskUserTool(deps) {
-    return {
-        name: ASK_USER_TOOL_NAME,
-        label: "Ask User",
-        description: "Ask the user clarifying questions when you need more information to proceed. " +
-            "Supports free text questions and multiple-choice options. " +
-            "Use this when the user's intent is ambiguous or you need confirmation.",
-        parameters: ASK_USER_TOOL_SCHEMA,
-        execute: async (_toolCallId, params) => {
-            // Validate questions count
-            if (!params.questions || params.questions.length === 0) {
-                return {
-                    content: [{ type: "text", text: "Error: at least one question is required." }],
-                    details: { type: "ask_user", error: "no_questions" },
-                };
-            }
-            if (params.questions.length > 4) {
-                return {
-                    content: [{ type: "text", text: "Error: maximum 4 questions allowed." }],
-                    details: { type: "ask_user", error: "too_many_questions" },
-                };
-            }
-            // Validate unique question texts
-            const questionTexts = params.questions.map((q) => q.question);
-            if (new Set(questionTexts).size !== questionTexts.length) {
-                return {
-                    content: [{ type: "text", text: "Error: all questions must have unique text." }],
-                    details: { type: "ask_user", error: "duplicate_questions" },
-                };
-            }
-            // Validate options count and label uniqueness per question
-            for (const q of params.questions) {
-                if (q.options && (q.options.length < 2 || q.options.length > 4)) {
-                    return {
-                        content: [{ type: "text", text: `Error: question "${q.header}" must have 2-4 options (got ${q.options.length}).` }],
-                        details: { type: "ask_user", error: "invalid_option_count" },
-                    };
-                }
-                if (q.options) {
-                    const labels = q.options.map((o) => o.label);
-                    if (new Set(labels).size !== labels.length) {
-                        return {
-                            content: [{ type: "text", text: `Error: question "${q.header}" has duplicate option labels.` }],
-                            details: { type: "ask_user", error: "duplicate_option_labels" },
-                        };
-                    }
-                }
-            }
-            const answers = await deps.askUser(params.questions);
-            if (answers === null) {
-                return {
-                    content: [{ type: "text", text: "User declined to answer questions." }],
-                    details: { type: "ask_user", declined: true },
-                };
-            }
-            const lines = ["User answered:"];
-            for (const q of params.questions) {
-                const answer = answers[q.question] ?? "(no answer)";
-                lines.push(`- ${q.header}: ${answer}`);
-            }
-            return {
-                content: [{ type: "text", text: lines.join("\n") }],
-                details: { type: "ask_user", answers, questionCount: params.questions.length },
-            };
-        },
-    };
-}

package/dist/skills/tools/brief-tool.d.ts

@@ -1,74 +0,0 @@
-import type { PortableTool } from "../portable-tool.js";
-export declare const BRIEF_TOOL_NAME: "send_user_message";
-export type BriefMessageStatus = "normal" | "proactive";
-export interface BriefAttachment {
-    /** Absolute or workspace-relative path */
-    path: string;
-    /** Size in bytes (filled by host) */
-    size?: number;
-    /** Whether the file is an image */
-    isImage?: boolean;
-    /** Upload UUID (host may upload for web preview) */
-    fileUuid?: string;
-}
-export interface BriefToolParams {
-    /** Markdown-formatted message to display to the user */
-    message: string;
-    /** File attachments to include with the message */
-    attachments?: string[];
-    /** Message status — 'proactive' for unsolicited updates */
-    status?: BriefMessageStatus;
-}
-export declare const BRIEF_TOOL_SCHEMA: {
-    readonly type: "object";
-    readonly properties: {
-        readonly message: {
-            readonly type: "string";
-            readonly description: string;
-            readonly minLength: 1;
-        };
-        readonly attachments: {
-            readonly type: "array";
-            readonly description: "Optional file paths to attach (images, documents, etc.).";
-            readonly items: {
-                readonly type: "string";
-            };
-            readonly maxItems: 10;
-        };
-        readonly status: {
-            readonly type: "string";
-            readonly enum: readonly ["normal", "proactive"];
-            readonly description: string;
-        };
-    };
-    readonly required: readonly ["message"];
-};
-export interface BriefDeliveryResult {
-    delivered: boolean;
-    attachments?: BriefAttachment[];
-    sentAt?: string;
-    error?: string;
-}
-/**
- * Host-provided message delivery backend.
- */
-export interface BriefToolDeps {
-    /** Deliver the message to the user's UI */
-    deliverMessage(params: {
-        message: string;
-        attachments?: string[];
-        status: BriefMessageStatus;
-    }): Promise<BriefDeliveryResult>;
-    /** Validate and resolve attachment paths. Returns resolved attachments or error. */
-    resolveAttachments?(paths: string[]): Promise<BriefAttachment[] | {
-        error: string;
-    }>;
-}
-/** Check if brief mode is active (host determines this) */
-export interface BriefModeConfig {
-    /** Whether the agent is in brief/chat mode */
-    isBriefMode: boolean;
-    /** Whether the user opted in via UI/CLI */
-    userOptIn?: boolean;
-}
-export declare function createBriefTool(deps: BriefToolDeps): PortableTool<BriefToolParams>;