qlogicagent 2.13.5 → 2.13.7

package/dist/skills/tools/petdex-create-tool.js

@@ -1,95 +0,0 @@
-import fs from "node:fs";
-import path from "node:path";
-import { forgePetdexAssetPackage } from "../../runtime/pet/petdex-forge-service.js";
-export const PETDEX_CREATE_TOOL_NAME = "petdex_create";
-export const PETDEX_CREATE_TOOL_SCHEMA = {
-    type: "object",
-    properties: {
-        name: {
-            type: "string",
-            description: "Short display name for the generated desktop pet. Defaults to a short name derived from description.",
-        },
-        description: {
-            type: "string",
-            description: "Canonical character description for the Petdex desktop pet.",
-        },
-        prompt: {
-            type: "string",
-            description: "Optional extra visual direction. The tool will embed it into a strict Petdex 8x9 atlas prompt.",
-        },
-        reference_image_url: {
-            type: "string",
-            description: "Optional publicly accessible HTTP/HTTPS reference image URL for image-to-image generation.",
-        },
-        base_spritesheet_path: {
-            type: "string",
-            description: "Optional existing spritesheet.webp path; used as the identity reference to regenerate the whole atlas while keeping the same character.",
-        },
-        output_dir: {
-            type: "string",
-            description: "Optional output directory. Defaults to the workspace Petdex asset output directory.",
-        },
-    },
-    required: ["description"],
-};
-export function createPetdexCreateTool(deps) {
-    return {
-        name: PETDEX_CREATE_TOOL_NAME,
-        label: "Petdex Create",
-        category: "media",
-        description: "Generate a canonical Petdex desktop pet asset package using the configured image model. " +
-            "The output is a .petdex package containing pet.json, spritesheet.webp, and validation.json. " +
-            "The atlas contract is strict: 1536x1872 WebP, 8 columns by 9 rows, 72 frames, 192x208 per frame. " +
-            "Use this instead of generic image_generate when the user asks to create a desktop pet, Petdex pet, pet sprite atlas, or pet asset package.",
-        parameters: PETDEX_CREATE_TOOL_SCHEMA,
-        searchHint: "create Petdex pet sprite atlas package 8x9 72 frames desktop pet",
-        execute: async (_toolCallId, params) => {
-            const description = params.description?.trim();
-            if (!description)
-                throw new Error("description is required");
-            const outputDir = deps.resolveOutputDir(params.output_dir);
-            const result = await forgePetdexAssetPackage({
-                input: {
-                    name: normalizeName(params.name, description),
-                    description,
-                    prompt: params.prompt?.trim() || description,
-                    referenceImageUrl: params.reference_image_url?.trim() || undefined,
-                    referenceMode: params.base_spritesheet_path ? "refine" : params.reference_image_url ? "identity" : undefined,
-                    baseSpritesheet: params.base_spritesheet_path ? fs.readFileSync(params.base_spritesheet_path) : undefined,
-                },
-                outputDir,
-                generateImage: deps.generateImage,
-                uploadReferenceImage: deps.uploadReferenceImage,
-            });
-            return {
-                content: [{
-                        type: "text",
-                        text: `Generated Petdex asset package ${path.basename(result.packagePath)} (${result.asset.id}).`,
-                    }],
-                imageUrls: [result.spritesheetPath],
-                details: {
-                    type: "petdex_create",
-                    assetId: result.asset.id,
-                    name: result.asset.name,
-                    description: result.asset.description,
-                    packagePath: result.packagePath,
-                    assetDir: result.assetDir,
-                    manifestPath: result.manifestPath,
-                    spritesheetPath: result.spritesheetPath,
-                    validationPath: result.validationPath,
-                    productionRunPath: result.productionRunPath,
-                    productionRun: result.productionRun,
-                    atlas: result.asset.atlas,
-                    animations: result.asset.animations,
-                    model: result.model,
-                    size: result.size,
-                    durationMs: result.durationMs,
-                },
-            };
-        },
-    };
-}
-function normalizeName(name, description) {
-    const candidate = name?.trim() || description.trim().split(/\s+/).slice(0, 3).join(" ");
-    return candidate.slice(0, 32) || "Petdex Pet";
-}

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

