qlogicagent 0.2.1 → 0.4.0

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

@@ -1,95 +0,0 @@
-// ============================================================
-// Brief Tool — "SendUserMessage" equivalent from Claude Code.
-//
-// In brief/chat mode, agent output is not directly visible to
-// the user. Only messages sent through this tool are displayed.
-// This enables clean separation of internal reasoning vs
-// user-facing communication.
-//
-// Reference: claude-code-haha/src/tools/BriefTool/BriefTool.ts
-// Category: interaction
-// ============================================================
-export const BRIEF_TOOL_NAME = "send_user_message";
-export const BRIEF_TOOL_SCHEMA = {
-    type: "object",
-    properties: {
-        message: {
-            type: "string",
-            description: "The message to send to the user. Supports Markdown formatting. " +
-                "This is the ONLY way to communicate with the user in brief/chat mode.",
-            minLength: 1,
-        },
-        attachments: {
-            type: "array",
-            description: "Optional file paths to attach (images, documents, etc.).",
-            items: { type: "string" },
-            maxItems: 10,
-        },
-        status: {
-            type: "string",
-            enum: ["normal", "proactive"],
-            description: "Message status. Use 'proactive' when providing unsolicited information " +
-                "(e.g., monitoring alerts, task completion notifications).",
-        },
-    },
-    required: ["message"],
-};
-export function createBriefTool(deps) {
-    return {
-        name: BRIEF_TOOL_NAME,
-        label: "Send User Message",
-        description: "Send a message to the user. In brief/chat mode this is the ONLY way " +
-            "your messages are visible. Supports Markdown and file attachments. " +
-            "Use 'proactive' status for unsolicited updates (monitoring alerts, " +
-            "task completions). Keep messages concise and useful.",
-        parameters: BRIEF_TOOL_SCHEMA,
-        isConcurrencySafe: true,
-        isReadOnly: true,
-        searchHint: "send message user brief chat communicate display output",
-        execute: async (_toolCallId, params) => {
-            if (!params.message || params.message.trim().length === 0) {
-                return {
-                    content: [{ type: "text", text: "Error: message cannot be empty." }],
-                    details: { type: "brief", error: "empty_message" },
-                };
-            }
-            // Resolve attachments if provided
-            let resolvedAttachments;
-            if (params.attachments && params.attachments.length > 0) {
-                if (deps.resolveAttachments) {
-                    const resolved = await deps.resolveAttachments(params.attachments);
-                    if ("error" in resolved) {
-                        return {
-                            content: [{ type: "text", text: `Attachment error: ${resolved.error}` }],
-                            details: { type: "brief", error: "attachment_resolution_failed" },
-                        };
-                    }
-                    resolvedAttachments = resolved;
-                }
-            }
-            const status = params.status || "normal";
-            const result = await deps.deliverMessage({
-                message: params.message.trim(),
-                attachments: params.attachments,
-                status,
-            });
-            if (!result.delivered) {
-                return {
-                    content: [{ type: "text", text: `Message delivery failed: ${result.error || "unknown error"}` }],
-                    details: { type: "brief", delivered: false, error: result.error },
-                };
-            }
-            // Minimal confirmation — avoids re-echoing message in context (saves tokens)
-            return {
-                content: [{ type: "text", text: "Message delivered to user." }],
-                details: {
-                    type: "brief",
-                    delivered: true,
-                    status,
-                    hasAttachments: (resolvedAttachments?.length ?? 0) > 0,
-                    sentAt: result.sentAt,
-                },
-            };
-        },
-    };
-}

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

