qlogicagent 0.2.1 → 0.3.0

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

@@ -1,153 +0,0 @@
-// ============================================================
-// Skill Manage Tool — create/edit/delete skills.
-// Reference: hermes-agent-2026.4.30/tools/skill_manager_tool.py
-// Category: skill
-// ============================================================
-export const SKILL_MANAGE_TOOL_NAME = "skill_manage";
-export const SKILL_MANAGE_TOOL_SCHEMA = {
-    type: "object",
-    properties: {
-        action: {
-            type: "string",
-            enum: ["create", "edit", "patch", "delete", "write_file", "remove_file"],
-            description: "Action to perform: create (new skill), edit (overwrite SKILL.md), " +
-                "patch (find/replace in SKILL.md), delete (remove skill), " +
-                "write_file (add/overwrite supporting file), remove_file (delete supporting file).",
-        },
-        name: {
-            type: "string",
-            description: "Skill name (lowercase, max 64 chars, kebab-case: letters, digits, hyphens).",
-        },
-        content: {
-            type: "string",
-            description: "Full SKILL.md content (YAML frontmatter + body). Required for create/edit. " +
-                "Max 100,000 chars. Must include ---\\nname: ...\\ndescription: ...\\n--- header.",
-        },
-        category: {
-            type: "string",
-            description: "Category/domain (e.g. 'devops', 'mlops'). Used by create to organize skills.",
-        },
-        filePath: {
-            type: "string",
-            description: "Path within the skill for write_file/remove_file. " +
-                "Must be in references/, templates/, scripts/, or assets/ subdirectory.",
-        },
-        fileContent: {
-            type: "string",
-            description: "Content for write_file action. Max 1 MiB.",
-        },
-        oldString: {
-            type: "string",
-            description: "Text to find for patch action (must match uniquely in SKILL.md).",
-        },
-        newString: {
-            type: "string",
-            description: "Replacement text for patch action (can be empty to delete).",
-        },
-    },
-    required: ["action", "name"],
-};
-const NAME_PATTERN = /^[a-z0-9][a-z0-9._-]{0,63}$/;
-const MAX_CONTENT_LENGTH = 100_000;
-const MAX_FILE_CONTENT_LENGTH = 1_048_576; // 1 MiB
-const ALLOWED_FILE_DIRS = ["references/", "templates/", "scripts/", "assets/"];
-export function createSkillManageTool(deps) {
-    return {
-        name: SKILL_MANAGE_TOOL_NAME,
-        label: "Manage Skills",
-        description: "Create, edit, patch, or delete skills. Skills are reusable workflows/knowledge packages " +
-            "that can be discovered and invoked. Supports managing supporting files (references, templates).",
-        parameters: SKILL_MANAGE_TOOL_SCHEMA,
-        execute: async (_toolCallId, params) => {
-            // Validate name
-            const nameError = deps.validateName
-                ? deps.validateName(params.name)
-                : validateNameBuiltin(params.name);
-            if (nameError) {
-                return {
-                    content: [{ type: "text", text: `Error: ${nameError}` }],
-                    details: { type: "skill_manage", error: "invalid_name" },
-                };
-            }
-            // Action-specific validation
-            const validationError = validateAction(params);
-            if (validationError) {
-                return {
-                    content: [{ type: "text", text: `Error: ${validationError}` }],
-                    details: { type: "skill_manage", error: "validation_failed" },
-                };
-            }
-            const result = await deps.manageSkill(params);
-            return {
-                content: [{ type: "text", text: result.message }],
-                details: {
-                    type: "skill_manage",
-                    action: params.action,
-                    name: params.name,
-                    success: result.success,
-                    path: result.path,
-                },
-            };
-        },
-    };
-}
-function validateNameBuiltin(name) {
-    if (!name)
-        return "name is required.";
-    if (!NAME_PATTERN.test(name)) {
-        return "name must be lowercase, start with letter/digit, contain only letters, digits, hyphens, dots, underscores (max 64 chars).";
-    }
-    return null;
-}
-function validateAction(params) {
-    switch (params.action) {
-        case "create":
-        case "edit":
-            if (!params.content)
-                return `content is required for ${params.action}.`;
-            if (params.content.length > MAX_CONTENT_LENGTH) {
-                return `content exceeds max length (${MAX_CONTENT_LENGTH} chars).`;
-            }
-            if (!params.content.includes("---")) {
-                return "content must include YAML frontmatter (--- delimiters).";
-            }
-            break;
-        case "patch":
-            if (!params.oldString)
-                return "oldString is required for patch.";
-            if (params.newString === undefined)
-                return "newString is required for patch (can be empty to delete).";
-            break;
-        case "write_file":
-            if (!params.filePath)
-                return "filePath is required for write_file.";
-            if (!params.fileContent)
-                return "fileContent is required for write_file.";
-            if (params.fileContent.length > MAX_FILE_CONTENT_LENGTH) {
-                return "fileContent exceeds max length (1 MiB).";
-            }
-            if (!ALLOWED_FILE_DIRS.some((d) => params.filePath.startsWith(d))) {
-                return `filePath must be in one of: ${ALLOWED_FILE_DIRS.join(", ")}`;
-            }
-            if (params.filePath.includes("..")) {
-                return "filePath must not contain path traversal (..).";
-            }
-            break;
-        case "remove_file":
-            if (!params.filePath)
-                return "filePath is required for remove_file.";
-            if (!ALLOWED_FILE_DIRS.some((d) => params.filePath.startsWith(d))) {
-                return `filePath must be in one of: ${ALLOWED_FILE_DIRS.join(", ")}`;
-            }
-            if (params.filePath.includes("..")) {
-                return "filePath must not contain path traversal (..).";
-            }
-            break;
-        case "delete":
-            // No extra validation needed
-            break;
-        default:
-            return `unknown action: ${params.action}`;
-    }
-    return null;
-}

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

