qlogicagent 2.13.5 → 2.13.6

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

@@ -1,129 +0,0 @@
-// ============================================================
-// Monitor Tool — event-driven wake-up / watch mechanism.
-// Reference: CC proactive mode MonitorTool (feature-gated)
-// Category: autonomous / proactive mode
-// ============================================================
-export const MONITOR_TOOL_NAME = "monitor";
-export const MONITOR_TOOL_SCHEMA = {
-    type: "object",
-    properties: {
-        action: {
-            type: "string",
-            enum: ["start", "stop", "list"],
-            description: "Action to perform: start a new monitor, stop an existing one, or list active monitors.",
-        },
-        monitorId: {
-            type: "string",
-            description: "Identifier for the monitor instance. Required for start/stop.",
-        },
-        source: {
-            type: "string",
-            // Only "file" is implemented. process/task/custom are not advertised until
-            // they actually watch something (no fail-quiet "success" on a dead monitor).
-            enum: ["file"],
-            description: "Type of event source to watch. Currently only \"file\" is supported.",
-        },
-        target: {
-            type: "string",
-            description: "Selector for the monitored target. For file: a path or glob pattern.",
-        },
-        conditions: {
-            type: "array",
-            items: {
-                type: "object",
-                properties: {
-                    type: {
-                        type: "string",
-                        enum: ["exit", "output_match", "file_changed", "task_status"],
-                    },
-                    value: { type: "string" },
-                },
-                required: ["type"],
-            },
-            description: "Conditions that trigger a wake-up notification.",
-        },
-        timeoutSeconds: {
-            type: "number",
-            description: "Auto-stop after this many seconds (default: 3600).",
-            minimum: 1,
-            maximum: 86400,
-        },
-    },
-    required: ["action"],
-};
-export function createMonitorTool(deps) {
-    return {
-        name: MONITOR_TOOL_NAME,
-        label: "Monitor",
-        shouldDefer: true,
-        searchHint: "monitor watch file-change event trigger 监视 文件变化 事件 盯着",
-        description: [
-            "Set up event-driven monitoring to wake up when a file changes.",
-            "",
-            "Watches file-system changes (new file, modification) on a path. When the",
-            "file changes you'll receive a notification in your next tick — more efficient",
-            "than polling with Sleep. (For background agents/commands, use the task tool's",
-            "\"output\" action instead.)",
-            "",
-            "Actions:",
-            "• start — register a new monitor (requires monitorId, source=\"file\", target)",
-            "• stop — deregister an active monitor",
-            "• list — show all active monitors and their event counts",
-        ].join("\n"),
-        parameters: MONITOR_TOOL_SCHEMA,
-        execute: async (_toolCallId, params) => {
-            const { action } = params;
-            if (action === "list") {
-                const monitors = await deps.listMonitors();
-                if (monitors.length === 0) {
-                    return {
-                        content: [{ type: "text", text: "No active monitors." }],
-                        details: { action, monitors: [] },
-                    };
-                }
-                const lines = monitors.map((m) => `• ${m.monitorId} [${m.source}] → ${m.target} (events: ${m.eventCount}, timeout: ${m.timeoutSeconds}s)`);
-                return {
-                    content: [{ type: "text", text: `Active monitors:\n${lines.join("\n")}` }],
-                    details: { action, monitors },
-                };
-            }
-            if (!params.monitorId) {
-                return {
-                    content: [{ type: "text", text: "Error: monitorId is required for start/stop." }],
-                    details: { action, success: false, error: "missing_monitor_id" },
-                };
-            }
-            if (action === "stop") {
-                const result = await deps.stopMonitor(params.monitorId);
-                const text = result.success
-                    ? `Monitor "${params.monitorId}" stopped.`
-                    : `Failed to stop monitor "${params.monitorId}": ${result.error ?? "not found"}`;
-                return {
-                    content: [{ type: "text", text }],
-                    details: { ...result },
-                };
-            }
-            // action === "start"
-            if (!params.source || !params.target) {
-                return {
-                    content: [{ type: "text", text: "Error: source and target are required to start a monitor." }],
-                    details: { action, success: false, error: "missing_source_or_target" },
-                };
-            }
-            const result = await deps.startMonitor({
-                monitorId: params.monitorId,
-                source: params.source,
-                target: params.target,
-                conditions: params.conditions ?? [],
-                timeoutSeconds: params.timeoutSeconds ?? 3600,
-            });
-            const text = result.success
-                ? `Monitor "${params.monitorId}" started: watching ${params.source} "${params.target}".`
-                : `Failed to start monitor: ${result.error ?? "unknown"}`;
-            return {
-                content: [{ type: "text", text }],
-                details: { ...result },
-            };
-        },
-    };
-}

