qlogicagent 0.2.1 → 0.4.0

package/dist/skills/tools/web-search-tool.d.ts

@@ -1,57 +0,0 @@
-import type { PortableTool } from "../portable-tool.js";
-export declare const WEB_SEARCH_TOOL_NAME: "web_search";
-export interface WebSearchToolParams {
-    query: string;
-    allowedDomains?: string[];
-    blockedDomains?: string[];
-}
-export declare const WEB_SEARCH_TOOL_SCHEMA: {
-    readonly type: "object";
-    readonly properties: {
-        readonly query: {
-            readonly type: "string";
-            readonly description: "Search query string. Be specific and concise for best results.";
-        };
-        readonly allowedDomains: {
-            readonly type: "array";
-            readonly items: {
-                readonly type: "string";
-            };
-            readonly description: string;
-        };
-        readonly blockedDomains: {
-            readonly type: "array";
-            readonly items: {
-                readonly type: "string";
-            };
-            readonly description: "Exclude results from these domains. Cannot be used together with allowedDomains.";
-        };
-    };
-    readonly required: readonly ["query"];
-};
-export interface WebSearchResult {
-    title: string;
-    url: string;
-    snippet: string;
-}
-export interface WebSearchOutput {
-    query: string;
-    results: WebSearchResult[];
-    totalResults?: number;
-}
-/**
- * Host-provided web search backend.
- * The host may use any search engine (SearXNG, Brave, Tavily, etc.).
- */
-export interface WebSearchToolDeps {
-    /**
-     * Execute a web search and return results.
-     * The host is responsible for API key management and rate limiting.
-     */
-    search(query: string, options?: {
-        allowedDomains?: string[];
-        blockedDomains?: string[];
-        maxResults?: number;
-    }): Promise<WebSearchOutput>;
-}
-export declare function createWebSearchTool(deps: WebSearchToolDeps): PortableTool<WebSearchToolParams>;

package/dist/skills/tools/web-search-tool.js

@@ -1,86 +0,0 @@
-// ============================================================
-// Web Search Tool — search the web for information.
-// Reference: claude-code-haha/src/tools/WebSearchTool/WebSearchTool.ts
-//            hermes-agent-2026.4.30/tools/web_tools.py
-// Category: web
-// ============================================================
-export const WEB_SEARCH_TOOL_NAME = "web_search";
-export const WEB_SEARCH_TOOL_SCHEMA = {
-    type: "object",
-    properties: {
-        query: {
-            type: "string",
-            description: "Search query string. Be specific and concise for best results.",
-        },
-        allowedDomains: {
-            type: "array",
-            items: { type: "string" },
-            description: "Only include results from these domains (e.g. ['docs.python.org', 'stackoverflow.com']). " +
-                "Cannot be used together with blockedDomains.",
-        },
-        blockedDomains: {
-            type: "array",
-            items: { type: "string" },
-            description: "Exclude results from these domains. Cannot be used together with allowedDomains.",
-        },
-    },
-    required: ["query"],
-};
-const MAX_RESULTS = 10;
-export function createWebSearchTool(deps) {
-    return {
-        name: WEB_SEARCH_TOOL_NAME,
-        label: "Web Search",
-        description: "Search the web for current information. Returns top results with title, URL, and snippet. " +
-            "Use this when you need up-to-date information that may not be in your training data. " +
-            "You MUST include source URLs as markdown links when citing search results.",
-        parameters: WEB_SEARCH_TOOL_SCHEMA,
-        execute: async (_toolCallId, params) => {
-            // Validate mutual exclusivity
-            if (params.allowedDomains?.length && params.blockedDomains?.length) {
-                return {
-                    content: [{ type: "text", text: "Error: allowedDomains and blockedDomains cannot both be specified." }],
-                    details: { type: "web_search", error: "mutual_exclusion" },
-                };
-            }
-            // Validate query
-            if (!params.query || params.query.trim().length < 2) {
-                return {
-                    content: [{ type: "text", text: "Error: query must be at least 2 characters." }],
-                    details: { type: "web_search", error: "invalid_query" },
-                };
-            }
-            const output = await deps.search(params.query.trim(), {
-                allowedDomains: params.allowedDomains,
-                blockedDomains: params.blockedDomains,
-                maxResults: MAX_RESULTS,
-            });
-            if (output.results.length === 0) {
-                return {
-                    content: [{ type: "text", text: `No results found for: "${params.query}"` }],
-                    details: { type: "web_search", query: params.query, resultCount: 0 },
-                };
-            }
-            const lines = [
-                `Web search results for: "${output.query}"`,
-                "",
-                "REMINDER: You MUST include source URLs as markdown links when referencing these results.",
-                "",
-            ];
-            for (let i = 0; i < output.results.length; i++) {
-                const r = output.results[i];
-                lines.push(`${i + 1}. [${r.title}](${r.url})`);
-                lines.push(`   ${r.snippet}`);
-                lines.push("");
-            }
-            return {
-                content: [{ type: "text", text: lines.join("\n") }],
-                details: {
-                    type: "web_search",
-                    query: output.query,
-                    resultCount: output.results.length,
-                },
-            };
-        },
-    };
-}

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