@@ -1,98 +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;
-    /**
-     * Semantic permissions to request on exit (CC ExitPlanModeV2 parity).
-     * Each entry describes a tool + intent the agent wants permission for.
-     */
-    allowedPrompts?: Array<{
-        tool: string;
-        prompt: 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 allowedPrompts: {
-            readonly type: "array";
-            readonly description: string;
-            readonly items: {
-                readonly type: "object";
-                readonly properties: {
-                    readonly tool: {
-                        readonly type: "string";
-                        readonly description: "Tool name to pre-approve.";
-                    };
-                    readonly prompt: {
-                        readonly type: "string";
-                        readonly description: "Intent description for this permission.";
-                    };
-                };
-                readonly required: readonly ["tool", "prompt"];
-            };
-        };
-    };
-    readonly required: readonly ["action"];
-};
-/** Tools allowed during plan mode (read-only + reasoning + task tracking) */
-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;
-    /**
-     * Request approval for the plan from the user/coordinator.
-     * CC parity: ExitPlanModeV2 triggers an approval dialog on exit.
-     * Returns true if approved, false if rejected.
-     */
-    requestPlanApproval?(plan: string, allowedPrompts?: Array<{
-        tool: string;
-        prompt: string;
-    }>): Promise<boolean>;
-    /**
-     * Persist plan to disk (CC parity: plan is saved to planFilePath).
-     */
-    persistPlan?(plan: string, filePath: string): Promise<void>;
-}
-export declare function createPlanModeTool(deps: PlanModeToolDeps): PortableTool<PlanModeToolParams>;

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

@@ -1,164 +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 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.",
-        },
-        allowedPrompts: {
-            type: "array",
-            description: "Semantic permissions to request on exit. Each entry describes a tool and intent " +
-                "the agent wants pre-approved (e.g. {tool:'exec', prompt:'run tests'}).",
-            items: {
-                type: "object",
-                properties: {
-                    tool: { type: "string", description: "Tool name to pre-approve." },
-                    prompt: { type: "string", description: "Intent description for this permission." },
-                },
-                required: ["tool", "prompt"],
-            },
-        },
-    },
-    required: ["action"],
-};
-/** Tools allowed during plan mode (read-only + reasoning + task tracking) */
-export const PLAN_MODE_ALLOWED_TOOLS = [
-    "read",
-    "search",
-    "task",
-    "lsp",
-    "web_search",
-    "web_fetch",
-    "memory",
-    "skill",
-    "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, 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" },
-                        };
-                    }
-                    // Persist plan to disk if path provided (CC parity)
-                    if (params.plan && params.planFilePath && deps.persistPlan) {
-                        try {
-                            await deps.persistPlan(params.plan, params.planFilePath);
-                        }
-                        catch {
-                            // Non-fatal — continue with exit
-                        }
-                    }
-                    // Request plan approval from user/coordinator (CC ExitPlanModeV2 parity)
-                    if (params.plan && deps.requestPlanApproval) {
-                        const approved = await deps.requestPlanApproval(params.plan, params.allowedPrompts);
-                        if (!approved) {
-                            return {
-                                content: [{ type: "text", text: "Plan was not approved. Remaining in plan mode. Refine the plan and try again." }],
-                                details: { type: "plan_mode", action: "exit", approved: false },
-                            };
-                        }
-                    }
-                    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("", "Approved plan:", "", params.plan);
-                    }
-                    if (params.allowedPrompts?.length) {
-                        lines.push("", "Pre-approved permissions:");
-                        for (const ap of params.allowedPrompts) {
-                            lines.push(`  - ${ap.tool}: ${ap.prompt}`);
-                        }
-                    }
-                    return {
-                        content: [{ type: "text", text: lines.join("\n") }],
-                        details: {
-                            type: "plan_mode",
-                            action: "exit",
-                            hasPlan: !!params.plan,
-                            approved: true,
-                            allowedPrompts: params.allowedPrompts,
-                        },
-                    };
-                }
-                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, image path for images, or rejection. */
-    readFile(path: string): Promise<{
-        type: "text";
-        text: string;
-    } | {
-        type: "image";
-        localPath: 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,88 +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,
-        isReadOnly: true,
-        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 — return as imageUrl reference for transport-layer resolution.
-            // The transport's FileUploadAdapter handles upload to provider API.
-            // No base64 in memory — supports images of any size.
-            if (result.type === "image") {
-                return {
-                    content: [{ type: "text", text: `[Image: ${resolved}] (${result.mimeType})` }],
-                    details: { type: "read", path: resolved, isImage: true },
-                    imageUrls: [result.localPath],
-                };
-            }
-            // 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/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 enforcemax-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>;