@@ -1,72 +0,0 @@
-// ============================================================
-// Skill View Tool — view full skill content.
-// Reference: hermes-agent-2026.4.30/tools/skills_tool.py (skill_view)
-// Category: skill
-// ============================================================
-export const SKILL_VIEW_TOOL_NAME = "skill_view";
-export const SKILL_VIEW_TOOL_SCHEMA = {
-    type: "object",
-    properties: {
-        name: {
-            type: "string",
-            description: "Skill name to view (e.g. 'code-review', 'deploy-ecs').",
-        },
-        filePath: {
-            type: "string",
-            description: "Optional: view a specific file within the skill (e.g. 'references/api.md'). " +
-                "Omit to view the main SKILL.md.",
-        },
-    },
-    required: ["name"],
-};
-export function createSkillViewTool(deps) {
-    return {
-        name: SKILL_VIEW_TOOL_NAME,
-        label: "View Skill",
-        description: "View the full content of a skill (instructions, configuration, reference files). " +
-            "Use skill_list to discover available skills first.",
-        parameters: SKILL_VIEW_TOOL_SCHEMA,
-        execute: async (_toolCallId, params) => {
-            if (!params.name || params.name.trim().length === 0) {
-                return {
-                    content: [{ type: "text", text: "Error: skill name is required." }],
-                    details: { type: "skill_view", error: "empty_name" },
-                };
-            }
-            const result = await deps.viewSkill(params.name.trim(), params.filePath);
-            if (!result) {
-                return {
-                    content: [{
-                            type: "text",
-                            text: `Skill "${params.name}" not found. Use skill_list to see available skills.`,
-                        }],
-                    details: { type: "skill_view", error: "not_found", name: params.name },
-                };
-            }
-            const lines = [];
-            if (params.filePath) {
-                lines.push(`## ${result.name} / ${params.filePath}`);
-            }
-            else {
-                lines.push(`## Skill: ${result.name}`);
-                if (result.tags && result.tags.length > 0) {
-                    lines.push(`Tags: ${result.tags.join(", ")}`);
-                }
-                if (result.referenceFiles && result.referenceFiles.length > 0) {
-                    lines.push(`Reference files: ${result.referenceFiles.join(", ")}`);
-                }
-            }
-            lines.push("");
-            lines.push(result.content);
-            return {
-                content: [{ type: "text", text: lines.join("\n") }],
-                details: {
-                    type: "skill_view",
-                    name: result.name,
-                    filePath: params.filePath,
-                    referenceFiles: result.referenceFiles,
-                },
-            };
-        },
-    };
-}

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

