qlogicagent 0.2.1 → 0.4.0

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

@@ -1,225 +0,0 @@
-// ============================================================
-// Search Tool — unified file name (glob) + content (grep) search.
-// Fuses CC GlobTool + GrepTool into single PortableTool.
-// Reference: claude-code-haha/src/tools/GlobTool/GlobTool.ts
-//            claude-code-haha/src/tools/GrepTool/GrepTool.ts
-// Category: search
-// ============================================================
-export const SEARCH_TOOL_NAME = "search";
-export const SEARCH_TOOL_SCHEMA = {
-    type: "object",
-    properties: {
-        mode: {
-            type: "string",
-            enum: ["filename", "content", "both"],
-            description: 'Search mode: "filename" to find files by name pattern (glob), ' +
-                '"content" to search within file contents (regex), ' +
-                '"both" to match both filename patterns and content simultaneously.',
-        },
-        pattern: {
-            type: "string",
-            description: "The pattern to search for. In filename mode this is a glob pattern " +
-                "(e.g. **/*.ts). In content mode this is a regular expression. " +
-                "In both mode this is treated as a regex for content, and fileGlob " +
-                "filters the filename set.",
-        },
-        path: {
-            type: "string",
-            description: "Directory to search in. Defaults to workdir/cwd if omitted.",
-        },
-        fileGlob: {
-            type: "string",
-            description: 'Glob pattern to filter files (e.g. "*.ts", "*.{js,tsx}"). ' +
-                "In content/both modes, only files matching this glob are searched.",
-        },
-        contextLines: {
-            type: "number",
-            description: "Number of context lines to show before and after each match " +
-                "(content/both modes only). Default: 0.",
-        },
-        caseInsensitive: {
-            type: "boolean",
-            description: "Case insensitive search (content/both modes). Default: false.",
-        },
-        headLimit: {
-            type: "number",
-            description: "Maximum number of result entries to return. Default 100 for filename, " +
-                "250 for content. Pass 0 for unlimited (use sparingly).",
-        },
-        offset: {
-            type: "number",
-            description: "Skip first N results before applying headLimit. Default: 0.",
-        },
-    },
-    required: ["mode", "pattern"],
-};
-// ── Constants ───────────────────────────────────────────────
-const DEFAULT_FILENAME_LIMIT = 100;
-const DEFAULT_CONTENT_LIMIT = 250;
-const MAX_RESULT_CHARS = 100_000;
-// ── Factory ─────────────────────────────────────────────────
-export function createSearchTool(deps) {
-    return {
-        name: SEARCH_TOOL_NAME,
-        label: "Search",
-        description: "Search for files by name, search within file contents by regex, or both. " +
-            "In filename mode, pattern is a glob. In content mode, pattern is a regex. " +
-            "Results are paginated via headLimit + offset.",
-        parameters: SEARCH_TOOL_SCHEMA,
-        execute: async (_toolCallId, params) => {
-            const cwd = params.path
-                ? (deps.resolvePath ? deps.resolvePath(params.path) : params.path)
-                : "";
-            const mode = params.mode;
-            if (mode === "filename") {
-                return executeFilenameSearch(deps, params, cwd);
-            }
-            else if (mode === "content") {
-                return executeContentSearch(deps, params, cwd);
-            }
-            else {
-                // "both" — run filename glob + content grep, merge results
-                return executeBothSearch(deps, params, cwd);
-            }
-        },
-    };
-}
-// ── Filename search ─────────────────────────────────────────
-async function executeFilenameSearch(deps, params, cwd) {
-    const limit = params.headLimit ?? DEFAULT_FILENAME_LIMIT;
-    const { files, truncated } = await deps.glob(params.pattern, {
-        cwd,
-        limit: limit === 0 ? 10000 : limit,
-    });
-    const offset = params.offset ?? 0;
-    const sliced = offset > 0 ? files.slice(offset) : files;
-    const effectiveLimit = limit === 0 ? sliced.length : limit;
-    const finalFiles = sliced.slice(0, effectiveLimit);
-    const wasTruncated = truncated || sliced.length > effectiveLimit;
-    if (finalFiles.length === 0) {
-        return {
-            content: [{ type: "text", text: "No files found matching pattern." }],
-            details: { mode: "filename", totalMatches: 0, truncated: false },
-        };
-    }
-    let text = finalFiles.join("\n");
-    if (wasTruncated) {
-        text += `\n\n(Results truncated. ${finalFiles.length} shown. Use a more specific pattern or increase headLimit.)`;
-    }
-    text = truncateText(text, MAX_RESULT_CHARS);
-    return {
-        content: [{ type: "text", text }],
-        details: {
-            mode: "filename",
-            totalMatches: finalFiles.length,
-            truncated: wasTruncated,
-        },
-    };
-}
-// ── Content search ──────────────────────────────────────────
-async function executeContentSearch(deps, params, cwd) {
-    const headLimit = params.headLimit ?? DEFAULT_CONTENT_LIMIT;
-    const { matches, truncated } = await deps.grep(params.pattern, {
-        cwd,
-        fileGlob: params.fileGlob,
-        caseInsensitive: params.caseInsensitive,
-        contextLines: params.contextLines,
-        headLimit: headLimit === 0 ? undefined : headLimit,
-        offset: params.offset,
-    });
-    if (matches.length === 0) {
-        return {
-            content: [{ type: "text", text: "No matches found." }],
-            details: { mode: "content", totalMatches: 0, truncated: false },
-        };
-    }
-    const lines = [];
-    for (const m of matches) {
-        if (m.contextBefore && m.contextBefore.length > 0) {
-            for (const ctx of m.contextBefore) {
-                lines.push(`  ${ctx}`);
-            }
-        }
-        lines.push(`${m.path}:${m.line}: ${m.text}`);
-        if (m.contextAfter && m.contextAfter.length > 0) {
-            for (const ctx of m.contextAfter) {
-                lines.push(`  ${ctx}`);
-            }
-        }
-        // Separator between match groups when context is present
-        if (params.contextLines && params.contextLines > 0) {
-            lines.push("--");
-        }
-    }
-    let text = lines.join("\n");
-    if (truncated) {
-        text += `\n\n(Results truncated at ${matches.length} matches. Use offset/headLimit for pagination.)`;
-    }
-    text = truncateText(text, MAX_RESULT_CHARS);
-    return {
-        content: [{ type: "text", text }],
-        details: {
-            mode: "content",
-            totalMatches: matches.length,
-            truncated,
-        },
-    };
-}
-// ── Both mode ───────────────────────────────────────────────
-async function executeBothSearch(deps, params, cwd) {
-    // Run both in parallel
-    const [globResult, grepResult] = await Promise.all([
-        params.fileGlob
-            ? deps.glob(params.fileGlob, { cwd, limit: DEFAULT_FILENAME_LIMIT })
-            : Promise.resolve({ files: [], truncated: false }),
-        deps.grep(params.pattern, {
-            cwd,
-            fileGlob: params.fileGlob,
-            caseInsensitive: params.caseInsensitive,
-            contextLines: params.contextLines,
-            headLimit: params.headLimit ?? DEFAULT_CONTENT_LIMIT,
-            offset: params.offset,
-        }),
-    ]);
-    // Deduplicate: files that appear in both glob and grep results
-    const contentFiles = new Set(grepResult.matches.map((m) => m.path));
-    const uniqueGlobFiles = globResult.files.filter((f) => !contentFiles.has(f));
-    const sections = [];
-    if (uniqueGlobFiles.length > 0) {
-        sections.push(`## Files matching glob (${uniqueGlobFiles.length}):\n${uniqueGlobFiles.join("\n")}`);
-    }
-    if (grepResult.matches.length > 0) {
-        const lines = [];
-        for (const m of grepResult.matches) {
-            lines.push(`${m.path}:${m.line}: ${m.text}`);
-        }
-        sections.push(`## Content matches (${grepResult.matches.length}):\n${lines.join("\n")}`);
-    }
-    if (sections.length === 0) {
-        return {
-            content: [{ type: "text", text: "No matches found in either filename or content." }],
-            details: { mode: "both", totalMatches: 0, truncated: false },
-        };
-    }
-    const truncated = globResult.truncated || grepResult.truncated;
-    let text = sections.join("\n\n");
-    if (truncated) {
-        text += "\n\n(Some results truncated. Use more specific patterns.)";
-    }
-    text = truncateText(text, MAX_RESULT_CHARS);
-    return {
-        content: [{ type: "text", text }],
-        details: {
-            mode: "both",
-            totalMatches: uniqueGlobFiles.length + grepResult.matches.length,
-            truncated,
-        },
-    };
-}
-// ── Util ────────────────────────────────────────────────────
-function truncateText(text, limit) {
-    if (text.length <= limit)
-        return text;
-    const half = Math.floor(limit / 2) - 50;
-    return `${text.slice(0, half)}\n\n... [truncated ${text.length - limit} chars] ...\n\n${text.slice(-half)}`;
-}

