qlogicagent 2.13.3 → 2.13.5

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

@@ -0,0 +1,153 @@
+import type { PortableTool } from "../portable-tool.js";
+export declare const LSP_TOOL_NAME: "lsp";
+export type LspOperation = "goToDefinition" | "findReferences" | "hover" | "documentSymbol" | "diagnostics" | "completion" | "signatureHelp" | "rename" | "codeAction";
+export interface LspToolParams {
+    /** LSP operation to perform */
+    operation: LspOperation;
+    /** File path (absolute or relative to workspace root) */
+    filePath: string;
+    /** Line number (1-indexed) */
+    line?: number;
+    /** Character position (1-indexed) */
+    character?: number;
+    /** New name (for rename operation) */
+    newName?: string;
+    /** Include context lines around results */
+    includeContext?: boolean;
+}
+export declare const LSP_TOOL_SCHEMA: {
+    readonly type: "object";
+    readonly properties: {
+        readonly operation: {
+            readonly type: "string";
+            readonly enum: readonly ["goToDefinition", "findReferences", "hover", "documentSymbol", "diagnostics", "completion", "signatureHelp", "rename", "codeAction"];
+            readonly description: string;
+        };
+        readonly filePath: {
+            readonly type: "string";
+            readonly description: "File path. Absolute or relative to workspace root.";
+        };
+        readonly line: {
+            readonly type: "number";
+            readonly description: "Line number (1-indexed). Required for positional operations.";
+        };
+        readonly character: {
+            readonly type: "number";
+            readonly description: "Character position (1-indexed). Required for positional operations.";
+        };
+        readonly newName: {
+            readonly type: "string";
+            readonly description: "New name for rename operation.";
+        };
+        readonly includeContext: {
+            readonly type: "boolean";
+            readonly description: "Include surrounding code context in results (default: true).";
+        };
+    };
+    readonly required: readonly ["operation", "filePath"];
+};
+export interface LspLocation {
+    filePath: string;
+    line: number;
+    character: number;
+    endLine?: number;
+    endCharacter?: number;
+    context?: string;
+}
+export interface LspSymbol {
+    name: string;
+    kind: string;
+    range: {
+        startLine: number;
+        endLine: number;
+    };
+    children?: LspSymbol[];
+}
+export interface LspDiagnostic {
+    message: string;
+    severity: "error" | "warning" | "info" | "hint";
+    line: number;
+    character: number;
+    source?: string;
+    code?: string | number;
+}
+export interface LspHoverInfo {
+    contents: string;
+    range?: {
+        startLine: number;
+        startCharacter: number;
+        endLine: number;
+        endCharacter: number;
+    };
+}
+export interface LspCompletion {
+    label: string;
+    kind: string;
+    detail?: string;
+    insertText?: string;
+}
+export interface LspRenameEdit {
+    filePath: string;
+    edits: Array<{
+        line: number;
+        character: number;
+        endLine: number;
+        endCharacter: number;
+        newText: string;
+    }>;
+}
+export interface LspCodeAction {
+    title: string;
+    kind?: string;
+    isPreferred?: boolean;
+}
+export type LspResult = {
+    type: "locations";
+    locations: LspLocation[];
+} | {
+    type: "symbols";
+    symbols: LspSymbol[];
+} | {
+    type: "diagnostics";
+    diagnostics: LspDiagnostic[];
+} | {
+    type: "hover";
+    hover: LspHoverInfo | null;
+} | {
+    type: "completions";
+    completions: LspCompletion[];
+} | {
+    type: "rename";
+    edits: LspRenameEdit[];
+} | {
+    type: "codeActions";
+    actions: LspCodeAction[];
+} | {
+    type: "signatureHelp";
+    signatures: string[];
+};
+/**
+ * Host-provided LSP backend.
+ * The host manages language server lifecycle and connections.
+ */
+export interface LspToolDeps {
+    /** Execute an LSP operation. Host dispatches to appropriate language server. */
+    executeOperation(params: {
+        operation: LspOperation;
+        filePath: string;
+        line?: number;
+        character?: number;
+        newName?: string;
+        includeContext?: boolean;
+    }): Promise<LspResult>;
+    /** Check if file exists and get its size */
+    statFile?(filePath: string): Promise<{
+        exists: boolean;
+        size: number;
+    } | null>;
+    /** Resolve relative path to absolute */
+    resolvePath(filePath: string): string;
+    /** List supported language IDs (e.g. ['typescript', 'python', 'rust']) */
+    supportedLanguages?(): string[];
+}
+export declare function createLspTool(deps: LspToolDeps): PortableTool<LspToolParams>;

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