@@ -1,81 +0,0 @@
-// ============================================================
-// Sleep Tool — lightweight wait with tick/interrupt support.
-// Reference: claude-code-haha/src/tools/SleepTool/prompt.ts
-// Category: autonomous / proactive mode
-// ============================================================
-export const SLEEP_TOOL_NAME = "sleep";
-export const SLEEP_TOOL_SCHEMA = {
-    type: "object",
-    properties: {
-        duration: {
-            type: "number",
-            description: "Duration to sleep in seconds (1–3600). Prefer short sleeps (10–60s) to stay responsive.",
-            minimum: 1,
-            maximum: 3600,
-        },
-        reason: {
-            type: "string",
-            description: "Brief reason for sleeping. Examples: \"waiting for build to finish\", " +
-                "\"nothing to do\", \"user asked to rest\".",
-        },
-    },
-    required: ["duration"],
-};
-export function createSleepTool(deps) {
-    return {
-        name: SLEEP_TOOL_NAME,
-        label: "Sleep",
-        shouldDefer: true,
-        isConcurrencySafe: true,
-        isReadOnly: true,
-        searchHint: "wait sleep rest idle tick proactive",
-        description: [
-            "Wait for a specified duration. The user can interrupt the sleep at any time.",
-            "",
-            "Use this when:",
-            "• You have nothing useful to do right now",
-            "• You're waiting for an external process to complete",
-            "• The user tells you to sleep or rest",
-            "• You receive a <tick> check-in with no actionable work",
-            "",
-            "Prefer this over `exec(sleep ...)` — it doesn't hold a shell process.",
-            "You can call this concurrently with other tools — it won't interfere with them.",
-            "",
-            "Each wake-up costs an API call, but the prompt cache expires after 5 minutes " +
-                "of inactivity — balance accordingly.",
-        ].join("\n"),
-        parameters: SLEEP_TOOL_SCHEMA,
-        execute: async (_toolCallId, params, signal) => {
-            const durationSec = Math.max(1, Math.min(3600, Math.round(params.duration)));
-            const durationMs = durationSec * 1000;
-            // Create a child AbortController so we can forward the outer signal
-            const controller = new AbortController();
-            const onAbort = () => controller.abort();
-            signal?.addEventListener("abort", onAbort, { once: true });
-            // Handle pre-aborted signal
-            if (signal?.aborted)
-                controller.abort();
-            try {
-                const result = await deps.sleep(durationMs, controller.signal);
-                const lines = [];
-                if (result.interrupted) {
-                    lines.push(`Sleep interrupted after ${result.sleptSeconds}s.`);
-                    if (result.interruptReason) {
-                        lines.push(`Reason: ${result.interruptReason}`);
-                    }
-                    lines.push("Check for new messages or tasks.");
-                }
-                else {
-                    lines.push(`Slept for ${result.sleptSeconds}s. Waking up.`);
-                }
-                return {
-                    content: [{ type: "text", text: lines.join("\n") }],
-                    details: { ...result, requestedSeconds: durationSec },
-                };
-            }
-            finally {
-                signal?.removeEventListener("abort", onAbort);
-            }
-        },
-    };
-}

package/dist/skills/tools/structured-output-tool.js