package/dist/skills/tools/send-message-tool.d.ts

@@ -1,51 +0,0 @@
-import type { PortableTool } from "../portable-tool.js";
-export declare const SEND_MESSAGE_TOOL_NAME: "send_message";
-export interface SendMessageToolParams {
-    /** Target agent name or '*' for broadcast */
-    to: string;
-    /** Message content */
-    message: string;
-    /** Optional short summary for routing/display */
-    summary?: string;
-}
-export declare const SEND_MESSAGE_TOOL_SCHEMA: {
-    readonly type: "object";
-    readonly properties: {
-        readonly to: {
-            readonly type: "string";
-            readonly description: string;
-        };
-        readonly message: {
-            readonly type: "string";
-            readonly description: "Message content to send to the target agent.";
-        };
-        readonly summary: {
-            readonly type: "string";
-            readonly description: "Optional short summary (for logging/routing).";
-        };
-    };
-    readonly required: readonly ["to", "message"];
-};
-export interface SendMessageResult {
-    success: boolean;
-    recipients?: string[];
-    error?: string;
-}
-/**
- * Host-provided message routing backend.
- * Messages are delivered asynchronously via mailbox pattern.
- */
-export interface SendMessageToolDeps {
-    /** Send message to target agent(s). Returns delivery status. */
-    sendMessage(params: {
-        to: string;
-        message: string;
-        summary?: string;
-        senderId: string;
-    }): Promise<SendMessageResult>;
-    /** Get the current agent's ID */
-    getSenderId(): string;
-    /** List available teammates */
-    listTeammates?(): string[];
-}
-export declare function createSendMessageTool(deps: SendMessageToolDeps): PortableTool<SendMessageToolParams>;

