qlogicagent 2.13.4 → 2.13.5

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

@@ -0,0 +1,129 @@
+// ============================================================
+// 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

@@ -0,0 +1,80 @@
+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

@@ -0,0 +1,98 @@
+// ============================================================
+// 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

@@ -0,0 +1,15 @@
+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

@@ -0,0 +1,206 @@
+// ============================================================
+// 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

@@ -0,0 +1,52 @@
+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 };