qlogicagent 0.2.1 → 0.3.0

package/dist/skills/tools/plan-mode-tool.js

@@ -1,122 +0,0 @@
-// ============================================================
-// Plan Mode Tool — enter/exit plan mode for safer exploration.
-// Reference: claude-code-haha/src/tools/EnterPlanModeTool/EnterPlanModeTool.ts
-//            claude-code-haha/src/tools/ExitPlanModeTool/ExitPlanModeV2Tool.ts
-// Category: system (mode switch)
-// ============================================================
-export const PLAN_MODE_TOOL_NAME = "plan_mode";
-export const PLAN_MODE_TOOL_SCHEMA = {
-    type: "object",
-    properties: {
-        action: {
-            type: "string",
-            enum: ["enter", "exit"],
-            description: "enter: Switch to plan mode (only read/search/think tools available).\n" +
-                "exit: Leave plan mode and submit plan for approval (restores full tool access).",
-        },
-        plan: {
-            type: "string",
-            description: "The finalized plan text to present for user approval (used with 'exit' action). " +
-                "Write a clear, structured plan of what will be done.",
-        },
-        planFilePath: {
-            type: "string",
-            description: "Optional file path where the plan was saved for reference.",
-        },
-    },
-    required: ["action"],
-};
-/** Tools allowed during plan mode (read-only + reasoning) */
-export const PLAN_MODE_ALLOWED_TOOLS = [
-    "read",
-    "search",
-    "think",
-    "lsp",
-    "web_search",
-    "web_fetch",
-    "memory_query",
-    "memory_search",
-    "skill_list",
-    "skill_view",
-    "tool_search",
-    "plan_mode",
-];
-export function createPlanModeTool(deps) {
-    return {
-        name: PLAN_MODE_TOOL_NAME,
-        label: "Plan Mode",
-        description: "Switch between plan mode and execution mode. In plan mode, only " +
-            "read-only tools (read, search, think, lsp) are available — no file writes or commands. " +
-            "Use plan mode to safely explore a problem before committing to changes. " +
-            "Exit plan mode with a finalized plan for user approval.",
-        parameters: PLAN_MODE_TOOL_SCHEMA,
-        execute: async (_toolCallId, params) => {
-            // Plan mode not allowed in sub-agent context
-            if (deps.isAgentContext?.()) {
-                return {
-                    content: [{ type: "text", text: "Error: plan mode is not available in sub-agent context." }],
-                    details: { type: "plan_mode", error: "agent_context" },
-                };
-            }
-            switch (params.action) {
-                case "enter": {
-                    const state = deps.getState();
-                    if (state.active) {
-                        return {
-                            content: [{ type: "text", text: "Already in plan mode. Use action='exit' with a plan to leave." }],
-                            details: { type: "plan_mode", error: "already_active" },
-                        };
-                    }
-                    const result = await deps.enterPlanMode();
-                    if (!result.success) {
-                        return {
-                            content: [{ type: "text", text: `Error: ${result.error || "failed to enter plan mode"}` }],
-                            details: { type: "plan_mode", error: result.error },
-                        };
-                    }
-                    const lines = [
-                        "Entered plan mode.",
-                        "",
-                        "Available tools: " + PLAN_MODE_ALLOWED_TOOLS.join(", "),
-                        "",
-                        "All write/execute tools are disabled. Explore the problem, then exit with a plan.",
-                        'Use action="exit" with a plan parameter when ready.',
-                    ];
-                    return {
-                        content: [{ type: "text", text: lines.join("\n") }],
-                        details: { type: "plan_mode", action: "enter", allowedTools: PLAN_MODE_ALLOWED_TOOLS },
-                    };
-                }
-                case "exit": {
-                    const state = deps.getState();
-                    if (!state.active) {
-                        return {
-                            content: [{ type: "text", text: "Not in plan mode. Nothing to exit." }],
-                            details: { type: "plan_mode", error: "not_active" },
-                        };
-                    }
-                    const result = await deps.exitPlanMode(params.plan, params.planFilePath);
-                    if (!result.success) {
-                        return {
-                            content: [{ type: "text", text: `Error: ${result.error || "failed to exit plan mode"}` }],
-                            details: { type: "plan_mode", error: result.error },
-                        };
-                    }
-                    const lines = ["Exited plan mode. Full tool access restored."];
-                    if (params.plan) {
-                        lines.push("", "Submitted plan for approval:", "", params.plan);
-                    }
-                    return {
-                        content: [{ type: "text", text: lines.join("\n") }],
-                        details: { type: "plan_mode", action: "exit", hasPlan: !!params.plan },
-                    };
-                }
-                default:
-                    return {
-                        content: [{ type: "text", text: `Error: unknown action "${params.action}". Use "enter" or "exit".` }],
-                        details: { type: "plan_mode", error: "unknown_action" },
-                    };
-            }
-        },
-    };
-}

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

