qlogicagent 0.2.1 → 0.3.0

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

@@ -1,155 +0,0 @@
-// ============================================================
-// Browser Tool — CDP-based browser automation.
-// Reference: hermes-agent-main/tools/browser_tool.py
-//            hermes-agent-main/tools/browser_cdp_tool.py
-// Category: web
-// ============================================================
-export const BROWSER_TOOL_NAME = "browser";
-export const BROWSER_TOOL_SCHEMA = {
-    type: "object",
-    properties: {
-        action: {
-            type: "string",
-            enum: ["navigate", "click", "type", "scroll", "snapshot", "screenshot", "console", "cdp"],
-            description: "Browser action: navigate (go to URL), click (element by ref), type (text into element), " +
-                "scroll (direction), snapshot (accessibility tree), screenshot (visual capture), " +
-                "console (eval JS / read logs), cdp (raw CDP command).",
-        },
-        url: {
-            type: "string",
-            description: "URL to navigate to. Required for 'navigate' action.",
-        },
-        ref: {
-            type: "string",
-            description: 'Element reference like "@e5" from a previous snapshot. Required for click/type.',
-        },
-        text: {
-            type: "string",
-            description: "Text to type into the referenced element. Required for 'type' action.",
-        },
-        direction: {
-            type: "string",
-            enum: ["up", "down", "left", "right"],
-            description: "Scroll direction. Required for 'scroll' action.",
-        },
-        method: {
-            type: "string",
-            description: "CDP method name (e.g. 'Page.reload'). Required for 'cdp' action.",
-        },
-        params: {
-            type: "object",
-            description: "Parameters for the CDP method. Optional for 'cdp' action.",
-        },
-        expression: {
-            type: "string",
-            description: "JavaScript expression to evaluate. Used with 'console' action.",
-        },
-        full: {
-            type: "boolean",
-            description: "Include full accessibility tree (default: compact). Used with 'snapshot'.",
-        },
-    },
-    required: ["action"],
-};
-export function createBrowserTool(deps) {
-    return {
-        name: BROWSER_TOOL_NAME,
-        label: "Browser",
-        description: "Control a headless browser via Chrome DevTools Protocol. " +
-            "Actions: navigate (URL), click/type (element refs from snapshot), " +
-            "scroll, snapshot (accessibility tree), screenshot (visual), " +
-            "console (JS eval/logs), cdp (raw CDP commands). " +
-            "Use snapshot to get element refs before click/type.",
-        parameters: BROWSER_TOOL_SCHEMA,
-        execute: async (_toolCallId, params) => {
-            switch (params.action) {
-                case "navigate": {
-                    if (!params.url) {
-                        return { content: [{ type: "text", text: "Error: url is required for navigate action." }], details: { type: "browser", error: "missing_url" } };
-                    }
-                    const blocked = deps.validateUrl(params.url);
-                    if (blocked) {
-                        return { content: [{ type: "text", text: `Blocked: ${blocked}` }], details: { type: "browser", error: "url_blocked" } };
-                    }
-                    const nav = await deps.navigate(params.url);
-                    const lines = [`Navigated to: ${nav.snapshot.url}`, `Title: ${nav.snapshot.title}`, "", `Elements: ${nav.snapshot.elements.length}`];
-                    if (nav.snapshot.elements.length <= 30) {
-                        for (const e of nav.snapshot.elements) {
-                            lines.push(`  ${e.ref} [${e.role}] ${e.name}${e.text ? `: "${e.text}"` : ""}`);
-                        }
-                    }
-                    else {
-                        lines.push("(use snapshot action for full element list)");
-                    }
-                    return { content: [{ type: "text", text: lines.join("\n") }], details: { type: "browser", action: "navigate", url: params.url } };
-                }
-                case "click": {
-                    if (!params.ref) {
-                        return { content: [{ type: "text", text: "Error: ref is required for click (e.g. '@e5')." }], details: { type: "browser", error: "missing_ref" } };
-                    }
-                    const click = await deps.click(params.ref);
-                    if (!click.success) {
-                        return { content: [{ type: "text", text: `Click failed: ${click.error || "unknown"}` }], details: { type: "browser", error: "click_failed" } };
-                    }
-                    return { content: [{ type: "text", text: `Clicked ${params.ref}` }], details: { type: "browser", action: "click", ref: params.ref } };
-                }
-                case "type": {
-                    if (!params.ref || !params.text) {
-                        return { content: [{ type: "text", text: "Error: ref and text are required for type action." }], details: { type: "browser", error: "missing_params" } };
-                    }
-                    const typed = await deps.type(params.ref, params.text);
-                    if (!typed.success) {
-                        return { content: [{ type: "text", text: `Type failed: ${typed.error || "unknown"}` }], details: { type: "browser", error: "type_failed" } };
-                    }
-                    return { content: [{ type: "text", text: `Typed "${params.text}" into ${params.ref}` }], details: { type: "browser", action: "type", ref: params.ref } };
-                }
-                case "scroll": {
-                    if (!params.direction) {
-                        return { content: [{ type: "text", text: "Error: direction is required for scroll." }], details: { type: "browser", error: "missing_direction" } };
-                    }
-                    await deps.scroll(params.direction);
-                    return { content: [{ type: "text", text: `Scrolled ${params.direction}` }], details: { type: "browser", action: "scroll", direction: params.direction } };
-                }
-                case "snapshot": {
-                    const snap = await deps.snapshot(params.full);
-                    const lines = [`URL: ${snap.url}`, `Title: ${snap.title}`, "", `Accessibility tree (${snap.elements.length} elements):`, ""];
-                    for (const e of snap.elements) {
-                        lines.push(`${e.ref} [${e.role}] ${e.name}${e.text ? ` — "${e.text}"` : ""}`);
-                    }
-                    return { content: [{ type: "text", text: lines.join("\n") }], details: { type: "browser", action: "snapshot", elementCount: snap.elements.length } };
-                }
-                case "screenshot": {
-                    const shot = await deps.screenshot();
-                    return {
-                        content: [{ type: "image", data: shot.base64, mimeType: shot.mimeType }],
-                        details: { type: "browser", action: "screenshot", width: shot.width, height: shot.height },
-                    };
-                }
-                case "console": {
-                    const c = await deps.consoleEval(params.expression);
-                    const lines = [];
-                    if (c.result !== undefined)
-                        lines.push(`Result: ${c.result}`);
-                    if (c.messages?.length) {
-                        lines.push("Console messages:");
-                        c.messages.forEach((m) => lines.push(`  ${m}`));
-                    }
-                    if (c.errors?.length) {
-                        lines.push("JS errors:");
-                        c.errors.forEach((e) => lines.push(`  ${e}`));
-                    }
-                    return { content: [{ type: "text", text: lines.join("\n") || "(no output)" }], details: { type: "browser", action: "console" } };
-                }
-                case "cdp": {
-                    if (!params.method) {
-                        return { content: [{ type: "text", text: "Error: method is required for cdp action." }], details: { type: "browser", error: "missing_method" } };
-                    }
-                    const result = await deps.cdp(params.method, params.params);
-                    return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }], details: { type: "browser", action: "cdp", method: params.method } };
-                }
-                default:
-                    return { content: [{ type: "text", text: `Error: unknown action "${params.action}".` }], details: { type: "browser", error: "unknown_action" } };
-            }
-        },
-    };
-}

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