package/dist/skills/tools/music-generate-tool.d.ts

@@ -1,80 +0,0 @@
-import type { PortableTool } from "../portable-tool.js";
-export declare const MUSIC_GENERATE_TOOL_NAME: "music_generate";
-export interface MusicGenerateToolParams {
-    prompt: string;
-    purpose?: string;
-    style?: string;
-    lyrics?: string;
-    duration?: number;
-    is_instrumental?: boolean;
-    cover_audio_url?: string;
-    audio_format?: string;
-}
-export declare const MUSIC_GENERATE_TOOL_SCHEMA: {
-    readonly type: "object";
-    readonly properties: {
-        readonly prompt: {
-            readonly type: "string";
-            readonly description: string;
-        };
-        readonly purpose: {
-            readonly type: "string";
-            readonly description: "Intended use: 'background-music', 'ringtone', 'short-video-bgm', 'full-song', 'notification-sound', etc.";
-        };
-        readonly style: {
-            readonly type: "string";
-            readonly description: "Musical style/genre: 'lo-fi', 'pop', 'rock', 'jazz', 'classical', 'electronic', 'ambient', etc.";
-        };
-        readonly lyrics: {
-            readonly type: "string";
-            readonly description: "Optional lyrics for vocal music. Structure with [verse], [chorus], [bridge] tags if desired.";
-        };
-        readonly duration: {
-            readonly type: "number";
-            readonly description: "Duration in seconds (5-300). Infer from purpose: ringtone 15-30s, BGM 30-60s, full song 120-180s.";
-        };
-        readonly is_instrumental: {
-            readonly type: "boolean";
-            readonly description: "Set true for pure instrumental music without vocals. Defaults to true when no lyrics are provided.";
-        };
-        readonly cover_audio_url: {
-            readonly type: "string";
-            readonly description: string;
-        };
-        readonly audio_format: {
-            readonly type: "string";
-            readonly enum: readonly ["mp3", "wav", "flac"];
-            readonly description: "Output audio format. Defaults to mp3.";
-        };
-    };
-    readonly required: readonly ["prompt"];
-};
-export interface MusicGenerateResult {
-    mediaUrls: string[];
-    model?: string;
-    durationMs?: number;
-}
-/** Deps injected by the host runtime for music generation. */
-export interface MusicGenerateToolDeps {
-    /**
-     * Generate music via the configured backend.
-     * The host handles model selection, failover, and storage.
-     */
-    generateMusic(params: {
-        prompt: string;
-        purpose?: string;
-        style?: string;
-        lyrics?: string;
-        duration?: number;
-        isInstrumental?: boolean;
-        audioUrl?: string;
-        audioFormat?: string;
-    }): Promise<MusicGenerateResult>;
-    /**
-     * Optional: auto-generate lyrics from a prompt (MiniMax Lyrics Generation API).
-     * When provided, the tool will auto-call this when no lyrics are supplied
-     * and the song is not marked as instrumental.
-     */
-    generateLyrics?: (prompt: string) => Promise<string>;
-}
-export declare function createMusicGenerateTool(deps: MusicGenerateToolDeps): PortableTool<MusicGenerateToolParams>;