package/dist/skills/tools/send-message-tool.js

@@ -1,76 +0,0 @@
-// ============================================================
-// Send Message Tool — agent-to-agent IPC within a team/swarm.
-// Reference: claude-code-haha/src/tools/SendMessageTool/SendMessageTool.ts
-//            hermes-agent-main/tools/send_message_tool.py
-// Category: system
-// ============================================================
-export const SEND_MESSAGE_TOOL_NAME = "send_message";
-export const SEND_MESSAGE_TOOL_SCHEMA = {
-    type: "object",
-    properties: {
-        to: {
-            type: "string",
-            description: "Target agent name or '*' for broadcast to all team members. " +
-                "Must be a valid agent name within the current team.",
-        },
-        message: {
-            type: "string",
-            description: "Message content to send to the target agent.",
-        },
-        summary: {
-            type: "string",
-            description: "Optional short summary (for logging/routing).",
-        },
-    },
-    required: ["to", "message"],
-};
-export function createSendMessageTool(deps) {
-    return {
-        name: SEND_MESSAGE_TOOL_NAME,
-        label: "Send Message",
-        description: "Send a message to another agent in your team. Use '*' to broadcast to all teammates. " +
-            "Messages are delivered asynchronously. Use for coordination, delegation, and status updates.",
-        parameters: SEND_MESSAGE_TOOL_SCHEMA,
-        execute: async (_toolCallId, params) => {
-            if (!params.to || params.to.trim().length === 0) {
-                return {
-                    content: [{ type: "text", text: "Error: 'to' is required (agent name or '*')." }],
-                    details: { type: "send_message", error: "missing_target" },
-                };
-            }
-            if (!params.message || params.message.trim().length === 0) {
-                return {
-                    content: [{ type: "text", text: "Error: message is required." }],
-                    details: { type: "send_message", error: "empty_message" },
-                };
-            }
-            // Validate target exists (unless broadcast)
-            if (params.to !== "*" && deps.listTeammates) {
-                const teammates = deps.listTeammates();
-                if (!teammates.includes(params.to)) {
-                    return {
-                        content: [{ type: "text", text: `Error: agent "${params.to}" not found in team. Available: ${teammates.join(", ")}` }],
-                        details: { type: "send_message", error: "target_not_found", available: teammates },
-                    };
-                }
-            }
-            const result = await deps.sendMessage({
-                to: params.to.trim(),
-                message: params.message.trim(),
-                summary: params.summary,
-                senderId: deps.getSenderId(),
-            });
-            if (!result.success) {
-                return {
-                    content: [{ type: "text", text: `Message delivery failed: ${result.error || "unknown error"}` }],
-                    details: { type: "send_message", success: false, error: result.error },
-                };
-            }
-            const target = params.to === "*" ? `broadcast (${result.recipients?.length || 0} recipients)` : params.to;
-            return {
-                content: [{ type: "text", text: `Message sent to ${target}.` }],
-                details: { type: "send_message", success: true, to: params.to, recipients: result.recipients },
-            };
-        },
-    };
-}