@@ -1,102 +0,0 @@
-// ============================================================
-// Checkpoint Manager — transparent file history snapshots.
-// Reference: hermes-agent-main/tools/checkpoint_manager.py
-// Category: infrastructure (LLM does NOT directly invoke)
-// ============================================================
-export const CHECKPOINT_TOOL_NAME = "checkpoint";
-export const CHECKPOINT_TOOL_SCHEMA = {
-    type: "object",
-    properties: {
-        action: {
-            type: "string",
-            enum: ["create", "list", "restore", "diff"],
-            description: "Action: create (snapshot current state), list (show checkpoints), " +
-                "restore (revert to checkpoint), diff (show changes since checkpoint).",
-        },
-        checkpointId: {
-            type: "string",
-            description: "Checkpoint ID. Required for restore and diff.",
-        },
-        message: {
-            type: "string",
-            description: "Optional descriptive message for the checkpoint.",
-        },
-        paths: {
-            type: "array",
-            items: { type: "string" },
-            description: "File paths to restore (partial restore). Omit to restore everything.",
-        },
-    },
-    required: ["action"],
-};
-const COMMIT_HASH_PATTERN = /^[0-9a-fA-F]{4,64}$/;
-export function createCheckpointTool(deps) {
-    return {
-        name: CHECKPOINT_TOOL_NAME,
-        label: "Checkpoint",
-        description: "Manage workspace checkpoints (shadow snapshots independent of user's git). " +
-            "Create snapshots before risky operations, list history, restore on errors, " +
-            "or diff to see what changed. Checkpoints do NOT affect user's .git.",
-        parameters: CHECKPOINT_TOOL_SCHEMA,
-        execute: async (_toolCallId, params) => {
-            switch (params.action) {
-                case "create": {
-                    const r = await deps.createCheckpoint(params.message);
-                    if (!r.success) {
-                        return { content: [{ type: "text", text: `Error: ${r.error}` }], details: { type: "checkpoint", error: r.error } };
-                    }
-                    return {
-                        content: [{ type: "text", text: `Checkpoint created: ${r.checkpoint.id}\nMessage: ${r.checkpoint.message}\nFiles: ${r.checkpoint.fileCount}` }],
-                        details: { type: "checkpoint", action: "create", checkpointId: r.checkpoint.id },
-                    };
-                }
-                case "list": {
-                    const r = await deps.listCheckpoints();
-                    if (!r.checkpoints || r.checkpoints.length === 0) {
-                        return { content: [{ type: "text", text: "No checkpoints available." }], details: { type: "checkpoint", action: "list", count: 0 } };
-                    }
-                    const lines = [`Checkpoints (${r.checkpoints.length}):`, ""];
-                    for (const cp of r.checkpoints) {
-                        lines.push(`- ${cp.id.slice(0, 8)} [${cp.timestamp}] ${cp.message} (${cp.fileCount} files)`);
-                    }
-                    return { content: [{ type: "text", text: lines.join("\n") }], details: { type: "checkpoint", action: "list", count: r.checkpoints.length } };
-                }
-                case "restore": {
-                    if (!params.checkpointId) {
-                        return { content: [{ type: "text", text: "Error: checkpointId required for restore." }], details: { type: "checkpoint", error: "missing_id" } };
-                    }
-                    if (!COMMIT_HASH_PATTERN.test(params.checkpointId)) {
-                        return { content: [{ type: "text", text: "Error: invalid checkpoint ID format." }], details: { type: "checkpoint", error: "invalid_id" } };
-                    }
-                    const r = await deps.restoreCheckpoint(params.checkpointId, params.paths);
-                    if (!r.success) {
-                        return { content: [{ type: "text", text: `Error: ${r.error}` }], details: { type: "checkpoint", error: r.error } };
-                    }
-                    const scope = params.paths ? `(${params.paths.length} files)` : "(full workspace)";
-                    return {
-                        content: [{ type: "text", text: `Restored to checkpoint ${params.checkpointId.slice(0, 8)} ${scope}` }],
-                        details: { type: "checkpoint", action: "restore", checkpointId: params.checkpointId },
-                    };
-                }
-                case "diff": {
-                    if (!params.checkpointId) {
-                        return { content: [{ type: "text", text: "Error: checkpointId required for diff." }], details: { type: "checkpoint", error: "missing_id" } };
-                    }
-                    if (!COMMIT_HASH_PATTERN.test(params.checkpointId)) {
-                        return { content: [{ type: "text", text: "Error: invalid checkpoint ID format." }], details: { type: "checkpoint", error: "invalid_id" } };
-                    }
-                    const r = await deps.diffCheckpoint(params.checkpointId);
-                    if (!r.success) {
-                        return { content: [{ type: "text", text: `Error: ${r.error}` }], details: { type: "checkpoint", error: r.error } };
-                    }
-                    return {
-                        content: [{ type: "text", text: r.diff || "(no changes since checkpoint)" }],
-                        details: { type: "checkpoint", action: "diff", checkpointId: params.checkpointId },
-                    };
-                }
-                default:
-                    return { content: [{ type: "text", text: `Error: unknown action "${params.action}".` }], details: { type: "checkpoint", error: "unknown_action" } };
-            }
-        },
-    };
-}

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

