qlogicagent 0.2.1 → 0.4.0

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

@@ -1,113 +0,0 @@
-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 ["process", "file", "task", "custom"];
-            readonly description: "Type of event source to watch.";
-        };
-        readonly target: {
-            readonly type: "string";
-            readonly description: string;
-        };
-        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>;

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.d.ts

@@ -1,55 +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;
-}
-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 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;
-    }): Promise<MusicGenerateResult>;
-}
-export declare function createMusicGenerateTool(deps: MusicGenerateToolDeps): PortableTool<MusicGenerateToolParams>;

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.d.ts

@@ -1,53 +0,0 @@
-import type { PortableTool } from "../portable-tool.js";
-export declare const NOTIFY_TOOL_NAME: "notify";
-export interface NotifyToolParams {
-    /** Notification message */
-    message: string;
-    /** Optional title/subject */
-    title?: string;
-    /** Priority level */
-    priority?: "low" | "normal" | "high";
-    /** Target channel override (default: user's primary channel) */
-    channel?: string;
-}
-export declare const NOTIFY_TOOL_SCHEMA: {
-    readonly type: "object";
-    readonly properties: {
-        readonly message: {
-            readonly type: "string";
-            readonly description: "Notification content to send to the user.";
-        };
-        readonly title: {
-            readonly type: "string";
-            readonly description: "Optional notification title/subject line.";
-        };
-        readonly priority: {
-            readonly type: "string";
-            readonly enum: readonly ["low", "normal", "high"];
-            readonly description: "Notification priority (default: normal). High may trigger sound/vibration.";
-        };
-        readonly channel: {
-            readonly type: "string";
-            readonly description: "Target delivery channel (e.g. 'wechat', 'feishu', 'discord'). Default: user's primary.";
-        };
-    };
-    readonly required: readonly ["message"];
-};
-export interface NotifyResult {
-    delivered: boolean;
-    channel: string;
-    error?: string;
-}
-/**
- * Host-provided notification delivery backend.
- */
-export interface NotifyToolDeps {
-    /** Send notification to user. Host routes to correct platform. */
-    sendNotification(params: {
-        message: string;
-        title?: string;
-        priority?: string;
-        channel?: string;
-    }): Promise<NotifyResult>;
-}
-export declare function createNotifyTool(deps: NotifyToolDeps): PortableTool<NotifyToolParams>;

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 },
-            };
-        },
-    };
-}

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

@@ -1,45 +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 declare function createPatchTool(deps: PatchToolDeps): PortableTool<PatchToolParams>;
-export { fuzzyFind, type MatchResult };