package/dist/skills/tools/skill-list-tool.d.ts

@@ -1,33 +0,0 @@
-import type { PortableTool } from "../portable-tool.js";
-export declare const SKILL_LIST_TOOL_NAME: "skill_list";
-export interface SkillListToolParams {
-    category?: string;
-}
-export declare const SKILL_LIST_TOOL_SCHEMA: {
-    readonly type: "object";
-    readonly properties: {
-        readonly category: {
-            readonly type: "string";
-            readonly description: "Filter skills by category (e.g. 'devops', 'mlops'). Omit to list all.";
-        };
-    };
-    readonly required: readonly [];
-};
-export interface SkillListItem {
-    name: string;
-    description: string;
-    version?: string;
-    category?: string;
-}
-export interface SkillListOutput {
-    skills: SkillListItem[];
-    categories: string[];
-}
-/**
- * Host-provided skill registry for listing.
- */
-export interface SkillListToolDeps {
-    /** List all available skills, optionally filtered by category. */
-    listSkills(category?: string): Promise<SkillListOutput>;
-}
-export declare function createSkillListTool(deps: SkillListToolDeps): PortableTool<SkillListToolParams>;

package/dist/skills/tools/skill-list-tool.js

@@ -1,54 +0,0 @@
-// ============================================================
-// Skill List Tool — discover available skills.
-// Reference: hermes-agent-2026.4.30/tools/skills_tool.py (skills_list)
-// Category: skill
-// ============================================================
-export const SKILL_LIST_TOOL_NAME = "skill_list";
-export const SKILL_LIST_TOOL_SCHEMA = {
-    type: "object",
-    properties: {
-        category: {
-            type: "string",
-            description: "Filter skills by category (e.g. 'devops', 'mlops'). Omit to list all.",
-        },
-    },
-    required: [],
-};
-export function createSkillListTool(deps) {
-    return {
-        name: SKILL_LIST_TOOL_NAME,
-        label: "List Skills",
-        description: "List all available skills (reusable workflows/knowledge packages). " +
-            "Returns skill names, descriptions, and categories. " +
-            "Use skill_view to see full skill content.",
-        parameters: SKILL_LIST_TOOL_SCHEMA,
-        execute: async (_toolCallId, params) => {
-            const output = await deps.listSkills(params.category);
-            if (output.skills.length === 0) {
-                const msg = params.category
-                    ? `No skills found in category "${params.category}".`
-                    : "No skills available.";
-                return {
-                    content: [{ type: "text", text: msg }],
-                    details: { type: "skill_list", count: 0 },
-                };
-            }
-            const lines = [`Available skills (${output.skills.length}):`];
-            if (output.categories.length > 0) {
-                lines.push(`Categories: ${output.categories.join(", ")}`);
-            }
-            lines.push("");
-            for (const s of output.skills) {
-                const cat = s.category ? ` [${s.category}]` : "";
-                const ver = s.version ? ` (v${s.version})` : "";
-                lines.push(`- **${s.name}**${ver}${cat}: ${s.description}`);
-            }
-            lines.push("");
-            lines.push("Use skill_view(name) to see full skill content.");
-            return {
-                content: [{ type: "text", text: lines.join("\n") }],
-                details: { type: "skill_list", count: output.skills.length, categories: output.categories },
-            };
-        },
-    };
-}