@@ -1,176 +0,0 @@
-// ============================================================
-// Structured Output Tool — validated JSON schema output for
-// non-interactive (SDK/API) sessions.
-// Reference: claude-code-haha/src/tools/SyntheticOutputTool/SyntheticOutputTool.ts
-// Category: output / structured
-// ============================================================
-export const STRUCTURED_OUTPUT_TOOL_NAME = "structured_output";
-/** Maximum content size for structured output results. */
-export const STRUCTURED_OUTPUT_MAX_CHARS = 100_000;
-/**
- * Base schema — accepts any object.
- * When used with createConfiguredStructuredOutputTool, the host overrides
- * this with the actual JSON Schema from `response_format.json_schema`.
- */
-export const STRUCTURED_OUTPUT_TOOL_SCHEMA = {
-    type: "object",
-    properties: {
-        data: {
-            type: "object",
-            description: "The structured JSON data to return as this turn's output. " +
-                "Must conform to the output schema specified for this session.",
-            additionalProperties: true,
-        },
-    },
-    required: ["data"],
-};
-/**
- * Whether the structured output tool should be enabled for this session.
- * CC equivalent: `isSyntheticOutputToolEnabled`.
- */
-export function isStructuredOutputEnabled(opts) {
-    return opts.isNonInteractiveSession;
-}
-/**
- * Create the base structured output tool with DI-based validation.
- * This is the standard factory for runtime integration.
- */
-export function createStructuredOutputTool(deps) {
-    return {
-        name: STRUCTURED_OUTPUT_TOOL_NAME,
-        label: "Structured Output",
-        shouldDefer: false,
-        isConcurrencySafe: true,
-        isReadOnly: true,
-        searchHint: "return the final response as structured JSON",
-        maxResultSizeChars: STRUCTURED_OUTPUT_MAX_CHARS,
-        description: [
-            "Return your final response as structured JSON data.",
-            "",
-            "Use this tool ONLY when the session requests structured output (via response_format).",
-            "You MUST call this tool exactly once at the end of your response to provide the structured output.",
-            "The data you provide must conform to the output JSON Schema specified for this session.",
-            "",
-            "Rules:",
-            "• Call this exactly once at the end of your turn to deliver results",
-            "• The data must be a valid JSON object matching the required schema",
-            "• If validation fails, you'll see the errors — fix your data and try again",
-            "• This is typically the last tool call in a turn",
-        ].join("\n"),
-        parameters: STRUCTURED_OUTPUT_TOOL_SCHEMA,
-        execute: async (_toolCallId, params) => {
-            const schema = deps.getOutputSchema();
-            if (!schema) {
-                return {
-                    content: [{
-                            type: "text",
-                            text: "Error: No output schema configured for this session. " +
-                                "structured_output is only available when response_format.json_schema is specified.",
-                        }],
-                    details: { valid: false, error: "no_schema" },
-                };
-            }
-            const validation = deps.validateOutput(params.data);
-            if (!validation.valid) {
-                const errorLines = (validation.errors ?? []).map((e) => `  • ${e.path || "/"}: ${e.message}`);
-                return {
-                    content: [{
-                            type: "text",
-                            text: [
-                                "Output does not match required schema:",
-                                ...errorLines,
-                            ].join("\n"),
-                        }],
-                    details: { valid: false, errors: validation.errors },
-                };
-            }
-            // Validation passed — deliver the output
-            await deps.deliverOutput(params.data);
-            return {
-                content: [{ type: "text", text: "Structured output provided successfully." }],
-                details: { valid: true, structured_output: params.data },
-            };
-        },
-    };
-}
-/** WeakMap cache for compiled schema tools (mirrors CC's toolCache). */
-const configuredToolCache = new WeakMap();
-/**
- * Create a StructuredOutputTool configured with a specific JSON Schema.
- * Mirrors CC's `createSyntheticOutputTool(jsonSchema)`.
- *
- * Features:
- * - Validates the schema itself at creation time
- * - Compiles the validator for reuse (cached via WeakMap)
- * - Overrides the tool's `parameters` with the provided schema (dynamic input)
- * - Returns { tool } on success or { error } if schema is invalid
- *
- * @param jsonSchema  The JSON Schema to validate output against.
- * @param compiler    Schema compiler/validator provided by the host.
- * @param deliver     Output delivery function (called after successful validation).
- */
-export function createConfiguredStructuredOutputTool(jsonSchema, compiler, deliver) {
-    const cached = configuredToolCache.get(jsonSchema);
-    if (cached)
-        return cached;
-    const result = buildConfiguredTool(jsonSchema, compiler, deliver);
-    configuredToolCache.set(jsonSchema, result);
-    return result;
-}
-function buildConfiguredTool(jsonSchema, compiler, deliver) {
-    try {
-        // Step 1: Validate the schema itself
-        const schemaError = compiler.validateSchema(jsonSchema);
-        if (schemaError) {
-            return { error: `Invalid JSON Schema: ${schemaError}` };
-        }
-        // Step 2: Compile the validator
-        const validate = compiler.compile(jsonSchema);
-        // Step 3: Build the tool with dynamic input schema
-        const tool = {
-            name: STRUCTURED_OUTPUT_TOOL_NAME,
-            label: "Structured Output",
-            shouldDefer: false,
-            isConcurrencySafe: true,
-            isReadOnly: true,
-            searchHint: "return the final response as structured JSON",
-            maxResultSizeChars: STRUCTURED_OUTPUT_MAX_CHARS,
-            description: [
-                "Use this tool to return your final response in the requested structured format.",
-                "You MUST call this tool exactly once at the end of your response to provide the structured output.",
-            ].join(" "),
-            // Dynamic: override with the actual JSON Schema so LLM gets type guidance
-            parameters: {
-                type: "object",
-                properties: {
-                    data: jsonSchema,
-                },
-                required: ["data"],
-            },
-            execute: async (_toolCallId, params) => {
-                const validation = validate(params.data);
-                if (!validation.valid) {
-                    const errors = (validation.errors ?? [])
-                        .map((e) => `${e.path || "root"}: ${e.message}`)
-                        .join(", ");
-                    return {
-                        content: [{
-                                type: "text",
-                                text: `Output does not match required schema: ${errors}`,
-                            }],
-                        details: { valid: false, errors: validation.errors },
-                    };
-                }
-                await deliver(params.data);
-                return {
-                    content: [{ type: "text", text: "Structured output provided successfully." }],
-                    details: { valid: true, structured_output: params.data },
-                };
-            },
-        };
-        return { tool };
-    }
-    catch (e) {
-        return { error: e instanceof Error ? e.message : String(e) };
-    }
-}

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