@@ -1,69 +0,0 @@
-import type { PortableTool } from "../portable-tool.js";
-export declare const WORKTREE_TOOL_NAME: "worktree";
-export type WorktreeAction = "enter" | "exit" | "list";
-export interface WorktreeToolParams {
-    /** Action: enter (create worktree), exit (leave worktree), list (show all) */
-    action: WorktreeAction;
-    /** Branch/worktree name (for enter). kebab-case, max 64 chars. */
-    name?: string;
-    /** For exit: 'keep' retains the worktree, 'remove' deletes it */
-    exitAction?: "keep" | "remove";
-    /** Required true to discard uncommitted changes on exit with remove */
-    discardChanges?: boolean;
-}
-export declare const WORKTREE_TOOL_SCHEMA: {
-    readonly type: "object";
-    readonly properties: {
-        readonly action: {
-            readonly type: "string";
-            readonly enum: readonly ["enter", "exit", "list"];
-            readonly description: string;
-        };
-        readonly name: {
-            readonly type: "string";
-            readonly description: string;
-        };
-        readonly exitAction: {
-            readonly type: "string";
-            readonly enum: readonly ["keep", "remove"];
-            readonly description: "For exit: 'keep' retains the worktree for later use; 'remove' deletes it.";
-        };
-        readonly discardChanges: {
-            readonly type: "boolean";
-            readonly description: string;
-        };
-    };
-    readonly required: readonly ["action"];
-};
-export interface WorktreeInfo {
-    name: string;
-    path: string;
-    branch: string;
-    isCurrent: boolean;
-    hasChanges: boolean;
-    unpushedCommits: number;
-}
-export interface WorktreeResult {
-    success: boolean;
-    worktree?: WorktreeInfo;
-    worktrees?: WorktreeInfo[];
-    previousCwd?: string;
-    error?: string;
-}
-/**
- * Host-provided git worktree backend.
- * Manages worktree creation, switching, and cleanup.
- */
-export interface WorktreeToolDeps {
-    /** Create a new worktree and switch session cwd */
-    enterWorktree(name?: string): Promise<WorktreeResult>;
-    /** Exit worktree (keep or remove) */
-    exitWorktree(action: "keep" | "remove", discardChanges?: boolean): Promise<WorktreeResult>;
-    /** List all worktrees */
-    listWorktrees(): Promise<WorktreeResult>;
-    /** Check if currently in a worktree */
-    isInWorktree(): boolean;
-    /** Get current worktree info */
-    currentWorktree?(): WorktreeInfo | null;
-}
-export declare function createWorktreeTool(deps: WorktreeToolDeps): PortableTool<WorktreeToolParams>;

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