package/dist/skills/tools/music-generate-tool.js

@@ -1,98 +0,0 @@
-// ============================================================
-// Music Generate Tool — text-to-music via backend adapter.
-// Category: media
-// ============================================================
-export const MUSIC_GENERATE_TOOL_NAME = "music_generate";
-export const MUSIC_GENERATE_TOOL_SCHEMA = {
-    type: "object",
-    properties: {
-        prompt: {
-            type: "string",
-            description: "Music generation prompt. MUST be in English. " +
-                "Include genre, mood, tempo, instruments, and atmosphere details.",
-        },
-        purpose: {
-            type: "string",
-            description: "Intended use: 'background-music', 'ringtone', 'short-video-bgm', 'full-song', 'notification-sound', etc.",
-        },
-        style: {
-            type: "string",
-            description: "Musical style/genre: 'lo-fi', 'pop', 'rock', 'jazz', 'classical', 'electronic', 'ambient', etc.",
-        },
-        lyrics: {
-            type: "string",
-            description: "Optional lyrics for vocal music. Structure with [verse], [chorus], [bridge] tags if desired.",
-        },
-        duration: {
-            type: "number",
-            description: "Duration in seconds (5-300). Infer from purpose: ringtone 15-30s, BGM 30-60s, full song 120-180s.",
-        },
-        is_instrumental: {
-            type: "boolean",
-            description: "Set true for pure instrumental music without vocals. Defaults to true when no lyrics are provided.",
-        },
-        cover_audio_url: {
-            type: "string",
-            description: "URL of an existing audio track to use as base for cover/remix. When provided, generates a cover version. " +
-                "MUST be a publicly accessible HTTP/HTTPS URL. " +
-                "Use file_upload tool first if the user provides a local file.",
-        },
-        audio_format: {
-            type: "string",
-            enum: ["mp3", "wav", "flac"],
-            description: "Output audio format. Defaults to mp3.",
-        },
-    },
-    required: ["prompt"],
-};
-export function createMusicGenerateTool(deps) {
-    return {
-        name: MUSIC_GENERATE_TOOL_NAME,
-        label: "Music Generate",
-        shouldDefer: true,
-        searchHint: "music song melody bgm compose lyrics 音乐 歌曲 作曲 写歌 背景音乐 旋律",
-        description: "Generate music, songs, or melodies from text descriptions. " +
-            "Prompt MUST be in English. Supports lyrics for vocal songs. " +
-            "DO NOT use for spoken-word audio or TTS \u2014 use tts tool instead. " +
-            "IMPORTANT: If the user has not specified genre/style or duration, use ask_user to clarify " +
-            "(e.g. style: lo-fi / pop / rock / jazz; duration inferred from purpose: 30s for ringtone, " +
-            "60-90s for BGM, 180-240s for full song). Auto-infer duration from purpose when possible.",
-        parameters: MUSIC_GENERATE_TOOL_SCHEMA,
-        isEgress: true,
-        // 外发的是 prompt + 歌词文本,不携带用户本地隐私数据,故不触发 high_risk_egress 每次确认。
-        egressCarriesData: false,
-        execute: async (_toolCallId, params) => {
-            // T9: 2-step lyrics flow — auto-generate lyrics when none provided and not instrumental
-            let finalLyrics = params.lyrics;
-            if (!finalLyrics && !params.is_instrumental && deps.generateLyrics) {
-                try {
-                    finalLyrics = await deps.generateLyrics(params.prompt);
-                }
-                catch {
-                    // Lyrics generation failed — fall back to instrumental mode
-                }
-            }
-            const result = await deps.generateMusic({
-                prompt: params.prompt,
-                purpose: params.purpose,
-                style: params.style,
-                lyrics: finalLyrics,
-                duration: params.duration,
-                isInstrumental: params.is_instrumental,
-                audioUrl: params.cover_audio_url,
-                audioFormat: params.audio_format,
-            });
-            const count = result.mediaUrls.length;
-            const text = `Generated ${count} audio track${count > 1 ? "s" : ""}${result.model ? ` (model: ${result.model})` : ""}`;
-            return {
-                content: [{ type: "text", text }],
-                details: {
-                    type: "music_generate",
-                    model: result.model,
-                    durationMs: result.durationMs,
-                    mediaUrls: result.mediaUrls,
-                },
-            };
-        },
-    };
-}

