qlogicagent 0.2.1 → 0.4.0

package/dist/skills/tools/plan-mode-tool.d.ts

@@ -1,59 +0,0 @@
-import type { PortableTool } from "../portable-tool.js";
-export declare const PLAN_MODE_TOOL_NAME: "plan_mode";
-export type PlanModeAction = "enter" | "exit";
-export interface PlanModeToolParams {
-    /** Action: enter or exit plan mode */
-    action: PlanModeAction;
-    /** Plan text (for exit — the finalized plan to present for approval) */
-    plan?: string;
-    /** File path where plan was saved (optional) */
-    planFilePath?: string;
-}
-export declare const PLAN_MODE_TOOL_SCHEMA: {
-    readonly type: "object";
-    readonly properties: {
-        readonly action: {
-            readonly type: "string";
-            readonly enum: readonly ["enter", "exit"];
-            readonly description: string;
-        };
-        readonly plan: {
-            readonly type: "string";
-            readonly description: string;
-        };
-        readonly planFilePath: {
-            readonly type: "string";
-            readonly description: "Optional file path where the plan was saved for reference.";
-        };
-    };
-    readonly required: readonly ["action"];
-};
-/** Tools allowed during plan mode (read-only + reasoning) */
-export declare const PLAN_MODE_ALLOWED_TOOLS: readonly string[];
-export interface PlanModeState {
-    active: boolean;
-    enteredAt?: string;
-    plan?: string;
-    planFilePath?: string;
-}
-export interface PlanModeResult {
-    success: boolean;
-    state: PlanModeState;
-    allowedTools?: readonly string[];
-    error?: string;
-}
-/**
- * Host-provided plan mode backend.
- * The host is responsible for filtering tool availability based on mode state.
- */
-export interface PlanModeToolDeps {
-    /** Get current plan mode state */
-    getState(): PlanModeState;
-    /** Enter plan mode — host should restrict tool availability */
-    enterPlanMode(): Promise<PlanModeResult>;
-    /** Exit plan mode — host restores full tool availability */
-    exitPlanMode(plan?: string, planFilePath?: string): Promise<PlanModeResult>;
-    /** Check if in agent/sub-agent context (plan mode not allowed in sub-agents) */
-    isAgentContext?(): boolean;
-}
-export declare function createPlanModeTool(deps: PlanModeToolDeps): PortableTool<PlanModeToolParams>;

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

@@ -1,51 +0,0 @@
-import type { PortableTool } from "../portable-tool.js";
-export declare const READ_TOOL_NAME: "read";
-export interface ReadToolParams {
-    path: string;
-    offset?: number;
-    limit?: number;
-}
-export declare const READ_TOOL_SCHEMA: {
-    readonly type: "object";
-    readonly properties: {
-        readonly path: {
-            readonly type: "string";
-            readonly description: "Absolute path to the file to read.";
-        };
-        readonly offset: {
-            readonly type: "number";
-            readonly description: "Line number to start reading from (1-indexed). Default: 1.";
-        };
-        readonly limit: {
-            readonly type: "number";
-            readonly description: "Maximum number of lines to read. Default/max: 2000.";
-        };
-    };
-    readonly required: readonly ["path"];
-};
-export type ReadResultType = "text" | "image" | "binary_rejected";
-/** Deps injected by the host runtime for file reading. */
-export interface ReadToolDeps {
-    /** Read file content. Return string for text, base64 for images, or rejection. */
-    readFile(path: string): Promise<{
-        type: "text";
-        text: string;
-    } | {
-        type: "image";
-        base64: string;
-        mimeType: string;
-    } | {
-        type: "binary";
-        mimeType: string;
-    }>;
-    /** Resolve a relative path to absolute. */
-    resolvePath(input: string): string;
-    /**
-     * Validate read access for the given path.
-     * Returns null if allowed, or an error message if blocked.
-     * Blocks device paths (/dev/zero, /dev/random, etc.) and
-     * paths outside the allowed workspace.
-     */
-    validatePath?(path: string): string | null;
-}
-export declare function createReadTool(deps: ReadToolDeps): PortableTool<ReadToolParams>;

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