@@ -1,147 +0,0 @@
-// ============================================================
-// Worktree Tool — git worktree isolation for parallel development.
-// Reference: claude-code-haha/src/tools/EnterWorktreeTool/EnterWorktreeTool.ts
-//            claude-code-haha/src/tools/ExitWorktreeTool/ExitWorktreeTool.ts
-// Category: system (git)
-// Dependency: #13 AgentTool
-// ============================================================
-export const WORKTREE_TOOL_NAME = "worktree";
-export const WORKTREE_TOOL_SCHEMA = {
-    type: "object",
-    properties: {
-        action: {
-            type: "string",
-            enum: ["enter", "exit", "list"],
-            description: "enter: Create and switch to an isolated git worktree branch.\n" +
-                "exit: Leave worktree (keep or remove it).\n" +
-                "list: Show all active worktrees.",
-        },
-        name: {
-            type: "string",
-            description: "Worktree/branch name (for enter). Must be kebab-case, max 64 characters. " +
-                "If omitted, auto-generated from task context.",
-        },
-        exitAction: {
-            type: "string",
-            enum: ["keep", "remove"],
-            description: "For exit: 'keep' retains the worktree for later use; 'remove' deletes it.",
-        },
-        discardChanges: {
-            type: "boolean",
-            description: "Required true to confirm discarding uncommitted changes when exitAction='remove'. " +
-                "Safety mechanism to prevent data loss.",
-        },
-    },
-    required: ["action"],
-};
-const NAME_PATTERN = /^[a-z0-9][a-z0-9-]{0,62}[a-z0-9]?$/;
-export function createWorktreeTool(deps) {
-    return {
-        name: WORKTREE_TOOL_NAME,
-        label: "Git Worktree",
-        description: "Create isolated git worktree branches for parallel development. " +
-            "Each worktree has its own working directory independent of the main branch. " +
-            "Use for: parallel features, safe experimentation, sub-agent isolation. " +
-            "Exit to keep or remove the worktree when done.",
-        parameters: WORKTREE_TOOL_SCHEMA,
-        execute: async (_toolCallId, params) => {
-            switch (params.action) {
-                case "enter": {
-                    if (deps.isInWorktree()) {
-                        return {
-                            content: [{ type: "text", text: "Error: already in a worktree. Exit first before entering another." }],
-                            details: { type: "worktree", error: "already_in_worktree" },
-                        };
-                    }
-                    if (params.name && !NAME_PATTERN.test(params.name)) {
-                        return {
-                            content: [{ type: "text", text: "Error: name must be kebab-case (a-z, 0-9, hyphens), 2-64 characters." }],
-                            details: { type: "worktree", error: "invalid_name" },
-                        };
-                    }
-                    const result = await deps.enterWorktree(params.name);
-                    if (!result.success) {
-                        return {
-                            content: [{ type: "text", text: `Error: ${result.error || "failed to create worktree"}` }],
-                            details: { type: "worktree", error: result.error },
-                        };
-                    }
-                    const wt = result.worktree;
-                    const lines = [
-                        `Entered worktree: ${wt.name}`,
-                        `  Branch: ${wt.branch}`,
-                        `  Path: ${wt.path}`,
-                        "",
-                        "Working in isolated branch. Changes here do not affect the main branch.",
-                        "Use action='exit' when done (keep or remove).",
-                    ];
-                    return {
-                        content: [{ type: "text", text: lines.join("\n") }],
-                        details: { type: "worktree", action: "enter", name: wt.name, branch: wt.branch, path: wt.path },
-                    };
-                }
-                case "exit": {
-                    if (!deps.isInWorktree()) {
-                        return {
-                            content: [{ type: "text", text: "Error: not in a worktree." }],
-                            details: { type: "worktree", error: "not_in_worktree" },
-                        };
-                    }
-                    const exitAction = params.exitAction || "keep";
-                    // Safety: require explicit discard confirmation for remove with changes
-                    if (exitAction === "remove") {
-                        const current = deps.currentWorktree?.();
-                        if (current && (current.hasChanges || current.unpushedCommits > 0) && !params.discardChanges) {
-                            const warnings = [];
-                            if (current.hasChanges)
-                                warnings.push("uncommitted changes");
-                            if (current.unpushedCommits > 0)
-                                warnings.push(`${current.unpushedCommits} unpushed commit(s)`);
-                            return {
-                                content: [{ type: "text", text: `Error: worktree has ${warnings.join(" and ")}. Set discardChanges=true to confirm removal, or use exitAction='keep'.` }],
-                                details: { type: "worktree", error: "has_changes", hasChanges: current.hasChanges, unpushedCommits: current.unpushedCommits },
-                            };
-                        }
-                    }
-                    const result = await deps.exitWorktree(exitAction, params.discardChanges);
-                    if (!result.success) {
-                        return {
-                            content: [{ type: "text", text: `Error: ${result.error || "failed to exit worktree"}` }],
-                            details: { type: "worktree", error: result.error },
-                        };
-                    }
-                    const action = exitAction === "keep" ? "Worktree kept for later use." : "Worktree removed.";
-                    return {
-                        content: [{ type: "text", text: `Exited worktree. ${action}\nRestored to: ${result.previousCwd || "main workspace"}` }],
-                        details: { type: "worktree", action: "exit", exitAction, previousCwd: result.previousCwd },
-                    };
-                }
-                case "list": {
-                    const result = await deps.listWorktrees();
-                    if (!result.worktrees || result.worktrees.length === 0) {
-                        return {
-                            content: [{ type: "text", text: "No worktrees (only the main working tree)." }],
-                            details: { type: "worktree", action: "list", count: 0 },
-                        };
-                    }
-                    const lines = [`Worktrees (${result.worktrees.length}):`, ""];
-                    for (const wt of result.worktrees) {
-                        const current = wt.isCurrent ? " ← current" : "";
-                        const status = wt.hasChanges ? " (has changes)" : "";
-                        lines.push(`  ${wt.name} [${wt.branch}]${current}${status}`);
-                        lines.push(`    path: ${wt.path}`);
-                    }
-                    return {
-                        content: [{ type: "text", text: lines.join("\n") }],
-                        details: { type: "worktree", action: "list", count: result.worktrees.length },
-                    };
-                }
-                default:
-                    return {
-                        content: [{ type: "text", text: `Error: unknown action "${params.action}".` }],
-                        details: { type: "worktree", error: "unknown_action" },
-                    };
-            }
-        },
-    };
-}

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