package/dist/skills/tools/notebook-edit-tool.d.ts

@@ -1,15 +0,0 @@
-import type { PortableTool } from "../portable-tool.js";
-export type NotebookEditMode = "replace" | "insert" | "delete";
-export interface NotebookEditParams {
-    /** Absolute path to the .ipynb file */
-    notebook_path: string;
-    /** Cell number (1-based) to operate on */
-    cell_number: number;
-    /** New cell source content (required for replace/insert) */
-    new_source?: string;
-    /** Cell type for insert (default: "code") */
-    cell_type?: "code" | "markdown";
-    /** Edit mode (default: "replace") */
-    edit_mode?: NotebookEditMode;
-}
-export declare function createNotebookEditTool(): PortableTool<NotebookEditParams>;

package/dist/skills/tools/notebook-edit-tool.js

@@ -1,206 +0,0 @@
-// ============================================================
-// Notebook Edit Tool — Jupyter cell-level operations.
-//
-// CC reference: src/tools/NotebookEditTool/NotebookEditTool.ts
-// Supports: replace / insert / delete cells in .ipynb files.
-// Category: file (write)
-// ============================================================
-import { readFile, writeFile } from "node:fs/promises";
-import * as path from "node:path";
-// ── Schema ──────────────────────────────────────────────────
-const NOTEBOOK_EDIT_SCHEMA = {
-    type: "object",
-    properties: {
-        notebook_path: {
-            type: "string",
-            description: "Absolute path to the .ipynb notebook file.",
-        },
-        cell_number: {
-            type: "number",
-            description: "1-based cell number to operate on. For 'insert', the new cell is inserted after this cell (use 0 to insert at the beginning).",
-        },
-        new_source: {
-            type: "string",
-            description: "New cell content. Required for 'replace' and 'insert' modes.",
-        },
-        cell_type: {
-            type: "string",
-            enum: ["code", "markdown"],
-            description: "Cell type for 'insert' mode. Default: 'code'.",
-        },
-        edit_mode: {
-            type: "string",
-            enum: ["replace", "insert", "delete"],
-            description: "Edit operation: replace (default), insert (after cell_number), or delete.",
-        },
-    },
-    required: ["notebook_path", "cell_number"],
-};
-// ── Helpers ─────────────────────────────────────────────────
-function sourceToLines(source) {
-    const lines = source.split("\n");
-    // .ipynb format: each line except last ends with \n
-    return lines.map((line, i) => (i < lines.length - 1 ? line + "\n" : line));
-}
-function linesToSource(lines) {
-    return lines.join("");
-}
-function cellSummary(cell, index) {
-    const src = linesToSource(cell.source).trim();
-    const preview = src.length > 80 ? src.slice(0, 80) + "..." : src;
-    return `Cell ${index + 1} [${cell.cell_type}]: ${preview}`;
-}
-function createEmptyCell(type, source) {
-    const cell = {
-        cell_type: type,
-        source: sourceToLines(source),
-        metadata: {},
-    };
-    if (type === "code") {
-        cell.execution_count = null;
-        cell.outputs = [];
-    }
-    return cell;
-}
-// ── Tool factory ────────────────────────────────────────────
-export function createNotebookEditTool() {
-    return {
-        name: "notebook_edit",
-        label: "Notebook Edit",
-        description: "Edit Jupyter notebook (.ipynb) files at the cell level. Supports replacing cell content, " +
-            "inserting new cells, and deleting cells. Operates on the notebook's JSON structure directly.",
-        parameters: NOTEBOOK_EDIT_SCHEMA,
-        shouldDefer: true,
-        isConcurrencySafe: false,
-        isReadOnly: false,
-        searchHint: "jupyter notebook ipynb cell edit insert delete 笔记本 单元格",
-        execute: async (_toolCallId, params) => {
-            const { notebook_path: nbPath, cell_number: cellNum, edit_mode = "replace" } = params;
-            const ext = path.extname(nbPath).toLowerCase();
-            // Validate extension
-            if (ext !== ".ipynb") {
-                return {
-                    content: [{ type: "text", text: `Error: File must be a .ipynb notebook. Got: ${ext}` }],
-                    details: { error: "invalid_extension" },
-                };
-            }
-            // Read and parse notebook
-            let raw;
-            try {
-                raw = await readFile(nbPath, "utf-8");
-            }
-            catch (err) {
-                return {
-                    content: [{ type: "text", text: `Error reading notebook: ${err.message}` }],
-                    details: { error: "read_failed" },
-                };
-            }
-            let notebook;
-            try {
-                notebook = JSON.parse(raw);
-            }
-            catch {
-                return {
-                    content: [{ type: "text", text: "Error: File is not valid JSON (not a valid .ipynb)." }],
-                    details: { error: "parse_failed" },
-                };
-            }
-            if (!Array.isArray(notebook.cells)) {
-                return {
-                    content: [{ type: "text", text: "Error: Notebook has no cells array." }],
-                    details: { error: "invalid_notebook" },
-                };
-            }
-            const totalCells = notebook.cells.length;
-            const cellIndex = cellNum - 1; // 0-based
-            // Validate cell_number range
-            if (edit_mode === "insert") {
-                // For insert: 0 = beginning, totalCells = end
-                if (cellNum < 0 || cellNum > totalCells) {
-                    return {
-                        content: [{ type: "text", text: `Error: cell_number ${cellNum} out of range. For insert, use 0-${totalCells}.` }],
-                        details: { error: "out_of_range" },
-                    };
-                }
-            }
-            else {
-                if (cellIndex < 0 || cellIndex >= totalCells) {
-                    return {
-                        content: [{ type: "text", text: `Error: cell_number ${cellNum} out of range. Notebook has ${totalCells} cell(s).` }],
-                        details: { error: "out_of_range" },
-                    };
-                }
-            }
-            let resultMsg;
-            switch (edit_mode) {
-                case "replace": {
-                    if (!params.new_source) {
-                        return {
-                            content: [{ type: "text", text: "Error: new_source is required for 'replace' mode." }],
-                            details: { error: "missing_source" },
-                        };
-                    }
-                    const cell = notebook.cells[cellIndex];
-                    const oldSource = linesToSource(cell.source);
-                    cell.source = sourceToLines(params.new_source);
-                    // Clear execution state for code cells (CC parity)
-                    if (cell.cell_type === "code") {
-                        cell.execution_count = null;
-                        cell.outputs = [];
-                    }
-                    resultMsg = `Replaced cell ${cellNum} [${cell.cell_type}].\nOld: ${oldSource.slice(0, 120)}${oldSource.length > 120 ? "..." : ""}\nNew: ${params.new_source.slice(0, 120)}${params.new_source.length > 120 ? "..." : ""}`;
-                    break;
-                }
-                case "insert": {
-                    if (!params.new_source) {
-                        return {
-                            content: [{ type: "text", text: "Error: new_source is required for 'insert' mode." }],
-                            details: { error: "missing_source" },
-                        };
-                    }
-                    const cellType = params.cell_type ?? "code";
-                    const newCell = createEmptyCell(cellType, params.new_source);
-                    notebook.cells.splice(cellNum, 0, newCell); // insert after cellNum (0=beginning)
-                    resultMsg = `Inserted new ${cellType} cell after position ${cellNum}. Total cells: ${notebook.cells.length}.`;
-                    break;
-                }
-                case "delete": {
-                    const deleted = notebook.cells.splice(cellIndex, 1)[0];
-                    resultMsg = `Deleted cell ${cellNum} [${deleted.cell_type}]. Remaining: ${notebook.cells.length} cells.`;
-                    break;
-                }
-                default:
-                    return {
-                        content: [{ type: "text", text: `Error: unknown edit_mode "${edit_mode}". Use replace, insert, or delete.` }],
-                        details: { error: "unknown_mode" },
-                    };
-            }
-            // Write back with original formatting (2-space indent to match Jupyter default)
-            try {
-                const output = JSON.stringify(notebook, null, 1) + "\n";
-                await writeFile(nbPath, output, "utf-8");
-            }
-            catch (err) {
-                return {
-                    content: [{ type: "text", text: `Error writing notebook: ${err.message}` }],
-                    details: { error: "write_failed" },
-                };
-            }
-            // Summary of notebook state
-            const cellList = notebook.cells
-                .slice(0, 10)
-                .map((c, i) => cellSummary(c, i))
-                .join("\n");
-            const suffix = notebook.cells.length > 10 ? `\n... and ${notebook.cells.length - 10} more cells` : "";
-            return {
-                content: [{ type: "text", text: `${resultMsg}\n\nCurrent cells:\n${cellList}${suffix}` }],
-                details: {
-                    type: "notebook_edit",
-                    edit_mode,
-                    cell_number: cellNum,
-                    total_cells: notebook.cells.length,
-                },
-            };
-        },
-    };
-}

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