@@ -1,114 +0,0 @@
-import type { PortableTool } from "../portable-tool.js";
-export declare const BROWSER_TOOL_NAME: "browser";
-export type BrowserAction = "navigate" | "click" | "type" | "scroll" | "snapshot" | "screenshot" | "console" | "cdp";
-export interface BrowserToolParams {
-    /** Browser action to perform */
-    action: BrowserAction;
-    /** URL for navigate action */
-    url?: string;
-    /** Element reference (e.g. "@e5") for click/type actions */
-    ref?: string;
-    /** Text to type */
-    text?: string;
-    /** Scroll direction */
-    direction?: "up" | "down" | "left" | "right";
-    /** CDP method name for raw cdp action */
-    method?: string;
-    /** CDP params object */
-    params?: Record<string, unknown>;
-    /** JavaScript expression for console eval */
-    expression?: string;
-    /** Whether to include full accessibility tree */
-    full?: boolean;
-}
-export declare const BROWSER_TOOL_SCHEMA: {
-    readonly type: "object";
-    readonly properties: {
-        readonly action: {
-            readonly type: "string";
-            readonly enum: readonly ["navigate", "click", "type", "scroll", "snapshot", "screenshot", "console", "cdp"];
-            readonly description: string;
-        };
-        readonly url: {
-            readonly type: "string";
-            readonly description: "URL to navigate to. Required for 'navigate' action.";
-        };
-        readonly ref: {
-            readonly type: "string";
-            readonly description: "Element reference like \"@e5\" from a previous snapshot. Required for click/type.";
-        };
-        readonly text: {
-            readonly type: "string";
-            readonly description: "Text to type into the referenced element. Required for 'type' action.";
-        };
-        readonly direction: {
-            readonly type: "string";
-            readonly enum: readonly ["up", "down", "left", "right"];
-            readonly description: "Scroll direction. Required for 'scroll' action.";
-        };
-        readonly method: {
-            readonly type: "string";
-            readonly description: "CDP method name (e.g. 'Page.reload'). Required for 'cdp' action.";
-        };
-        readonly params: {
-            readonly type: "object";
-            readonly description: "Parameters for the CDP method. Optional for 'cdp' action.";
-        };
-        readonly expression: {
-            readonly type: "string";
-            readonly description: "JavaScript expression to evaluate. Used with 'console' action.";
-        };
-        readonly full: {
-            readonly type: "boolean";
-            readonly description: "Include full accessibility tree (default: compact). Used with 'snapshot'.";
-        };
-    };
-    readonly required: readonly ["action"];
-};
-export interface BrowserSnapshot {
-    elements: Array<{
-        ref: string;
-        role: string;
-        name: string;
-        text?: string;
-    }>;
-    url: string;
-    title: string;
-}
-export interface BrowserScreenshot {
-    base64: string;
-    mimeType: string;
-    width: number;
-    height: number;
-}
-/**
- * Host-provided browser automation backend.
- * The host manages Chrome/Chromium lifecycle and CDP connections.
- */
-export interface BrowserToolDeps {
-    navigate(url: string): Promise<{
-        snapshot: BrowserSnapshot;
-    }>;
-    click(ref: string): Promise<{
-        success: boolean;
-        error?: string;
-    }>;
-    type(ref: string, text: string): Promise<{
-        success: boolean;
-        error?: string;
-    }>;
-    scroll(direction: "up" | "down" | "left" | "right"): Promise<{
-        success: boolean;
-    }>;
-    snapshot(full?: boolean): Promise<BrowserSnapshot>;
-    screenshot(): Promise<BrowserScreenshot>;
-    consoleEval(expression?: string): Promise<{
-        result?: string;
-        messages?: string[];
-        errors?: string[];
-    }>;
-    cdp(method: string, params?: Record<string, unknown>): Promise<Record<string, unknown>>;
-    /** Validate URL safety (SSRF prevention). Returns error message if blocked, null if safe. */
-    validateUrl(url: string): string | null;
-}
-export declare function createBrowserTool(deps: BrowserToolDeps): PortableTool<BrowserToolParams>;

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