package/dist/skills/tools/skill-manage-tool.d.ts

@@ -1,73 +0,0 @@
-import type { PortableTool } from "../portable-tool.js";
-export declare const SKILL_MANAGE_TOOL_NAME: "skill_manage";
-export type SkillManageAction = "create" | "edit" | "patch" | "delete" | "write_file" | "remove_file";
-export interface SkillManageToolParams {
-    action: SkillManageAction;
-    name: string;
-    content?: string;
-    category?: string;
-    filePath?: string;
-    fileContent?: string;
-    oldString?: string;
-    newString?: string;
-}
-export declare const SKILL_MANAGE_TOOL_SCHEMA: {
-    readonly type: "object";
-    readonly properties: {
-        readonly action: {
-            readonly type: "string";
-            readonly enum: readonly ["create", "edit", "patch", "delete", "write_file", "remove_file"];
-            readonly description: string;
-        };
-        readonly name: {
-            readonly type: "string";
-            readonly description: "Skill name (lowercase, max 64 chars, kebab-case: letters, digits, hyphens).";
-        };
-        readonly content: {
-            readonly type: "string";
-            readonly description: string;
-        };
-        readonly category: {
-            readonly type: "string";
-            readonly description: "Category/domain (e.g. 'devops', 'mlops'). Used by create to organize skills.";
-        };
-        readonly filePath: {
-            readonly type: "string";
-            readonly description: string;
-        };
-        readonly fileContent: {
-            readonly type: "string";
-            readonly description: "Content for write_file action. Max 1 MiB.";
-        };
-        readonly oldString: {
-            readonly type: "string";
-            readonly description: "Text to find for patch action (must match uniquely in SKILL.md).";
-        };
-        readonly newString: {
-            readonly type: "string";
-            readonly description: "Replacement text for patch action (can be empty to delete).";
-        };
-    };
-    readonly required: readonly ["action", "name"];
-};
-export interface SkillManageResult {
-    success: boolean;
-    message: string;
-    path?: string;
-}
-/**
- * Host-provided skill management backend.
- */
-export interface SkillManageToolDeps {
-    /**
-     * Execute a skill management action.
-     * The host handles file system operations, validation, and security scanning.
-     */
-    manageSkill(params: SkillManageToolParams): Promise<SkillManageResult>;
-    /**
-     * Validate skill name format.
-     * If not provided, tool uses built-in validation.
-     */
-    validateName?(name: string): string | null;
-}
-export declare function createSkillManageTool(deps: SkillManageToolDeps): PortableTool<SkillManageToolParams>;

package/dist/skills/tools/skill-manage-tool.js