@@ -1,45 +0,0 @@
-import type { PortableTool } from "../portable-tool.js";
-export declare const WRITE_TOOL_NAME: "write";
-export interface WriteToolParams {
-    path: string;
-    content: string;
-}
-export declare const WRITE_TOOL_SCHEMA: {
-    readonly type: "object";
-    readonly properties: {
-        readonly path: {
-            readonly type: "string";
-            readonly description: "Absolute path to the file to write.";
-        };
-        readonly content: {
-            readonly type: "string";
-            readonly description: "Content to write to the file.";
-        };
-    };
-    readonly required: readonly ["path", "content"];
-};
-/** Deps injected by the host runtime for file writing. */
-export interface WriteToolDeps {
-    /** Write content to a file. Create parent dirs as needed. */
-    writeFile(path: string, content: string): Promise<void>;
-    /** Resolve a relative path to absolute. */
-    resolvePath(input: string): string;
-    /**
-     * Check if file has been read before writing (first-read-then-write protection).
-     * Returns null if write is allowed, or a warning message.
-     * If not provided, no protection is applied.
-     */
-    checkReadBeforeWrite?(path: string): string | null;
-    /**
-     * Validate write access for the given path.
-     * Returns null if allowed, or an error message if blocked.
-     */
-    validatePath?(path: string): string | null;
-    /**
-     * Check for concurrent modification before overwriting an existing file.
-     * Returns null if safe to write, or a warning if modified since last read.
-     * If not provided, no concurrent modification check is performed.
-     */
-    checkConcurrentModification?(path: string): string | null;
-}
-export declare function createWriteTool(deps: WriteToolDeps): PortableTool<WriteToolParams>;

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

@@ -1,81 +0,0 @@
-// ============================================================
-// File Write Tool — create/overwrite files.
-// Reference: claude-code-haha/src/tools/FileWriteTool/FileWriteTool.ts
-// Category: coding
-// ============================================================
-export const WRITE_TOOL_NAME = "write";
-export const WRITE_TOOL_SCHEMA = {
-    type: "object",
-    properties: {
-        path: {
-            type: "string",
-            description: "Absolute path to the file to write.",
-        },
-        content: {
-            type: "string",
-            description: "Content to write to the file.",
-        },
-    },
-    required: ["path", "content"],
-};
-const MAX_WRITE_SIZE = 500_000; // 500KB safety limit
-export function createWriteTool(deps) {
-    return {
-        name: WRITE_TOOL_NAME,
-        label: "Write File",
-        description: "Write content to a file. Creates the file if it doesn't exist, overwrites if it does. " +
-            "Automatically creates parent directories. " +
-            "Prefer edit/patch for modifying existing files (safer than full overwrite).",
-        parameters: WRITE_TOOL_SCHEMA,
-        execute: async (_toolCallId, params) => {
-            const resolved = deps.resolvePath(params.path);
-            // Validate path access
-            if (deps.validatePath) {
-                const blocked = deps.validatePath(resolved);
-                if (blocked) {
-                    return {
-                        content: [{ type: "text", text: `Access denied: ${blocked}` }],
-                        details: { type: "write", path: resolved, error: "access_denied" },
-                    };
-                }
-            }
-            // Large file protection
-            if (params.content.length > MAX_WRITE_SIZE) {
-                return {
-                    content: [{
-                            type: "text",
-                            text: `Content too large (${params.content.length} chars, max ${MAX_WRITE_SIZE}). ` +
-                                "Split into multiple writes or use a different approach.",
-                        }],
-                    details: { type: "write", path: resolved, error: "content_too_large" },
-                };
-            }
-            // First-read-then-write protection
-            if (deps.checkReadBeforeWrite) {
-                const warning = deps.checkReadBeforeWrite(resolved);
-                if (warning) {
-                    return {
-                        content: [{ type: "text", text: warning }],
-                        details: { type: "write", path: resolved, error: "not_read_first" },
-                    };
-                }
-            }
-            // Concurrent modification detection
-            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: "write", path: resolved, error: "concurrent_modification" },
-                    };
-                }
-            }
-            await deps.writeFile(resolved, params.content);
-            const lineCount = params.content.split("\n").length;
-            return {
-                content: [{ type: "text", text: `Wrote ${lineCount} lines to ${resolved}` }],
-                details: { type: "write", path: resolved, lineCount },
-            };
-        },
-    };
-}