@@ -1,66 +0,0 @@
-import type { PortableTool } from "../portable-tool.js";
-export declare const CHECKPOINT_TOOL_NAME: "checkpoint";
-export type CheckpointAction = "create" | "list" | "restore" | "diff";
-export interface CheckpointToolParams {
-    action: CheckpointAction;
-    /** Checkpoint ID (for restore/diff) */
-    checkpointId?: string;
-    /** Optional message for create */
-    message?: string;
-    /** File paths to restore (partial restore). If empty, restores all. */
-    paths?: string[];
-}
-export declare const CHECKPOINT_TOOL_SCHEMA: {
-    readonly type: "object";
-    readonly properties: {
-        readonly action: {
-            readonly type: "string";
-            readonly enum: readonly ["create", "list", "restore", "diff"];
-            readonly description: string;
-        };
-        readonly checkpointId: {
-            readonly type: "string";
-            readonly description: "Checkpoint ID. Required for restore and diff.";
-        };
-        readonly message: {
-            readonly type: "string";
-            readonly description: "Optional descriptive message for the checkpoint.";
-        };
-        readonly paths: {
-            readonly type: "array";
-            readonly items: {
-                readonly type: "string";
-            };
-            readonly description: "File paths to restore (partial restore). Omit to restore everything.";
-        };
-    };
-    readonly required: readonly ["action"];
-};
-export interface Checkpoint {
-    id: string;
-    message: string;
-    timestamp: string;
-    fileCount: number;
-}
-export interface CheckpointResult {
-    success: boolean;
-    checkpoint?: Checkpoint;
-    checkpoints?: Checkpoint[];
-    diff?: string;
-    error?: string;
-}
-/**
- * Host-provided checkpoint backend.
- * Uses shadow git repos (isolated from user project) for snapshots.
- */
-export interface CheckpointToolDeps {
-    /** Create a snapshot of the current workspace state */
-    createCheckpoint(message?: string): Promise<CheckpointResult>;
-    /** List all available checkpoints */
-    listCheckpoints(): Promise<CheckpointResult>;
-    /** Restore workspace to a checkpoint state (optionally partial) */
-    restoreCheckpoint(checkpointId: string, paths?: string[]): Promise<CheckpointResult>;
-    /** Show diff between current state and a checkpoint */
-    diffCheckpoint(checkpointId: string): Promise<CheckpointResult>;
-}
-export declare function createCheckpointTool(deps: CheckpointToolDeps): PortableTool<CheckpointToolParams>;

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

@@ -1,63 +0,0 @@
-import type { PortableTool } from "../portable-tool.js";
-export declare const CONFIG_TOOL_NAME: "config";
-export type ConfigAction = "get" | "set" | "list" | "reset";
-export interface ConfigToolParams {
-    /** Config action */
-    action: ConfigAction;
-    /** Setting key path (e.g. "model", "language", "theme") */
-    key?: string;
-    /** Value to set (for 'set' action) */
-    value?: string | boolean | number;
-}
-export declare const CONFIG_TOOL_SCHEMA: {
-    readonly type: "object";
-    readonly properties: {
-        readonly action: {
-            readonly type: "string";
-            readonly enum: readonly ["get", "set", "list", "reset"];
-            readonly description: string;
-        };
-        readonly key: {
-            readonly type: "string";
-            readonly description: string;
-        };
-        readonly value: {
-            readonly description: "Value to set. Type depends on the setting. Required for 'set' action.";
-        };
-    };
-    readonly required: readonly ["action"];
-};
-export interface ConfigSetting {
-    key: string;
-    value: unknown;
-    type: "string" | "boolean" | "number" | "enum";
-    description: string;
-    options?: string[];
-    readOnly?: boolean;
-}
-export interface ConfigResult {
-    success: boolean;
-    setting?: ConfigSetting;
-    settings?: ConfigSetting[];
-    previousValue?: unknown;
-    error?: string;
-}
-/** Keys that cannot be modified by LLM (security-critical) */
-export declare const CONFIG_READONLY_KEYS: readonly string[];
-/**
- * Host-provided config backend.
- * Manages persistent agent settings with safety guardrails.
- */
-export interface ConfigToolDeps {
-    /** Get a single config value */
-    getConfig(key: string): Promise<ConfigResult>;
-    /** Set a config value (respects readonly/whitelist) */
-    setConfig(key: string, value: unknown): Promise<ConfigResult>;
-    /** List all available config settings */
-    listConfig(): Promise<ConfigResult>;
-    /** Reset a setting to default */
-    resetConfig(key: string): Promise<ConfigResult>;
-    /** Check if a key is supported/valid */
-    isValidKey?(key: string): boolean;
-}
-export declare function createConfigTool(deps: ConfigToolDeps): PortableTool<ConfigToolParams>;