@@ -1,84 +0,0 @@
-// ============================================================
-// File Read Tool — read file contents with offset/limit.
-// Reference: claude-code-haha/src/tools/FileReadTool/FileReadTool.ts
-// Category: coding
-// ============================================================
-export const READ_TOOL_NAME = "read";
-export const READ_TOOL_SCHEMA = {
-    type: "object",
-    properties: {
-        path: {
-            type: "string",
-            description: "Absolute path to the file to read.",
-        },
-        offset: {
-            type: "number",
-            description: "Line number to start reading from (1-indexed). Default: 1.",
-        },
-        limit: {
-            type: "number",
-            description: "Maximum number of lines to read. Default/max: 2000.",
-        },
-    },
-    required: ["path"],
-};
-export function createReadTool(deps) {
-    const MAX_LINES = 2000;
-    const MAX_BYTES = 50_000;
-    return {
-        name: READ_TOOL_NAME,
-        label: "Read File",
-        description: "Read the contents of a file. Supports text files and images (jpg, png, gif, webp). " +
-            "For text files, output is truncated to 2000 lines or 50KB. " +
-            "Binary files are rejected with a hint. " +
-            "Use offset/limit for pagination of large files.",
-        parameters: READ_TOOL_SCHEMA,
-        execute: async (_toolCallId, params) => {
-            const resolved = deps.resolvePath(params.path);
-            // Validate path access
-            if (deps.validatePath) {
-                const blocked = deps.validatePath(resolved);
-                if (blocked) {
-                    return {
-                        content: [{ type: "text", text: `Access denied: ${blocked}` }],
-                        details: { type: "read", path: resolved, error: "access_denied" },
-                    };
-                }
-            }
-            const result = await deps.readFile(resolved);
-            // Image
-            if (result.type === "image") {
-                return {
-                    content: [{ type: "image", data: result.base64, mimeType: result.mimeType }],
-                    details: { type: "read", path: resolved, isImage: true },
-                };
-            }
-            // Binary rejection
-            if (result.type === "binary") {
-                return {
-                    content: [{
-                            type: "text",
-                            text: `Cannot read binary file (${result.mimeType}). ` +
-                                "Use a specific tool for this file type (e.g. pdf tool for PDFs).",
-                        }],
-                    details: { type: "read", path: resolved, error: "binary_file", mimeType: result.mimeType },
-                };
-            }
-            // Text file
-            const lines = result.text.split("\n");
-            const offset = Math.max(0, (params.offset ?? 1) - 1);
-            const limit = Math.min(params.limit ?? MAX_LINES, MAX_LINES);
-            const sliced = lines.slice(offset, offset + limit);
-            let text = sliced.join("\n");
-            if (text.length > MAX_BYTES)
-                text = text.slice(0, MAX_BYTES) + "\n... (truncated)";
-            const totalLines = lines.length;
-            const endLine = offset + sliced.length;
-            const hasMore = endLine < totalLines;
-            return {
-                content: [{ type: "text", text }],
-                details: { type: "read", path: resolved, totalLines, startLine: offset + 1, endLine, hasMore },
-            };
-        },
-    };
-}

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