@@ -1,52 +0,0 @@
-import type { PortableTool } from "../portable-tool.js";
-export declare const PATCH_TOOL_NAME: "patch";
-export interface PatchToolParams {
-    /** V4A unified diff or simple find-replace */
-    input: string;
-    /** When true, replace all occurrences in each file (default: false) */
-    replaceAll?: boolean;
-}
-export declare const PATCH_TOOL_SCHEMA: {
-    readonly type: "object";
-    readonly properties: {
-        readonly input: {
-            readonly type: "string";
-            readonly description: string;
-        };
-        readonly replaceAll: {
-            readonly type: "boolean";
-            readonly description: "Replace all occurrences instead of first only (default: false).";
-        };
-    };
-    readonly required: readonly ["input"];
-};
-export interface PatchResult {
-    filesModified: string[];
-    filesAdded: string[];
-    filesDeleted: string[];
-    strategies: Record<string, string>;
-    errors: string[];
-}
-export interface PatchToolDeps {
-    readFile(path: string): Promise<string>;
-    writeFile(path: string, content: string): Promise<void>;
-    deleteFile(path: string): Promise<void>;
-    fileExists(path: string): Promise<boolean>;
-    resolvePath(input: string): string;
-}
-export type MatchStrategy = "exact" | "line_trimmed" | "whitespace_normalized" | "indentation_flexible" | "escape_normalized" | "trimmed_boundary" | "unicode_normalized" | "block_anchor" | "context_aware";
-interface MatchResult {
-    start: number;
-    end: number;
-    strategy: MatchStrategy;
-}
-declare function fuzzyFind(content: string, search: string, replaceAll: boolean): MatchResult[];
-export interface PatchTargets {
-    /** Every file path the patch adds, updates, deletes, or moves (source + destination). */
-    paths: string[];
-    /** Paths removed via a *** Delete File: directive. */
-    deletes: string[];
-}
-export declare function extractPatchTargets(input: string): PatchTargets;
-export declare function createPatchTool(deps: PatchToolDeps): PortableTool<PatchToolParams>;
-export { fuzzyFind, type MatchResult };