@@ -1,143 +0,0 @@
-// ============================================================
-// Config Tool — agent configuration management (read/write preferences).
-// Reference: claude-code-haha/src/tools/ConfigTool/ConfigTool.ts
-// Category: system
-// ============================================================
-export const CONFIG_TOOL_NAME = "config";
-export const CONFIG_TOOL_SCHEMA = {
-    type: "object",
-    properties: {
-        action: {
-            type: "string",
-            enum: ["get", "set", "list", "reset"],
-            description: "Action:\n" +
-                "- get: Read a config setting\n" +
-                "- set: Write a config setting\n" +
-                "- list: List all available settings\n" +
-                "- reset: Reset a setting to default",
-        },
-        key: {
-            type: "string",
-            description: "Config key path (e.g. 'model', 'language', 'theme', 'permissions.defaultMode'). " +
-                "Required for get/set/reset.",
-        },
-        value: {
-            description: "Value to set. Type depends on the setting. Required for 'set' action.",
-        },
-    },
-    required: ["action"],
-};
-/** Keys that cannot be modified by LLM (security-critical) */
-export const CONFIG_READONLY_KEYS = [
-    "permissions.securityPolicy",
-    "api.key",
-    "api.secret",
-    "auth.token",
-    "system.adminMode",
-];
-export function createConfigTool(deps) {
-    return {
-        name: CONFIG_TOOL_NAME,
-        label: "Config",
-        description: "Read and write agent configuration settings. " +
-            "Supports preferences like model selection, language, theme, tool enablement, etc. " +
-            "Security-critical settings (API keys, permissions) are read-only. " +
-            "Changes persist across sessions.",
-        parameters: CONFIG_TOOL_SCHEMA,
-        execute: async (_toolCallId, params) => {
-            switch (params.action) {
-                case "get": {
-                    if (!params.key) {
-                        return { content: [{ type: "text", text: "Error: key is required for get." }], details: { type: "config", error: "missing_key" } };
-                    }
-                    if (deps.isValidKey && !deps.isValidKey(params.key)) {
-                        return { content: [{ type: "text", text: `Error: unknown config key "${params.key}". Use action='list' to see available settings.` }], details: { type: "config", error: "unknown_key" } };
-                    }
-                    const result = await deps.getConfig(params.key);
-                    if (!result.success) {
-                        return { content: [{ type: "text", text: `Error: ${result.error}` }], details: { type: "config", error: result.error } };
-                    }
-                    const s = result.setting;
-                    const lines = [
-                        `${s.key} = ${JSON.stringify(s.value)}`,
-                        `  Type: ${s.type}${s.options ? ` (${s.options.join(" | ")})` : ""}`,
-                        `  ${s.description}`,
-                    ];
-                    if (s.readOnly)
-                        lines.push("  ⚠️ Read-only (cannot be changed)");
-                    return {
-                        content: [{ type: "text", text: lines.join("\n") }],
-                        details: { type: "config", action: "get", key: params.key, value: s.value },
-                    };
-                }
-                case "set": {
-                    if (!params.key) {
-                        return { content: [{ type: "text", text: "Error: key is required for set." }], details: { type: "config", error: "missing_key" } };
-                    }
-                    if (params.value === undefined) {
-                        return { content: [{ type: "text", text: "Error: value is required for set." }], details: { type: "config", error: "missing_value" } };
-                    }
-                    // Block security-critical keys
-                    if (CONFIG_READONLY_KEYS.includes(params.key)) {
-                        return {
-                            content: [{ type: "text", text: `Error: "${params.key}" is a security-critical setting and cannot be modified.` }],
-                            details: { type: "config", error: "readonly_key" },
-                        };
-                    }
-                    if (deps.isValidKey && !deps.isValidKey(params.key)) {
-                        return { content: [{ type: "text", text: `Error: unknown config key "${params.key}".` }], details: { type: "config", error: "unknown_key" } };
-                    }
-                    const result = await deps.setConfig(params.key, params.value);
-                    if (!result.success) {
-                        return { content: [{ type: "text", text: `Error: ${result.error}` }], details: { type: "config", error: result.error } };
-                    }
-                    return {
-                        content: [{ type: "text", text: `Updated "${params.key}": ${JSON.stringify(result.previousValue)} → ${JSON.stringify(params.value)}` }],
-                        details: { type: "config", action: "set", key: params.key, previousValue: result.previousValue, newValue: params.value },
-                    };
-                }
-                case "list": {
-                    const result = await deps.listConfig();
-                    if (!result.settings || result.settings.length === 0) {
-                        return { content: [{ type: "text", text: "No config settings available." }], details: { type: "config", action: "list", count: 0 } };
-                    }
-                    const lines = [`Available settings (${result.settings.length}):`, ""];
-                    for (const s of result.settings) {
-                        const ro = s.readOnly ? " [read-only]" : "";
-                        const val = JSON.stringify(s.value);
-                        lines.push(`  ${s.key} = ${val}${ro}`);
-                        lines.push(`    ${s.description}`);
-                    }
-                    return {
-                        content: [{ type: "text", text: lines.join("\n") }],
-                        details: { type: "config", action: "list", count: result.settings.length },
-                    };
-                }
-                case "reset": {
-                    if (!params.key) {
-                        return { content: [{ type: "text", text: "Error: key is required for reset." }], details: { type: "config", error: "missing_key" } };
-                    }
-                    if (CONFIG_READONLY_KEYS.includes(params.key)) {
-                        return {
-                            content: [{ type: "text", text: `Error: "${params.key}" cannot be reset (security-critical).` }],
-                            details: { type: "config", error: "readonly_key" },
-                        };
-                    }
-                    const result = await deps.resetConfig(params.key);
-                    if (!result.success) {
-                        return { content: [{ type: "text", text: `Error: ${result.error}` }], details: { type: "config", error: result.error } };
-                    }
-                    return {
-                        content: [{ type: "text", text: `Reset "${params.key}" to default: ${JSON.stringify(result.setting?.value)}` }],
-                        details: { type: "config", action: "reset", key: params.key, value: result.setting?.value },
-                    };
-                }
-                default:
-                    return {
-                        content: [{ type: "text", text: `Error: unknown action "${params.action}".` }],
-                        details: { type: "config", error: "unknown_action" },
-                    };
-            }
-        },
-    };
-}

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