@@ -1,69 +0,0 @@
-// ============================================================
-// REPL Tool — execute JavaScript in a persistent VM context
-//             with injected tool primitives for batch operations.
-// Reference: claude-code-haha/src/tools/REPLTool/primitiveTools.ts
-// Category: system
-// ============================================================
-export const REPL_TOOL_NAME = "repl";
-export const REPL_TOOL_SCHEMA = {
-    type: "object",
-    properties: {
-        code: {
-            type: "string",
-            description: "JavaScript code to execute. The VM has access to these built-in primitives:\n" +
-                "- readFile(path): Promise<string> — read a file\n" +
-                "- writeFile(path, content): Promise<void> — write a file\n" +
-                "- editFile(path, edits): Promise<string> — apply edits [{oldText, newText}]\n" +
-                "- exec(command): Promise<{stdout, stderr, exitCode}> — run shell command\n" +
-                "- glob(pattern): Promise<string[]> — find files by glob\n" +
-                "- grep(pattern, path?): Promise<{file,line,text}[]> — search files\n" +
-                "Use this for batch operations (rename many files, transform data, etc) " +
-                "to reduce tool call round-trips.",
-        },
-    },
-    required: ["code"],
-};
-/** Tool names that should be hidden from direct LLM access when REPL is active. */
-export const REPL_HIDES_TOOLS = ["read", "write", "edit", "exec", "search"];
-const MAX_CODE_LENGTH = 100_000;
-const MAX_OUTPUT_LENGTH = 50_000;
-export function createReplTool(deps) {
-    return {
-        name: REPL_TOOL_NAME,
-        label: "REPL",
-        description: "Execute JavaScript in a persistent VM with built-in file/shell primitives. " +
-            "Use for batch operations that would otherwise require many individual tool calls. " +
-            "The VM persists variables between calls within the same session. " +
-            "Each primitive (readFile, writeFile, exec, etc.) still goes through permission checks.",
-        parameters: REPL_TOOL_SCHEMA,
-        execute: async (_toolCallId, params) => {
-            if (!params.code || params.code.trim().length === 0) {
-                return {
-                    content: [{ type: "text", text: "Error: code is required." }],
-                    details: { type: "repl", error: "empty_code" },
-                };
-            }
-            if (params.code.length > MAX_CODE_LENGTH) {
-                return {
-                    content: [{ type: "text", text: `Error: code too large (${params.code.length} chars, max ${MAX_CODE_LENGTH}).` }],
-                    details: { type: "repl", error: "code_too_large" },
-                };
-            }
-            const result = await deps.executeInVm(params.code);
-            let output = result.output || "";
-            if (output.length > MAX_OUTPUT_LENGTH) {
-                output = output.slice(0, MAX_OUTPUT_LENGTH) + "\n... (truncated)";
-            }
-            if (result.error) {
-                return {
-                    content: [{ type: "text", text: `Error: ${result.error}\n\nOutput:\n${output}` }],
-                    details: { type: "repl", error: result.error, duration: result.duration },
-                };
-            }
-            return {
-                content: [{ type: "text", text: output || "(no output)" }],
-                details: { type: "repl", duration: result.duration, outputLength: output.length },
-            };
-        },
-    };
-}

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