@@ -1,70 +0,0 @@
-import type { PortableTool } from "../portable-tool.js";
-export declare const REPL_TOOL_NAME: "repl";
-export interface ReplToolParams {
-    /** JavaScript code to execute in the persistent VM context */
-    code: string;
-}
-export declare const REPL_TOOL_SCHEMA: {
-    readonly type: "object";
-    readonly properties: {
-        readonly code: {
-            readonly type: "string";
-            readonly description: string;
-        };
-    };
-    readonly required: readonly ["code"];
-};
-export interface ReplExecResult {
-    output: string;
-    error?: string;
-    duration: number;
-}
-/** Primitive operations injected into the VM context. */
-export interface ReplPrimitives {
-    readFile(path: string): Promise<string>;
-    writeFile(path: string, content: string): Promise<void>;
-    editFile(path: string, edits: Array<{
-        oldText: string;
-        newText: string;
-    }>): Promise<string>;
-    exec(command: string): Promise<{
-        stdout: string;
-        stderr: string;
-        exitCode: number;
-    }>;
-    glob(pattern: string): Promise<string[]>;
-    grep(pattern: string, path?: string): Promise<Array<{
-        file: string;
-        line: number;
-        text: string;
-    }>>;
-}
-/**
- * Host-provided REPL execution backend.
- */
-export interface ReplToolDeps {
-    /**
-     * Execute JavaScript code within a persistent VM context.
-     * The VM is pre-initialized with the primitive functions above.
-     * Each tool invocation reuses the same VM (preserving variable state).
-     */
-    executeInVm(code: string): Promise<ReplExecResult>;
-    /**
-     * Reset the VM context (clear state). Optional hook called on errors.
-     */
-    resetVm?(): void;
-    /**
-     * The host-provided primitives injected into the VM.
-     * When provided, the tool validates that the host has set up all required primitives.
-     */
-    primitives?: ReplPrimitives;
-    /**
-     * Permission check for individual primitive operations.
-     * Called before each primitive executes inside the VM.
-     * Returns null if allowed, or an error message if denied.
-     */
-    checkPermission?(operation: string, args: unknown[]): Promise<string | null>;
-}
-/** Tool names that should be hidden from direct LLM access when REPL is active. */
-export declare const REPL_HIDES_TOOLS: readonly string[];
-export declare function createReplTool(deps: ReplToolDeps): PortableTool<ReplToolParams>;

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

@@ -1,112 +0,0 @@
-import type { PortableTool } from "../portable-tool.js";
-export declare const SEARCH_TOOL_NAME: "search";
-export type SearchMode = "filename" | "content" | "both";
-export interface SearchToolParams {
-    mode: SearchMode;
-    pattern: string;
-    path?: string;
-    fileGlob?: string;
-    contextLines?: number;
-    caseInsensitive?: boolean;
-    headLimit?: number;
-    offset?: number;
-}
-export declare const SEARCH_TOOL_SCHEMA: {
-    readonly type: "object";
-    readonly properties: {
-        readonly mode: {
-            readonly type: "string";
-            readonly enum: readonly ["filename", "content", "both"];
-            readonly description: string;
-        };
-        readonly pattern: {
-            readonly type: "string";
-            readonly description: string;
-        };
-        readonly path: {
-            readonly type: "string";
-            readonly description: "Directory to search in. Defaults to workdir/cwd if omitted.";
-        };
-        readonly fileGlob: {
-            readonly type: "string";
-            readonly description: string;
-        };
-        readonly contextLines: {
-            readonly type: "number";
-            readonly description: string;
-        };
-        readonly caseInsensitive: {
-            readonly type: "boolean";
-            readonly description: "Case insensitive search (content/both modes). Default: false.";
-        };
-        readonly headLimit: {
-            readonly type: "number";
-            readonly description: string;
-        };
-        readonly offset: {
-            readonly type: "number";
-            readonly description: "Skip first N results before applying headLimit. Default: 0.";
-        };
-    };
-    readonly required: readonly ["mode", "pattern"];
-};
-export interface SearchFileResult {
-    path: string;
-}
-export interface SearchContentResult {
-    path: string;
-    line: number;
-    text: string;
-    contextBefore?: string[];
-    contextAfter?: string[];
-}
-export interface SearchOutput {
-    mode: SearchMode;
-    totalMatches: number;
-    truncated: boolean;
-    fileResults?: SearchFileResult[];
-    contentResults?: SearchContentResult[];
-}
-/** Host-provided search backend. */
-export interface SearchToolDeps {
-    /**
-     * Find files matching a glob pattern.
-     * Returns array of relative file paths.
-     * The host SHOULD auto-exclude VCS directories (.git, .svn, .hg, .bzr)
-     * unless the user explicitly includes them.
-     */
-    glob(pattern: string, options: {
-        cwd: string;
-        limit: number;
-    }): Promise<{
-        files: string[];
-        truncated: boolean;
-    }>;
-    /**
-     * Search file contents using regex.
-     * The implementation may use ripgrep, native grep, or a custom engine.
-     * Returns match records.
-     * The host SHOULD auto-exclude VCS directories (.git, .svn, .hg, .bzr)
-     * and enforce --max-columns 500 to avoid minified file noise.
-     */
-    grep(pattern: string, options: {
-        cwd: string;
-        fileGlob?: string;
-        caseInsensitive?: boolean;
-        contextLines?: number;
-        headLimit?: number;
-        offset?: number;
-    }): Promise<{
-        matches: Array<{
-            path: string;
-            line: number;
-            text: string;
-            contextBefore?: string[];
-            contextAfter?: string[];
-        }>;
-        truncated: boolean;
-    }>;
-    /** Resolve relative path to absolute. If omitted, cwd is used. */
-    resolvePath?(input: string): string;
-}
-export declare function createSearchTool(deps: SearchToolDeps): PortableTool<SearchToolParams>;