@@ -1,175 +0,0 @@
-// ============================================================
-// Cron Tool — scheduled task management (CRUD).
-// Reference: hermes-agent-main/tools/cronjob_tools.py
-// Category: system
-// ============================================================
-export const CRON_TOOL_NAME = "cron";
-export const CRON_TOOL_SCHEMA = {
-    type: "object",
-    properties: {
-        action: {
-            type: "string",
-            enum: ["create", "list", "get", "update", "delete", "pause", "resume", "trigger"],
-            description: "CRUD action: create/list/get/update/delete/pause/resume/trigger.",
-        },
-        jobId: {
-            type: "string",
-            description: "Job ID. Required for get/update/delete/pause/resume/trigger.",
-        },
-        prompt: {
-            type: "string",
-            description: "Task prompt to execute on schedule. Required for create.",
-        },
-        schedule: {
-            type: "string",
-            description: "Schedule expression. Supports:\n" +
-                "- Cron: '0 9 * * *' (every day at 9am)\n" +
-                "- Shorthand: '5m' (every 5 min), '1h' (hourly), '1d' (daily)\n" +
-                "Required for create.",
-        },
-        name: {
-            type: "string",
-            description: "Human-readable job name.",
-        },
-        repeat: {
-            type: "number",
-            description: "Number of times to repeat (null = infinite). Default: null.",
-        },
-        allowedTools: {
-            type: "array",
-            items: { type: "string" },
-            description: "Tools the scheduled task is allowed to use.",
-        },
-        enabled: {
-            type: "boolean",
-            description: "Whether the job is enabled (for update).",
-        },
-    },
-    required: ["action"],
-};
-export const MAX_CRON_JOBS = 50;
-export function createCronTool(deps) {
-    return {
-        name: CRON_TOOL_NAME,
-        label: "Cron",
-        description: "Manage scheduled tasks. Create recurring jobs with cron expressions or shorthand " +
-            "('5m', '1h', '0 9 * * *'). Jobs persist locally and survive restarts. " +
-            "Actions: create, list, get, update, delete, pause, resume, trigger (run now).",
-        parameters: CRON_TOOL_SCHEMA,
-        execute: async (_toolCallId, params) => {
-            switch (params.action) {
-                case "create": {
-                    if (!params.prompt) {
-                        return { content: [{ type: "text", text: "Error: prompt is required for create." }], details: { type: "cron", error: "missing_prompt" } };
-                    }
-                    if (!params.schedule) {
-                        return { content: [{ type: "text", text: "Error: schedule is required for create." }], details: { type: "cron", error: "missing_schedule" } };
-                    }
-                    if (deps.validateSchedule) {
-                        const err = deps.validateSchedule(params.schedule);
-                        if (err)
-                            return { content: [{ type: "text", text: `Error: invalid schedule — ${err}` }], details: { type: "cron", error: "invalid_schedule" } };
-                    }
-                    // Check max jobs limit
-                    const existing = await deps.listJobs();
-                    if (existing.jobs && existing.jobs.length >= MAX_CRON_JOBS) {
-                        return { content: [{ type: "text", text: `Error: maximum ${MAX_CRON_JOBS} jobs reached. Delete unused jobs first.` }], details: { type: "cron", error: "max_jobs_reached" } };
-                    }
-                    const r = await deps.createJob({ prompt: params.prompt, schedule: params.schedule, name: params.name, repeat: params.repeat, allowedTools: params.allowedTools });
-                    if (!r.success)
-                        return { content: [{ type: "text", text: `Error: ${r.error}` }], details: { type: "cron", error: r.error } };
-                    return { content: [{ type: "text", text: formatJob(r.job) }], details: { type: "cron", action: "create", jobId: r.job.id } };
-                }
-                case "list": {
-                    const r = await deps.listJobs();
-                    if (!r.jobs || r.jobs.length === 0) {
-                        return { content: [{ type: "text", text: "No scheduled jobs." }], details: { type: "cron", action: "list", count: 0 } };
-                    }
-                    const lines = [`Scheduled jobs (${r.jobs.length}):`, ""];
-                    for (const j of r.jobs) {
-                        lines.push(`- **${j.name || j.id}** [${j.state}] ${j.scheduleDisplay} — next: ${j.nextRunAt || "N/A"}`);
-                    }
-                    return { content: [{ type: "text", text: lines.join("\n") }], details: { type: "cron", action: "list", count: r.jobs.length } };
-                }
-                case "get": {
-                    if (!params.jobId)
-                        return { content: [{ type: "text", text: "Error: jobId required." }], details: { type: "cron", error: "missing_jobId" } };
-                    const r = await deps.getJob(params.jobId);
-                    if (!r.success)
-                        return { content: [{ type: "text", text: `Error: ${r.error}` }], details: { type: "cron", error: r.error } };
-                    return { content: [{ type: "text", text: formatJob(r.job) }], details: { type: "cron", action: "get", jobId: params.jobId } };
-                }
-                case "update": {
-                    if (!params.jobId)
-                        return { content: [{ type: "text", text: "Error: jobId required." }], details: { type: "cron", error: "missing_jobId" } };
-                    const updates = {};
-                    if (params.prompt !== undefined)
-                        updates.prompt = params.prompt;
-                    if (params.schedule !== undefined)
-                        updates.schedule = params.schedule;
-                    if (params.name !== undefined)
-                        updates.name = params.name;
-                    if (params.enabled !== undefined)
-                        updates.enabled = params.enabled;
-                    if (params.repeat !== undefined)
-                        updates.repeat = params.repeat;
-                    if (params.allowedTools !== undefined)
-                        updates.allowedTools = params.allowedTools;
-                    const r = await deps.updateJob(params.jobId, updates);
-                    if (!r.success)
-                        return { content: [{ type: "text", text: `Error: ${r.error}` }], details: { type: "cron", error: r.error } };
-                    return { content: [{ type: "text", text: `Job updated.\n${formatJob(r.job)}` }], details: { type: "cron", action: "update", jobId: params.jobId } };
-                }
-                case "delete": {
-                    if (!params.jobId)
-                        return { content: [{ type: "text", text: "Error: jobId required." }], details: { type: "cron", error: "missing_jobId" } };
-                    const r = await deps.deleteJob(params.jobId);
-                    if (!r.success)
-                        return { content: [{ type: "text", text: `Error: ${r.error}` }], details: { type: "cron", error: r.error } };
-                    return { content: [{ type: "text", text: `Job ${params.jobId} deleted.` }], details: { type: "cron", action: "delete", jobId: params.jobId } };
-                }
-                case "pause": {
-                    if (!params.jobId)
-                        return { content: [{ type: "text", text: "Error: jobId required." }], details: { type: "cron", error: "missing_jobId" } };
-                    const r = await deps.pauseJob(params.jobId);
-                    if (!r.success)
-                        return { content: [{ type: "text", text: `Error: ${r.error}` }], details: { type: "cron", error: r.error } };
-                    return { content: [{ type: "text", text: `Job ${params.jobId} paused.` }], details: { type: "cron", action: "pause", jobId: params.jobId } };
-                }
-                case "resume": {
-                    if (!params.jobId)
-                        return { content: [{ type: "text", text: "Error: jobId required." }], details: { type: "cron", error: "missing_jobId" } };
-                    const r = await deps.resumeJob(params.jobId);
-                    if (!r.success)
-                        return { content: [{ type: "text", text: `Error: ${r.error}` }], details: { type: "cron", error: r.error } };
-                    return { content: [{ type: "text", text: `Job ${params.jobId} resumed.` }], details: { type: "cron", action: "resume", jobId: params.jobId } };
-                }
-                case "trigger": {
-                    if (!params.jobId)
-                        return { content: [{ type: "text", text: "Error: jobId required." }], details: { type: "cron", error: "missing_jobId" } };
-                    const r = await deps.triggerJob(params.jobId);
-                    if (!r.success)
-                        return { content: [{ type: "text", text: `Error: ${r.error}` }], details: { type: "cron", error: r.error } };
-                    return { content: [{ type: "text", text: `Job ${params.jobId} triggered (running now).` }], details: { type: "cron", action: "trigger", jobId: params.jobId } };
-                }
-                default:
-                    return { content: [{ type: "text", text: `Error: unknown action "${params.action}".` }], details: { type: "cron", error: "unknown_action" } };
-            }
-        },
-    };
-}
-function formatJob(job) {
-    const lines = [
-        `Job: ${job.name || job.id}`,
-        `ID: ${job.id}`,
-        `Schedule: ${job.scheduleDisplay} (${job.schedule})`,
-        `State: ${job.state}`,
-        `Repeat: ${job.repeat.times === null ? "infinite" : `${job.repeat.completed}/${job.repeat.times}`}`,
-    ];
-    if (job.nextRunAt)
-        lines.push(`Next run: ${job.nextRunAt}`);
-    if (job.lastRunAt)
-        lines.push(`Last run: ${job.lastRunAt} (${job.lastStatus || "unknown"})`);
-    lines.push(`Prompt: ${job.prompt.slice(0, 100)}${job.prompt.length > 100 ? "..." : ""}`);
-    return lines.join("\n");
-}

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