@@ -1,225 +0,0 @@
-// ============================================================
-// Search Tool — unified file name (glob) + content (grep) search.
-// Fuses CC GlobTool + GrepTool into single PortableTool.
-// Reference: claude-code-haha/src/tools/GlobTool/GlobTool.ts
-//            claude-code-haha/src/tools/GrepTool/GrepTool.ts
-// Category: search
-// ============================================================
-export const SEARCH_TOOL_NAME = "search";
-export const SEARCH_TOOL_SCHEMA = {
-    type: "object",
-    properties: {
-        mode: {
-            type: "string",
-            enum: ["filename", "content", "both"],
-            description: 'Search mode: "filename" to find files by name pattern (glob), ' +
-                '"content" to search within file contents (regex), ' +
-                '"both" to match both filename patterns and content simultaneously.',
-        },
-        pattern: {
-            type: "string",
-            description: "The pattern to search for. In filename mode this is a glob pattern " +
-                "(e.g. **/*.ts). In content mode this is a regular expression. " +
-                "In both mode this is treated as a regex for content, and fileGlob " +
-                "filters the filename set.",
-        },
-        path: {
-            type: "string",
-            description: "Directory to search in. Defaults to workdir/cwd if omitted.",
-        },
-        fileGlob: {
-            type: "string",
-            description: 'Glob pattern to filter files (e.g. "*.ts", "*.{js,tsx}"). ' +
-                "In content/both modes, only files matching this glob are searched.",
-        },
-        contextLines: {
-            type: "number",
-            description: "Number of context lines to show before and after each match " +
-                "(content/both modes only). Default: 0.",
-        },
-        caseInsensitive: {
-            type: "boolean",
-            description: "Case insensitive search (content/both modes). Default: false.",
-        },
-        headLimit: {
-            type: "number",
-            description: "Maximum number of result entries to return. Default 100 for filename, " +
-                "250 for content. Pass 0 for unlimited (use sparingly).",
-        },
-        offset: {
-            type: "number",
-            description: "Skip first N results before applying headLimit. Default: 0.",
-        },
-    },
-    required: ["mode", "pattern"],
-};
-// ── Constants ───────────────────────────────────────────────
-const DEFAULT_FILENAME_LIMIT = 100;
-const DEFAULT_CONTENT_LIMIT = 250;
-const MAX_RESULT_CHARS = 100_000;
-// ── Factory ─────────────────────────────────────────────────
-export function createSearchTool(deps) {
-    return {
-        name: SEARCH_TOOL_NAME,
-        label: "Search",
-        description: "Search for files by name, search within file contents by regex, or both. " +
-            "In filename mode, pattern is a glob. In content mode, pattern is a regex. " +
-            "Results are paginated via headLimit + offset.",
-        parameters: SEARCH_TOOL_SCHEMA,
-        execute: async (_toolCallId, params) => {
-            const cwd = params.path
-                ? (deps.resolvePath ? deps.resolvePath(params.path) : params.path)
-                : "";
-            const mode = params.mode;
-            if (mode === "filename") {
-                return executeFilenameSearch(deps, params, cwd);
-            }
-            else if (mode === "content") {
-                return executeContentSearch(deps, params, cwd);
-            }
-            else {
-                // "both" — run filename glob + content grep, merge results
-                return executeBothSearch(deps, params, cwd);
-            }
-        },
-    };
-}
-// ── Filename search ─────────────────────────────────────────
-async function executeFilenameSearch(deps, params, cwd) {
-    const limit = params.headLimit ?? DEFAULT_FILENAME_LIMIT;
-    const { files, truncated } = await deps.glob(params.pattern, {
-        cwd,
-        limit: limit === 0 ? 10000 : limit,
-    });
-    const offset = params.offset ?? 0;
-    const sliced = offset > 0 ? files.slice(offset) : files;
-    const effectiveLimit = limit === 0 ? sliced.length : limit;
-    const finalFiles = sliced.slice(0, effectiveLimit);
-    const wasTruncated = truncated || sliced.length > effectiveLimit;
-    if (finalFiles.length === 0) {
-        return {
-            content: [{ type: "text", text: "No files found matching pattern." }],
-            details: { mode: "filename", totalMatches: 0, truncated: false },
-        };
-    }
-    let text = finalFiles.join("\n");
-    if (wasTruncated) {
-        text += `\n\n(Results truncated. ${finalFiles.length} shown. Use a more specific pattern or increase headLimit.)`;
-    }
-    text = truncateText(text, MAX_RESULT_CHARS);
-    return {
-        content: [{ type: "text", text }],
-        details: {
-            mode: "filename",
-            totalMatches: finalFiles.length,
-            truncated: wasTruncated,
-        },
-    };
-}
-// ── Content search ──────────────────────────────────────────
-async function executeContentSearch(deps, params, cwd) {
-    const headLimit = params.headLimit ?? DEFAULT_CONTENT_LIMIT;
-    const { matches, truncated } = await deps.grep(params.pattern, {
-        cwd,
-        fileGlob: params.fileGlob,
-        caseInsensitive: params.caseInsensitive,
-        contextLines: params.contextLines,
-        headLimit: headLimit === 0 ? undefined : headLimit,
-        offset: params.offset,
-    });
-    if (matches.length === 0) {
-        return {
-            content: [{ type: "text", text: "No matches found." }],
-            details: { mode: "content", totalMatches: 0, truncated: false },
-        };
-    }
-    const lines = [];
-    for (const m of matches) {
-        if (m.contextBefore && m.contextBefore.length > 0) {
-            for (const ctx of m.contextBefore) {
-                lines.push(`  ${ctx}`);
-            }
-        }
-        lines.push(`${m.path}:${m.line}: ${m.text}`);
-        if (m.contextAfter && m.contextAfter.length > 0) {
-            for (const ctx of m.contextAfter) {
-                lines.push(`  ${ctx}`);
-            }
-        }
-        // Separator between match groups when context is present
-        if (params.contextLines && params.contextLines > 0) {
-            lines.push("--");
-        }
-    }
-    let text = lines.join("\n");
-    if (truncated) {
-        text += `\n\n(Results truncated at ${matches.length} matches. Use offset/headLimit for pagination.)`;
-    }
-    text = truncateText(text, MAX_RESULT_CHARS);
-    return {
-        content: [{ type: "text", text }],
-        details: {
-            mode: "content",
-            totalMatches: matches.length,
-            truncated,
-        },
-    };
-}
-// ── Both mode ───────────────────────────────────────────────
-async function executeBothSearch(deps, params, cwd) {
-    // Run both in parallel
-    const [globResult, grepResult] = await Promise.all([
-        params.fileGlob
-            ? deps.glob(params.fileGlob, { cwd, limit: DEFAULT_FILENAME_LIMIT })
-            : Promise.resolve({ files: [], truncated: false }),
-        deps.grep(params.pattern, {
-            cwd,
-            fileGlob: params.fileGlob,
-            caseInsensitive: params.caseInsensitive,
-            contextLines: params.contextLines,
-            headLimit: params.headLimit ?? DEFAULT_CONTENT_LIMIT,
-            offset: params.offset,
-        }),
-    ]);
-    // Deduplicate: files that appear in both glob and grep results
-    const contentFiles = new Set(grepResult.matches.map((m) => m.path));
-    const uniqueGlobFiles = globResult.files.filter((f) => !contentFiles.has(f));
-    const sections = [];
-    if (uniqueGlobFiles.length > 0) {
-        sections.push(`## Files matching glob (${uniqueGlobFiles.length}):\n${uniqueGlobFiles.join("\n")}`);
-    }
-    if (grepResult.matches.length > 0) {
-        const lines = [];
-        for (const m of grepResult.matches) {
-            lines.push(`${m.path}:${m.line}: ${m.text}`);
-        }
-        sections.push(`## Content matches (${grepResult.matches.length}):\n${lines.join("\n")}`);
-    }
-    if (sections.length === 0) {
-        return {
-            content: [{ type: "text", text: "No matches found in either filename or content." }],
-            details: { mode: "both", totalMatches: 0, truncated: false },
-        };
-    }
-    const truncated = globResult.truncated || grepResult.truncated;
-    let text = sections.join("\n\n");
-    if (truncated) {
-        text += "\n\n(Some results truncated. Use more specific patterns.)";
-    }
-    text = truncateText(text, MAX_RESULT_CHARS);
-    return {
-        content: [{ type: "text", text }],
-        details: {
-            mode: "both",
-            totalMatches: uniqueGlobFiles.length + grepResult.matches.length,
-            truncated,
-        },
-    };
-}
-// ── Util ────────────────────────────────────────────────────
-function truncateText(text, limit) {
-    if (text.length <= limit)
-        return text;
-    const half = Math.floor(limit / 2) - 50;
-    return `${text.slice(0, half)}\n\n... [truncated ${text.length - limit} chars] ...\n\n${text.slice(-half)}`;
-}