@@ -0,0 +1,230 @@
+// ============================================================
+// LSP Tool — Language Server Protocol code intelligence.
+// Reference: claude-code-haha/src/tools/LSPTool/LSPTool.ts
+// Category: coding (read-only)
+// ============================================================
+export const LSP_TOOL_NAME = "lsp";
+export const LSP_TOOL_SCHEMA = {
+    type: "object",
+    properties: {
+        operation: {
+            type: "string",
+            enum: [
+                "goToDefinition",
+                "findReferences",
+                "hover",
+                "documentSymbol",
+                "diagnostics",
+                "completion",
+                "signatureHelp",
+                "rename",
+                "codeAction",
+            ],
+            description: "LSP operation:\n" +
+                "- goToDefinition: jump to symbol definition\n" +
+                "- findReferences: find all usages of a symbol\n" +
+                "- hover: get type/docs for symbol at position\n" +
+                "- documentSymbol: list all symbols in file (classes, functions, etc)\n" +
+                "- diagnostics: get errors/warnings for a file\n" +
+                "- completion: get completions at position\n" +
+                "- signatureHelp: get function signature at call site\n" +
+                "- rename: preview rename of symbol\n" +
+                "- codeAction: get available quick-fixes/refactorings",
+        },
+        filePath: {
+            type: "string",
+            description: "File path. Absolute or relative to workspace root.",
+        },
+        line: {
+            type: "number",
+            description: "Line number (1-indexed). Required for positional operations.",
+        },
+        character: {
+            type: "number",
+            description: "Character position (1-indexed). Required for positional operations.",
+        },
+        newName: {
+            type: "string",
+            description: "New name for rename operation.",
+        },
+        includeContext: {
+            type: "boolean",
+            description: "Include surrounding code context in results (default: true).",
+        },
+    },
+    required: ["operation", "filePath"],
+};
+// ── Dependencies ────────────────────────────────────────────
+const MAX_FILE_SIZE = 10 * 1024 * 1024; // 10MB
+// Positional operations require line and character
+const POSITIONAL_OPS = [
+    "goToDefinition",
+    "findReferences",
+    "hover",
+    "completion",
+    "signatureHelp",
+    "rename",
+    "codeAction",
+];
+export function createLspTool(deps) {
+    return {
+        name: LSP_TOOL_NAME,
+        label: "LSP",
+        category: "developer",
+        shouldDefer: true,
+        searchHint: "lsp definition references hover diagnostics completion rename code-intelligence 跳转定义 找引用 代码诊断 补全 重命名",
+        description: "Query language servers for code intelligence. Supports go-to-definition, find-references, " +
+            "hover (type info), document symbols, diagnostics (errors/warnings), completions, " +
+            "signature help, rename preview, and code actions. Read-only — does not modify files.",
+        parameters: LSP_TOOL_SCHEMA,
+        execute: async (_toolCallId, params) => {
+            if (!params.filePath || params.filePath.trim().length === 0) {
+                return {
+                    content: [{ type: "text", text: "Error: filePath is required." }],
+                    details: { type: "lsp", error: "missing_filePath" },
+                };
+            }
+            // Block UNC paths (NTLM credential leak risk on Windows)
+            if (params.filePath.startsWith("\\\\") || params.filePath.startsWith("//")) {
+                return {
+                    content: [{ type: "text", text: "Error: UNC paths are not allowed." }],
+                    details: { type: "lsp", error: "unc_blocked" },
+                };
+            }
+            // Validate positional params
+            if (POSITIONAL_OPS.includes(params.operation)) {
+                if (params.line == null || params.character == null) {
+                    return {
+                        content: [{ type: "text", text: `Error: line and character are required for ${params.operation}.` }],
+                        details: { type: "lsp", error: "missing_position" },
+                    };
+                }
+                if (params.line < 1 || params.character < 1) {
+                    return {
+                        content: [{ type: "text", text: "Error: line and character must be ≥ 1." }],
+                        details: { type: "lsp", error: "invalid_position" },
+                    };
+                }
+            }
+            // Rename requires newName
+            if (params.operation === "rename" && !params.newName) {
+                return {
+                    content: [{ type: "text", text: "Error: newName is required for rename operation." }],
+                    details: { type: "lsp", error: "missing_newName" },
+                };
+            }
+            const resolved = deps.resolvePath(params.filePath);
+            // File size check
+            if (deps.statFile) {
+                const stat = await deps.statFile(resolved);
+                if (!stat || !stat.exists) {
+                    return {
+                        content: [{ type: "text", text: `Error: file not found: ${params.filePath}` }],
+                        details: { type: "lsp", error: "file_not_found" },
+                    };
+                }
+                if (stat.size > MAX_FILE_SIZE) {
+                    return {
+                        content: [{ type: "text", text: `Error: file too large (${(stat.size / 1024 / 1024).toFixed(1)}MB, max 10MB).` }],
+                        details: { type: "lsp", error: "file_too_large" },
+                    };
+                }
+            }
+            const result = await deps.executeOperation({
+                operation: params.operation,
+                filePath: resolved,
+                line: params.line,
+                character: params.character,
+                newName: params.newName,
+                includeContext: params.includeContext ?? true,
+            });
+            return { content: [{ type: "text", text: formatLspResult(params.operation, result) }], details: { type: "lsp", operation: params.operation } };
+        },
+    };
+}
+// ── Output formatting ───────────────────────────────────────
+function formatLspResult(operation, result) {
+    switch (result.type) {
+        case "locations": {
+            if (result.locations.length === 0)
+                return "No results found.";
+            const lines = [`Found ${result.locations.length} location(s):`, ""];
+            for (const loc of result.locations.slice(0, 50)) {
+                lines.push(`  ${loc.filePath}:${loc.line}:${loc.character}`);
+                if (loc.context)
+                    lines.push(`    ${loc.context.trim()}`);
+            }
+            if (result.locations.length > 50)
+                lines.push(`  ... and ${result.locations.length - 50} more`);
+            return lines.join("\n");
+        }
+        case "symbols": {
+            if (result.symbols.length === 0)
+                return "No symbols found.";
+            const lines = [`Document symbols (${result.symbols.length}):`, ""];
+            for (const sym of result.symbols) {
+                lines.push(`  ${sym.kind} ${sym.name} (L${sym.range.startLine}-${sym.range.endLine})`);
+                if (sym.children) {
+                    for (const child of sym.children.slice(0, 10)) {
+                        lines.push(`    ${child.kind} ${child.name} (L${child.range.startLine})`);
+                    }
+                    if (sym.children.length > 10)
+                        lines.push(`    ... and ${sym.children.length - 10} more`);
+                }
+            }
+            return lines.join("\n");
+        }
+        case "diagnostics": {
+            if (result.diagnostics.length === 0)
+                return "No diagnostics (clean file).";
+            const lines = [`Diagnostics (${result.diagnostics.length}):`, ""];
+            for (const d of result.diagnostics) {
+                const icon = d.severity === "error" ? "❌" : d.severity === "warning" ? "⚠️" : "ℹ️";
+                lines.push(`  ${icon} L${d.line}:${d.character} [${d.source || ""}${d.code ? `:${d.code}` : ""}] ${d.message}`);
+            }
+            return lines.join("\n");
+        }
+        case "hover": {
+            if (!result.hover)
+                return "No hover information available.";
+            return result.hover.contents;
+        }
+        case "completions": {
+            if (result.completions.length === 0)
+                return "No completions available.";
+            const lines = [`Completions (${result.completions.length}):`, ""];
+            for (const c of result.completions.slice(0, 20)) {
+                lines.push(`  [${c.kind}] ${c.label}${c.detail ? ` — ${c.detail}` : ""}`);
+            }
+            if (result.completions.length > 20)
+                lines.push(`  ... and ${result.completions.length - 20} more`);
+            return lines.join("\n");
+        }
+        case "signatureHelp": {
+            if (result.signatures.length === 0)
+                return "No signature information available.";
+            return result.signatures.join("\n");
+        }
+        case "rename": {
+            if (result.edits.length === 0)
+                return "No edits generated for rename.";
+            const total = result.edits.reduce((sum, f) => sum + f.edits.length, 0);
+            const lines = [`Rename would affect ${total} location(s) in ${result.edits.length} file(s):`, ""];
+            for (const file of result.edits) {
+                lines.push(`  ${file.filePath} (${file.edits.length} edits)`);
+            }
+            return lines.join("\n");
+        }
+        case "codeActions": {
+            if (result.actions.length === 0)
+                return "No code actions available.";
+            const lines = [`Available code actions (${result.actions.length}):`, ""];
+            for (const a of result.actions) {
+                lines.push(`  ${a.isPreferred ? "★" : "-"} ${a.title}${a.kind ? ` [${a.kind}]` : ""}`);
+            }
+            return lines.join("\n");
+        }
+        default:
+            return "Unknown result type.";
+    }
+}