@@ -1,70 +0,0 @@
-// ============================================================
-// File Edit Tool — surgical text replacement in files.
-// Category: coding
-// ============================================================
-export const EDIT_TOOL_NAME = "edit";
-export const EDIT_TOOL_SCHEMA = {
-    type: "object",
-    properties: {
-        path: {
-            type: "string",
-            description: "Path to the file to edit (relative or absolute).",
-        },
-        oldText: {
-            type: "string",
-            description: "Exact text to find and replace (must match exactly, including whitespace).",
-        },
-        newText: {
-            type: "string",
-            description: "New text to replace the old text with.",
-        },
-    },
-    required: ["path", "oldText", "newText"],
-};
-export function createEditTool(deps) {
-    return {
-        name: EDIT_TOOL_NAME,
-        label: "Edit File",
-        description: "Edit a file by replacing exact text. The oldText must match exactly (including whitespace). " +
-            "Use this for precise, surgical edits. For multiple edits, call this tool multiple times.",
-        parameters: EDIT_TOOL_SCHEMA,
-        execute: async (_toolCallId, params) => {
-            const resolved = deps.resolvePath(params.path);
-            // Concurrent modification check
-            if (deps.checkConcurrentModification) {
-                const conflict = deps.checkConcurrentModification(resolved);
-                if (conflict) {
-                    return {
-                        content: [{ type: "text", text: `Concurrent modification detected: ${conflict}. Re-read the file first.` }],
-                        details: { type: "edit", path: resolved, success: false, reason: "concurrent_modification" },
-                    };
-                }
-            }
-            const content = await deps.readFile(resolved);
-            const index = content.indexOf(params.oldText);
-            if (index === -1) {
-                return {
-                    content: [{ type: "text", text: `Error: oldText not found in ${resolved}. Ensure it matches exactly.` }],
-                    details: { type: "edit", path: resolved, success: false, reason: "not_found" },
-                };
-            }
-            // Check for multiple matches
-            const secondIndex = content.indexOf(params.oldText, index + 1);
-            if (secondIndex !== -1) {
-                return {
-                    content: [{ type: "text", text: `Error: oldText matches multiple locations in ${resolved}. Include more context to make the match unique.` }],
-                    details: { type: "edit", path: resolved, success: false, reason: "ambiguous" },
-                };
-            }
-            const newContent = content.slice(0, index) + params.newText + content.slice(index + params.oldText.length);
-            await deps.writeFile(resolved, newContent);
-            // Compute first changed line
-            const preLines = content.slice(0, index).split("\n");
-            const firstChangedLine = preLines.length;
-            return {
-                content: [{ type: "text", text: `Edited ${resolved} (line ${firstChangedLine})` }],
-                details: { type: "edit", path: resolved, success: true, firstChangedLine },
-            };
-        },
-    };
-}