package/dist/skills/tools/send-message-tool.js

@@ -1,76 +0,0 @@
-// ============================================================
-// Send Message Tool — agent-to-agent IPC within a team/swarm.
-// Reference: claude-code-haha/src/tools/SendMessageTool/SendMessageTool.ts
-//            hermes-agent-main/tools/send_message_tool.py
-// Category: system
-// ============================================================
-export const SEND_MESSAGE_TOOL_NAME = "send_message";
-export const SEND_MESSAGE_TOOL_SCHEMA = {
-    type: "object",
-    properties: {
-        to: {
-            type: "string",
-            description: "Target agent name or '*' for broadcast to all team members. " +
-                "Must be a valid agent name within the current team.",
-        },
-        message: {
-            type: "string",
-            description: "Message content to send to the target agent.",
-        },
-        summary: {
-            type: "string",
-            description: "Optional short summary (for logging/routing).",
-        },
-    },
-    required: ["to", "message"],
-};
-export function createSendMessageTool(deps) {
-    return {
-        name: SEND_MESSAGE_TOOL_NAME,
-        label: "Send Message",
-        description: "Send a message to another agent in your team. Use '*' to broadcast to all teammates. " +
-            "Messages are delivered asynchronously. Use for coordination, delegation, and status updates.",
-        parameters: SEND_MESSAGE_TOOL_SCHEMA,
-        execute: async (_toolCallId, params) => {
-            if (!params.to || params.to.trim().length === 0) {
-                return {
-                    content: [{ type: "text", text: "Error: 'to' is required (agent name or '*')." }],
-                    details: { type: "send_message", error: "missing_target" },
-                };
-            }
-            if (!params.message || params.message.trim().length === 0) {
-                return {
-                    content: [{ type: "text", text: "Error: message is required." }],
-                    details: { type: "send_message", error: "empty_message" },
-                };
-            }
-            // Validate target exists (unless broadcast)
-            if (params.to !== "*" && deps.listTeammates) {
-                const teammates = deps.listTeammates();
-                if (!teammates.includes(params.to)) {
-                    return {
-                        content: [{ type: "text", text: `Error: agent "${params.to}" not found in team. Available: ${teammates.join(", ")}` }],
-                        details: { type: "send_message", error: "target_not_found", available: teammates },
-                    };
-                }
-            }
-            const result = await deps.sendMessage({
-                to: params.to.trim(),
-                message: params.message.trim(),
-                summary: params.summary,
-                senderId: deps.getSenderId(),
-            });
-            if (!result.success) {
-                return {
-                    content: [{ type: "text", text: `Message delivery failed: ${result.error || "unknown error"}` }],
-                    details: { type: "send_message", success: false, error: result.error },
-                };
-            }
-            const target = params.to === "*" ? `broadcast (${result.recipients?.length || 0} recipients)` : params.to;
-            return {
-                content: [{ type: "text", text: `Message sent to ${target}.` }],
-                details: { type: "send_message", success: true, to: params.to, recipients: result.recipients },
-            };
-        },
-    };
-}