@@ -1,153 +0,0 @@
-// ============================================================
-// Skill Manage Tool — create/edit/delete skills.
-// Reference: hermes-agent-2026.4.30/tools/skill_manager_tool.py
-// Category: skill
-// ============================================================
-export const SKILL_MANAGE_TOOL_NAME = "skill_manage";
-export const SKILL_MANAGE_TOOL_SCHEMA = {
-    type: "object",
-    properties: {
-        action: {
-            type: "string",
-            enum: ["create", "edit", "patch", "delete", "write_file", "remove_file"],
-            description: "Action to perform: create (new skill), edit (overwrite SKILL.md), " +
-                "patch (find/replace in SKILL.md), delete (remove skill), " +
-                "write_file (add/overwrite supporting file), remove_file (delete supporting file).",
-        },
-        name: {
-            type: "string",
-            description: "Skill name (lowercase, max 64 chars, kebab-case: letters, digits, hyphens).",
-        },
-        content: {
-            type: "string",
-            description: "Full SKILL.md content (YAML frontmatter + body). Required for create/edit. " +
-                "Max 100,000 chars. Must include ---\\nname: ...\\ndescription: ...\\n--- header.",
-        },
-        category: {
-            type: "string",
-            description: "Category/domain (e.g. 'devops', 'mlops'). Used by create to organize skills.",
-        },
-        filePath: {
-            type: "string",
-            description: "Path within the skill for write_file/remove_file. " +
-                "Must be in references/, templates/, scripts/, or assets/ subdirectory.",
-        },
-        fileContent: {
-            type: "string",
-            description: "Content for write_file action. Max 1 MiB.",
-        },
-        oldString: {
-            type: "string",
-            description: "Text to find for patch action (must match uniquely in SKILL.md).",
-        },
-        newString: {
-            type: "string",
-            description: "Replacement text for patch action (can be empty to delete).",
-        },
-    },
-    required: ["action", "name"],
-};
-const NAME_PATTERN = /^[a-z0-9][a-z0-9._-]{0,63}$/;
-const MAX_CONTENT_LENGTH = 100_000;
-const MAX_FILE_CONTENT_LENGTH = 1_048_576; // 1 MiB
-const ALLOWED_FILE_DIRS = ["references/", "templates/", "scripts/", "assets/"];
-export function createSkillManageTool(deps) {
-    return {
-        name: SKILL_MANAGE_TOOL_NAME,
-        label: "Manage Skills",
-        description: "Create, edit, patch, or delete skills. Skills are reusable workflows/knowledge packages " +
-            "that can be discovered and invoked. Supports managing supporting files (references, templates).",
-        parameters: SKILL_MANAGE_TOOL_SCHEMA,
-        execute: async (_toolCallId, params) => {
-            // Validate name
-            const nameError = deps.validateName
-                ? deps.validateName(params.name)
-                : validateNameBuiltin(params.name);
-            if (nameError) {
-                return {
-                    content: [{ type: "text", text: `Error: ${nameError}` }],
-                    details: { type: "skill_manage", error: "invalid_name" },
-                };
-            }
-            // Action-specific validation
-            const validationError = validateAction(params);
-            if (validationError) {
-                return {
-                    content: [{ type: "text", text: `Error: ${validationError}` }],
-                    details: { type: "skill_manage", error: "validation_failed" },
-                };
-            }
-            const result = await deps.manageSkill(params);
-            return {
-                content: [{ type: "text", text: result.message }],
-                details: {
-                    type: "skill_manage",
-                    action: params.action,
-                    name: params.name,
-                    success: result.success,
-                    path: result.path,
-                },
-            };
-        },
-    };
-}
-function validateNameBuiltin(name) {
-    if (!name)
-        return "name is required.";
-    if (!NAME_PATTERN.test(name)) {
-        return "name must be lowercase, start with letter/digit, contain only letters, digits, hyphens, dots, underscores (max 64 chars).";
-    }
-    return null;
-}
-function validateAction(params) {
-    switch (params.action) {
-        case "create":
-        case "edit":
-            if (!params.content)
-                return `content is required for ${params.action}.`;
-            if (params.content.length > MAX_CONTENT_LENGTH) {
-                return `content exceeds max length (${MAX_CONTENT_LENGTH} chars).`;
-            }
-            if (!params.content.includes("---")) {
-                return "content must include YAML frontmatter (--- delimiters).";
-            }
-            break;
-        case "patch":
-            if (!params.oldString)
-                return "oldString is required for patch.";
-            if (params.newString === undefined)
-                return "newString is required for patch (can be empty to delete).";
-            break;
-        case "write_file":
-            if (!params.filePath)
-                return "filePath is required for write_file.";
-            if (!params.fileContent)
-                return "fileContent is required for write_file.";
-            if (params.fileContent.length > MAX_FILE_CONTENT_LENGTH) {
-                return "fileContent exceeds max length (1 MiB).";
-            }
-            if (!ALLOWED_FILE_DIRS.some((d) => params.filePath.startsWith(d))) {
-                return `filePath must be in one of: ${ALLOWED_FILE_DIRS.join(", ")}`;
-            }
-            if (params.filePath.includes("..")) {
-                return "filePath must not contain path traversal (..).";
-            }
-            break;
-        case "remove_file":
-            if (!params.filePath)
-                return "filePath is required for remove_file.";
-            if (!ALLOWED_FILE_DIRS.some((d) => params.filePath.startsWith(d))) {
-                return `filePath must be in one of: ${ALLOWED_FILE_DIRS.join(", ")}`;
-            }
-            if (params.filePath.includes("..")) {
-                return "filePath must not contain path traversal (..).";
-            }
-            break;
-        case "delete":
-            // No extra validation needed
-            break;
-        default:
-            return `unknown action: ${params.action}`;
-    }
-    return null;
-}