qlogicagent 0.2.1 → 0.3.0

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

@@ -1,131 +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",
-            enum: ["process", "file", "task", "custom"],
-            description: "Type of event source to watch.",
-        },
-        target: {
-            type: "string",
-            description: "Selector for the monitored target. For process: PID or background job id. " +
-                "For file: glob pattern. For task: task ID. For custom: host-defined key.",
-        },
-        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,
-        description: [
-            "Set up event-driven monitoring to wake up when something happens.",
-            "",
-            "Use this to watch for:",
-            "• Background process completion or specific output patterns",
-            "• File system changes (new file, modification)",
-            "• Async task state transitions (pending → completed/failed)",
-            "• Custom host-defined events",
-            "",
-            "When a monitored condition triggers, you'll receive a notification in your next tick.",
-            "This is more efficient than polling with Sleep — you only wake up when there's work to do.",
-            "",
-            "Actions:",
-            "• start — register a new monitor (requires monitorId, source, 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.js

@@ -1,62 +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.",
-        },
-    },
-    required: ["prompt"],
-};
-export function createMusicGenerateTool(deps) {
-    return {
-        name: MUSIC_GENERATE_TOOL_NAME,
-        label: "Music Generate",
-        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 — use tts tool instead.",
-        parameters: MUSIC_GENERATE_TOOL_SCHEMA,
-        execute: async (_toolCallId, params) => {
-            const result = await deps.generateMusic({
-                prompt: params.prompt,
-                purpose: params.purpose,
-                style: params.style,
-                lyrics: params.lyrics,
-                duration: params.duration,
-            });
-            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/notify-tool.js

@@ -1,62 +0,0 @@
-// ============================================================
-// Notify Tool — push notifications to user across platforms.
-// Reference: hermes-agent-main/tools/send_message_tool.py
-// Category: interaction
-// ============================================================
-export const NOTIFY_TOOL_NAME = "notify";
-export const NOTIFY_TOOL_SCHEMA = {
-    type: "object",
-    properties: {
-        message: {
-            type: "string",
-            description: "Notification content to send to the user.",
-        },
-        title: {
-            type: "string",
-            description: "Optional notification title/subject line.",
-        },
-        priority: {
-            type: "string",
-            enum: ["low", "normal", "high"],
-            description: "Notification priority (default: normal). High may trigger sound/vibration.",
-        },
-        channel: {
-            type: "string",
-            description: "Target delivery channel (e.g. 'wechat', 'feishu', 'discord'). Default: user's primary.",
-        },
-    },
-    required: ["message"],
-};
-export function createNotifyTool(deps) {
-    return {
-        name: NOTIFY_TOOL_NAME,
-        label: "Notify",
-        description: "Send a notification to the user. Used for alerting about completed long-running tasks, " +
-            "important updates, or requesting attention. Supports multiple channels (WeChat, Feishu, Discord, etc).",
-        parameters: NOTIFY_TOOL_SCHEMA,
-        execute: async (_toolCallId, params) => {
-            if (!params.message || params.message.trim().length === 0) {
-                return {
-                    content: [{ type: "text", text: "Error: message is required." }],
-                    details: { type: "notify", error: "empty_message" },
-                };
-            }
-            const result = await deps.sendNotification({
-                message: params.message.trim(),
-                title: params.title,
-                priority: params.priority || "normal",
-                channel: params.channel,
-            });
-            if (!result.delivered) {
-                return {
-                    content: [{ type: "text", text: `Notification failed: ${result.error || "delivery error"}` }],
-                    details: { type: "notify", delivered: false, error: result.error },
-                };
-            }
-            return {
-                content: [{ type: "text", text: `Notification sent via ${result.channel}.` }],
-                details: { type: "notify", delivered: true, channel: result.channel },
-            };
-        },
-    };
-}