package/dist/skills/tools/skill-list-tool.js

@@ -1,54 +0,0 @@
-// ============================================================
-// Skill List Tool — discover available skills.
-// Reference: hermes-agent-2026.4.30/tools/skills_tool.py (skills_list)
-// Category: skill
-// ============================================================
-export const SKILL_LIST_TOOL_NAME = "skill_list";
-export const SKILL_LIST_TOOL_SCHEMA = {
-    type: "object",
-    properties: {
-        category: {
-            type: "string",
-            description: "Filter skills by category (e.g. 'devops', 'mlops'). Omit to list all.",
-        },
-    },
-    required: [],
-};
-export function createSkillListTool(deps) {
-    return {
-        name: SKILL_LIST_TOOL_NAME,
-        label: "List Skills",
-        description: "List all available skills (reusable workflows/knowledge packages). " +
-            "Returns skill names, descriptions, and categories. " +
-            "Use skill_view to see full skill content.",
-        parameters: SKILL_LIST_TOOL_SCHEMA,
-        execute: async (_toolCallId, params) => {
-            const output = await deps.listSkills(params.category);
-            if (output.skills.length === 0) {
-                const msg = params.category
-                    ? `No skills found in category "${params.category}".`
-                    : "No skills available.";
-                return {
-                    content: [{ type: "text", text: msg }],
-                    details: { type: "skill_list", count: 0 },
-                };
-            }
-            const lines = [`Available skills (${output.skills.length}):`];
-            if (output.categories.length > 0) {
-                lines.push(`Categories: ${output.categories.join(", ")}`);
-            }
-            lines.push("");
-            for (const s of output.skills) {
-                const cat = s.category ? ` [${s.category}]` : "";
-                const ver = s.version ? ` (v${s.version})` : "";
-                lines.push(`- **${s.name}**${ver}${cat}: ${s.description}`);
-            }
-            lines.push("");
-            lines.push("Use skill_view(name) to see full skill content.");
-            return {
-                content: [{ type: "text", text: lines.join("\n") }],
-                details: { type: "skill_list", count: output.skills.length, categories: output.categories },
-            };
-        },
-    };
-}