package/dist/skills/tools/media-cancel-tool.d.ts

@@ -0,0 +1,30 @@
+import type { PortableTool } from "../portable-tool.js";
+export declare const MEDIA_CANCEL_TOOL_NAME: "media_cancel";
+export interface MediaCancelToolParams {
+    task_id: string;
+    provider?: string;
+}
+export declare const MEDIA_CANCEL_TOOL_SCHEMA: {
+    readonly type: "object";
+    readonly properties: {
+        readonly task_id: {
+            readonly type: "string";
+            readonly description: "The task ID of the media generation to cancel (returned in previous generation results).";
+        };
+        readonly provider: {
+            readonly type: "string";
+            readonly description: "Provider name (e.g. 'doubao', 'zhipu'). If omitted, auto-detects from task context.";
+        };
+    };
+    readonly required: readonly ["task_id"];
+};
+export interface MediaCancelToolDeps {
+    cancelTask(params: {
+        taskId: string;
+        provider?: string;
+    }): Promise<{
+        ok: boolean;
+        message: string;
+    }>;
+}
+export declare function createMediaCancelTool(deps: MediaCancelToolDeps): PortableTool<MediaCancelToolParams>;

package/dist/skills/tools/media-cancel-tool.js

@@ -0,0 +1,46 @@
+// ============================================================
+// Media Cancel Tool — cancel an in-progress media generation task.
+// Category: media
+// ============================================================
+export const MEDIA_CANCEL_TOOL_NAME = "media_cancel";
+export const MEDIA_CANCEL_TOOL_SCHEMA = {
+    type: "object",
+    properties: {
+        task_id: {
+            type: "string",
+            description: "The task ID of the media generation to cancel (returned in previous generation results).",
+        },
+        provider: {
+            type: "string",
+            description: "Provider name (e.g. 'doubao', 'zhipu'). If omitted, auto-detects from task context.",
+        },
+    },
+    required: ["task_id"],
+};
+export function createMediaCancelTool(deps) {
+    return {
+        name: MEDIA_CANCEL_TOOL_NAME,
+        label: "Media Cancel",
+        searchHint: "cancel stop abort media generation task 取消 中止 停止生成",
+        description: "Cancel an in-progress media generation task (video, 3D, etc.). " +
+            "Provide the task_id from a previous generation result. " +
+            "Use this when a user wants to abort a long-running generation.",
+        parameters: MEDIA_CANCEL_TOOL_SCHEMA,
+        execute: async (_toolCallId, params) => {
+            if (!params.task_id) {
+                return {
+                    content: [{ type: "text", text: "Error: task_id is required." }],
+                    details: { error: "task_id is required" },
+                };
+            }
+            const result = await deps.cancelTask({
+                taskId: params.task_id,
+                provider: params.provider,
+            });
+            return {
+                content: [{ type: "text", text: result.ok ? `Task ${params.task_id} cancelled.` : `Cancel failed: ${result.message}` }],
+                details: result.ok ? undefined : { error: result.message },
+            };
+        },
+    };
+}

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