@@ -1,161 +0,0 @@
-// ============================================================
-// Task Tool — background agent task management (CRUD + output).
-// Reference: claude-code-haha/src/tools/TaskCreateTool/TaskCreateTool.ts
-//            claude-code-haha/src/tools/TaskGetTool/TaskGetTool.ts
-//            claude-code-haha/src/tools/TaskListTool/TaskListTool.ts
-//            claude-code-haha/src/tools/TaskOutputTool/TaskOutputTool.tsx
-//            claude-code-haha/src/tools/TaskStopTool/TaskStopTool.ts
-// Category: system
-// ============================================================
-export const TASK_TOOL_NAME = "task";
-export const TASK_TOOL_SCHEMA = {
-    type: "object",
-    properties: {
-        action: {
-            type: "string",
-            enum: ["create", "get", "list", "output", "stop"],
-            description: "Action to perform:\n" +
-                "- create: Spawn a new background agent task\n" +
-                "- get: Get task status and metadata by ID\n" +
-                "- list: List all tasks with their statuses\n" +
-                "- output: Get stdout/output from a running or completed task\n" +
-                "- stop: Terminate a running task",
-        },
-        taskId: {
-            type: "string",
-            description: "Task ID. Required for get/output/stop.",
-        },
-        prompt: {
-            type: "string",
-            description: "Detailed prompt for the background agent. Must contain all context needed " +
-                "to complete the task independently. Required for create.",
-        },
-        description: {
-            type: "string",
-            description: "Short (3-7 word) description of the task. Used for tracking and display.",
-        },
-        allowedTools: {
-            type: "array",
-            items: { type: "string" },
-            description: "Restrict background agent to only these tools. If omitted, inherits parent's tools.",
-        },
-        cwd: {
-            type: "string",
-            description: "Working directory for the background task (absolute path).",
-        },
-        model: {
-            type: "string",
-            description: "Model override for the task agent (e.g. 'sonnet', 'opus').",
-        },
-        maxLines: {
-            type: "number",
-            description: "Max output lines to return for the 'output' action (default: 100).",
-            minimum: 1,
-            maximum: 2000,
-        },
-    },
-    required: ["action"],
-};
-const DEFAULT_MAX_LINES = 100;
-export function createTaskTool(deps) {
-    return {
-        name: TASK_TOOL_NAME,
-        label: "Task",
-        shouldDefer: true,
-        description: "Manage background agent tasks. Use this to spawn long-running tasks (image generation, " +
-            "code refactoring, research) that run independently while you continue working. " +
-            "Actions: create (spawn), get (status check), list (all tasks), output (logs), stop (terminate).",
-        parameters: TASK_TOOL_SCHEMA,
-        execute: async (_toolCallId, params) => {
-            switch (params.action) {
-                case "create": {
-                    if (!params.prompt || params.prompt.trim().length < 10) {
-                        return {
-                            content: [{ type: "text", text: "Error: 'prompt' is required for create (min 10 chars)." }],
-                        };
-                    }
-                    const task = await deps.createTask({
-                        prompt: params.prompt.trim(),
-                        description: params.description,
-                        allowedTools: params.allowedTools,
-                        cwd: params.cwd,
-                        model: params.model,
-                    });
-                    return {
-                        content: [{
-                                type: "text",
-                                text: [
-                                    `Task created successfully.`,
-                                    `ID: ${task.taskId}`,
-                                    `Status: ${task.status}`,
-                                    task.description ? `Description: ${task.description}` : "",
-                                ].filter(Boolean).join("\n"),
-                            }],
-                        details: { type: "task", action: "create", taskId: task.taskId, status: task.status },
-                    };
-                }
-                case "get": {
-                    if (!params.taskId) {
-                        return { content: [{ type: "text", text: "Error: 'taskId' is required for get." }] };
-                    }
-                    const task = await deps.getTask(params.taskId);
-                    if (!task) {
-                        return { content: [{ type: "text", text: `Error: task "${params.taskId}" not found.` }] };
-                    }
-                    const lines = [
-                        `Task: ${task.taskId}`,
-                        `Status: ${task.status}`,
-                        task.description ? `Description: ${task.description}` : "",
-                        `Created: ${new Date(task.createdAt).toISOString()}`,
-                        task.completedAt ? `Completed: ${new Date(task.completedAt).toISOString()}` : "",
-                        task.result ? `Result: ${task.result.slice(0, 500)}` : "",
-                        task.error ? `Error: ${task.error}` : "",
-                    ];
-                    return {
-                        content: [{ type: "text", text: lines.filter(Boolean).join("\n") }],
-                        details: { type: "task", action: "get", task },
-                    };
-                }
-                case "list": {
-                    const tasks = await deps.listTasks();
-                    if (tasks.length === 0) {
-                        return { content: [{ type: "text", text: "No tasks found." }] };
-                    }
-                    const lines = tasks.map(t => {
-                        const icon = t.status === "completed" ? "✅" :
-                            t.status === "running" ? "🔄" :
-                                t.status === "failed" ? "❌" :
-                                    t.status === "stopped" ? "⏹️" : "⏳";
-                        return `${icon} [${t.taskId}] ${t.description || "(no description)"} — ${t.status}`;
-                    });
-                    return {
-                        content: [{ type: "text", text: `Tasks (${tasks.length}):\n${lines.join("\n")}` }],
-                        details: { type: "task", action: "list", count: tasks.length },
-                    };
-                }
-                case "output": {
-                    if (!params.taskId) {
-                        return { content: [{ type: "text", text: "Error: 'taskId' is required for output." }] };
-                    }
-                    const output = await deps.getTaskOutput(params.taskId, params.maxLines ?? DEFAULT_MAX_LINES);
-                    return {
-                        content: [{ type: "text", text: output || "(no output yet)" }],
-                        details: { type: "task", action: "output", taskId: params.taskId },
-                    };
-                }
-                case "stop": {
-                    if (!params.taskId) {
-                        return { content: [{ type: "text", text: "Error: 'taskId' is required for stop." }] };
-                    }
-                    const stopped = await deps.stopTask(params.taskId);
-                    return {
-                        content: [{ type: "text", text: stopped ? `Task ${params.taskId} stopped.` : `Failed to stop task ${params.taskId} (may already be completed).` }],
-                        details: { type: "task", action: "stop", taskId: params.taskId, stopped },
-                    };
-                }
-                default:
-                    return { content: [{ type: "text", text: `Error: unknown action "${params.action}". Use: create/get/list/output/stop.` }] };
-            }
-        },
-    };
-}