@@ -0,0 +1,113 @@
+import type { PortableTool } from "../portable-tool.js";
+export declare const MONITOR_TOOL_NAME: "monitor";
+/** The kind of event source the agent can monitor. */
+export type MonitorSource = "process" | "file" | "task" | "custom";
+export type MonitorAction = "start" | "stop" | "list";
+export interface MonitorToolParams {
+    action: MonitorAction;
+    /** Required for start/stop — identifies the monitor instance. */
+    monitorId?: string;
+    /** Required for start — what kind of event source to watch. */
+    source?: MonitorSource;
+    /** Required for start — selector for the target (pid, path, taskId, custom key). */
+    target?: string;
+    /** Optional for start — conditions that should trigger wake-up. */
+    conditions?: MonitorCondition[];
+    /** Optional for start — max time to monitor in seconds before auto-stop. */
+    timeoutSeconds?: number;
+}
+export interface MonitorCondition {
+    /** What to check: exit code, stdout pattern, file modification, task status. */
+    type: "exit" | "output_match" | "file_changed" | "task_status";
+    /** Pattern or value to match (regex for output_match, status name for task_status). */
+    value?: string;
+}
+export declare const MONITOR_TOOL_SCHEMA: {
+    readonly type: "object";
+    readonly properties: {
+        readonly action: {
+            readonly type: "string";
+            readonly enum: readonly ["start", "stop", "list"];
+            readonly description: "Action to perform: start a new monitor, stop an existing one, or list active monitors.";
+        };
+        readonly monitorId: {
+            readonly type: "string";
+            readonly description: "Identifier for the monitor instance. Required for start/stop.";
+        };
+        readonly source: {
+            readonly type: "string";
+            readonly enum: readonly ["file"];
+            readonly description: "Type of event source to watch. Currently only \"file\" is supported.";
+        };
+        readonly target: {
+            readonly type: "string";
+            readonly description: "Selector for the monitored target. For file: a path or glob pattern.";
+        };
+        readonly conditions: {
+            readonly type: "array";
+            readonly items: {
+                readonly type: "object";
+                readonly properties: {
+                    readonly type: {
+                        readonly type: "string";
+                        readonly enum: readonly ["exit", "output_match", "file_changed", "task_status"];
+                    };
+                    readonly value: {
+                        readonly type: "string";
+                    };
+                };
+                readonly required: readonly ["type"];
+            };
+            readonly description: "Conditions that trigger a wake-up notification.";
+        };
+        readonly timeoutSeconds: {
+            readonly type: "number";
+            readonly description: "Auto-stop after this many seconds (default: 3600).";
+            readonly minimum: 1;
+            readonly maximum: 86400;
+        };
+    };
+    readonly required: readonly ["action"];
+};
+/** Info about an active monitor. */
+export interface MonitorInfo {
+    monitorId: string;
+    source: MonitorSource;
+    target: string;
+    conditions: MonitorCondition[];
+    startedAt: number;
+    timeoutSeconds: number;
+    /** Events received so far. */
+    eventCount: number;
+}
+/** Result of monitor operations. */
+export interface MonitorResult {
+    action: MonitorAction;
+    success: boolean;
+    monitorId?: string;
+    monitors?: MonitorInfo[];
+    error?: string;
+}
+/**
+ * Runtime dependencies injected by the host.
+ *
+ * The host is responsible for:
+ * 1. Actually watching the event source (polling, inotify, process hooks, etc.)
+ * 2. Delivering notifications back to the agent loop (via tick or wake-up)
+ * 3. Cleaning up monitors when they time out or are stopped.
+ */
+export interface MonitorToolDeps {
+    /** Start monitoring a target. Returns the created monitor info. */
+    startMonitor(params: {
+        monitorId: string;
+        source: MonitorSource;
+        target: string;
+        conditions: MonitorCondition[];
+        timeoutSeconds: number;
+    }): Promise<MonitorResult>;
+    /** Stop an active monitor. */
+    stopMonitor(monitorId: string): Promise<MonitorResult>;
+    /** List all active monitors for this session. */
+    listMonitors(): Promise<MonitorInfo[]>;
+}
+export declare function createMonitorTool(deps: MonitorToolDeps): PortableTool<MonitorToolParams>;