comisai 1.0.18 → 1.0.22

package/node_modules/@comis/skills/dist/builtin/file/grep-output-mode-wrapper.js

@@ -1,167 +0,0 @@
-/**
- * Grep tool output mode wrapper.
- *
- * Post-processes grep tool results based on an `output_mode` parameter added
- * at the Comis layer. The upstream SDK grep always returns full match output
- * (file:line: content). This wrapper provides additional output formats:
- *   - `content` (default): unchanged upstream output
- *   - `files_with_matches`: deduplicated file paths only
- *   - `count`: per-file match counts, sorted by count descending
- *
- * @module
- */
-import { Type } from "@sinclair/typebox";
-/**
- * Regex to extract file path and line number from grep output lines.
- *
- * Match lines: `filepath:linenum: content`
- * Context lines: `filepath-linenum- content`
- *
- * The file path is everything before the first `:linenum:` or `-linenum-`.
- */
-const MATCH_LINE_RE = /^(.+?):(\d+): /;
-const CONTEXT_LINE_RE = /^(.+?)-(\d+)- /;
-/** Sentinel for no-match output from pi-coding-agent grep. */
-const NO_MATCHES = "No matches found";
-/**
- * Extract trailing notice lines (starting with `[`) from the output.
- * Notices appear after a blank line at the end of grep output.
- */
-function splitNotices(text) {
-    const lines = text.split("\n");
-    const notices = [];
-    // Walk backwards to find trailing notice lines
-    let i = lines.length - 1;
-    while (i >= 0 && (lines[i].startsWith("[") || lines[i].trim() === "")) {
-        if (lines[i].startsWith("[")) {
-            notices.unshift(lines[i]);
-        }
-        i--;
-    }
-    const body = lines.slice(0, i + 1).join("\n");
-    return { body, notices };
-}
-/**
- * Parse grep output into file-path-keyed match counts.
- * Only counts actual match lines (`:linenum: `), not context lines (`-linenum- `).
- */
-function countMatchesByFile(body) {
-    const counts = new Map();
-    for (const line of body.split("\n")) {
-        const match = MATCH_LINE_RE.exec(line);
-        if (match) {
-            const filePath = match[1];
-            counts.set(filePath, (counts.get(filePath) ?? 0) + 1);
-        }
-    }
-    return counts;
-}
-/**
- * Extract unique file paths from grep output (both match and context lines).
- */
-function extractUniquePaths(body) {
-    const seen = new Set();
-    const paths = [];
-    for (const line of body.split("\n")) {
-        const matchResult = MATCH_LINE_RE.exec(line) ?? CONTEXT_LINE_RE.exec(line);
-        if (matchResult) {
-            const filePath = matchResult[1];
-            if (!seen.has(filePath)) {
-                seen.add(filePath);
-                paths.push(filePath);
-            }
-        }
-    }
-    return paths;
-}
-/**
- * Wrap the grep tool to support `output_mode` parameter.
- *
- * Extends the tool's parameter schema to add `output_mode`, strips it
- * before delegating to the original tool, then post-processes the result
- * based on the requested output mode.
- *
- * @param tool - The grep tool (already wrapped with safePath)
- * @returns A new AgentTool with output_mode support
- */
-export function wrapGrepWithOutputMode(
-// eslint-disable-next-line @typescript-eslint/no-explicit-any -- AgentTool generic requires `any` per pi-agent-core API
-tool) {
-    // Extend parameter schema with output_mode
-    const originalParams = tool.parameters;
-    const extendedParams = Type.Object({
-        ...originalParams.properties,
-        output_mode: Type.Optional(Type.Union([
-            Type.Literal("content"),
-            Type.Literal("files_with_matches"),
-            Type.Literal("count"),
-        ], {
-            description: "Output format: 'content' (default, full match lines), 'files_with_matches' (file paths only), or 'count' (match counts per file)",
-        })),
-        offset: Type.Optional(Type.Number({
-            description: "Skip the first N result entries (lines for content mode, file paths for files_with_matches, count entries for count mode). Default: 0.",
-        })),
-    });
-    return {
-        ...tool,
-        parameters: extendedParams,
-        async execute(toolCallId, params, signal, onUpdate) {
-            // Extract and strip output_mode + offset before delegating to upstream
-            const outputMode = params.output_mode ?? "content";
-            const offset = params.offset ?? 0;
-            const upstreamParams = { ...params };
-            delete upstreamParams.output_mode;
-            delete upstreamParams.offset;
-            // Delegate to original grep tool
-            const result = await tool.execute(toolCallId, upstreamParams, signal, onUpdate);
-            // Extract text content from result
-            const textParts = result.content
-                .filter((c) => c.type === "text")
-                .map((c) => c.text);
-            const fullText = textParts.join("");
-            // Passthrough for empty or no-match results
-            if (fullText.trim() === "" || fullText.trim() === NO_MATCHES) {
-                return result;
-            }
-            // For default/content mode, apply offset if needed then return
-            if (outputMode === "content") {
-                if (offset <= 0) {
-                    return result;
-                }
-                const { body, notices } = splitNotices(fullText);
-                const lines = body.split("\n").slice(offset);
-                let transformedText = lines.join("\n");
-                if (notices.length > 0) {
-                    transformedText += (transformedText ? "\n\n" : "") + notices.join("\n");
-                }
-                return {
-                    ...result,
-                    content: [{ type: "text", text: transformedText }],
-                };
-            }
-            // Separate output body from trailing notices
-            const { body, notices } = splitNotices(fullText);
-            let transformedText;
-            if (outputMode === "files_with_matches") {
-                const paths = extractUniquePaths(body).slice(offset);
-                transformedText = paths.join("\n");
-            }
-            else {
-                // count mode
-                const counts = countMatchesByFile(body);
-                const sorted = [...counts.entries()].sort((a, b) => b[1] - a[1]).slice(offset);
-                transformedText = sorted
-                    .map(([filePath, count]) => `${filePath}: ${count} ${count === 1 ? "match" : "matches"}`)
-                    .join("\n");
-            }
-            // Append notices if present
-            if (notices.length > 0) {
-                transformedText += (transformedText ? "\n\n" : "") + notices.join("\n");
-            }
-            return {
-                ...result,
-                content: [{ type: "text", text: transformedText }],
-            };
-        },
-    };
-}

package/node_modules/@comis/skills/dist/builtin/task-plan-tool.d.ts

@@ -1,25 +0,0 @@
-/**
- * Task plan tool: stateless formatter for multi-step work plans.
- *
- * Agents use this tool to structure and communicate multi-step plans
- * visible in conversation history. Pure formatting -- no persistence,
- * no side effects, no state.
- *
- * @module
- */
-import type { AgentTool } from "@mariozechner/pi-agent-core";
-declare const TaskPlanParams: import("@sinclair/typebox").TObject<{
-    tasks: import("@sinclair/typebox").TArray<import("@sinclair/typebox").TObject<{
-        id: import("@sinclair/typebox").TString;
-        description: import("@sinclair/typebox").TString;
-        status: import("@sinclair/typebox").TUnion<[import("@sinclair/typebox").TLiteral<"pending">, import("@sinclair/typebox").TLiteral<"in-progress">, import("@sinclair/typebox").TLiteral<"done">, import("@sinclair/typebox").TLiteral<"skipped">]>;
-    }>>;
-    title: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
-}>;
-/**
- * Create a stateless task_plan tool for structuring multi-step work plans.
- *
- * @returns AgentTool that formats task lists into readable plan text
- */
-export declare function createTaskPlanTool(): AgentTool<typeof TaskPlanParams>;
-export {};

package/node_modules/@comis/skills/dist/builtin/task-plan-tool.js

@@ -1,67 +0,0 @@
-/**
- * Task plan tool: stateless formatter for multi-step work plans.
- *
- * Agents use this tool to structure and communicate multi-step plans
- * visible in conversation history. Pure formatting -- no persistence,
- * no side effects, no state.
- *
- * @module
- */
-import { Type } from "@sinclair/typebox";
-import { jsonResult } from "./platform/tool-helpers.js";
-// ---------------------------------------------------------------------------
-// Parameter schema
-// ---------------------------------------------------------------------------
-const TaskPlanParams = Type.Object({
-    tasks: Type.Array(Type.Object({
-        id: Type.String({ description: "Unique task identifier" }),
-        description: Type.String({ description: "What needs to be done" }),
-        status: Type.Union([
-            Type.Literal("pending"),
-            Type.Literal("in-progress"),
-            Type.Literal("done"),
-            Type.Literal("skipped"),
-        ], { description: "Current task status" }),
-    }), { description: "List of tasks in the plan" }),
-    title: Type.Optional(Type.String({ description: "Optional plan title (defaults to 'Task Plan')" })),
-});
-// ---------------------------------------------------------------------------
-// Status icon mapping
-// ---------------------------------------------------------------------------
-const STATUS_ICONS = {
-    pending: "[ ]",
-    "in-progress": "[~]",
-    done: "[x]",
-    skipped: "[-]",
-};
-// ---------------------------------------------------------------------------
-// Factory
-// ---------------------------------------------------------------------------
-/**
- * Create a stateless task_plan tool for structuring multi-step work plans.
- *
- * @returns AgentTool that formats task lists into readable plan text
- */
-export function createTaskPlanTool() {
-    return {
-        name: "task_plan",
-        label: "Task Plan",
-        description: "Structure and display a multi-step task plan. Returns a formatted summary. " +
-            "Stateless -- use this to organize your work and communicate progress.",
-        parameters: TaskPlanParams,
-        async execute(_toolCallId, params) {
-            const p = params;
-            const title = p.title ?? "Task Plan";
-            const tasks = p.tasks ?? [];
-            // Format each task line
-            const lines = tasks.map((t) => `${STATUS_ICONS[t.status]} ${t.id}: ${t.description}`);
-            // Count completed
-            const doneCount = tasks.filter((t) => t.status === "done").length;
-            const totalCount = tasks.length;
-            const summary = `${doneCount}/${totalCount} tasks completed`;
-            // Build plan text
-            const plan = [title, "", ...lines, "", summary].join("\n");
-            return jsonResult({ plan, summary, tasks });
-        },
-    };
-}

package/node_modules/@comis/skills/dist/integrations/mcp-tool-bridge.d.ts

@@ -1,75 +0,0 @@
-/**
- * MCP Tool Bridge: Converts MCP tool definitions to AgentTool instances.
- *
- * Follows the pattern established by skill-tool-bridge.ts for converting
- * external tool definitions into the AgentTool format expected by the
- * agent executor (pi-agent-core).
- *
- * Key functions:
- * - mcpToolsToAgentTools: Batch convert MCP tools to AgentTool[]
- * - jsonSchemaToTypeBox: Basic JSON Schema -> TypeBox conversion
- *
- * @module
- */
-import type { AgentTool } from "@mariozechner/pi-agent-core";
-import { type TSchema } from "@sinclair/typebox";
-import { type ToolSourceProfile } from "../builtin/tool-source-profiles.js";
-import type { McpToolDefinition, McpClientManager } from "./mcp-client.js";
-/**
- * Extract the MCP server name from a sanitized tool name.
- *
- * Sanitized MCP tool names use the format `mcp__serverName--toolName`.
- * Returns `undefined` for non-MCP tools or malformed names.
- *
- * @example
- * extractMcpServerName("mcp__context7--resolve-library-id") // "context7"
- * extractMcpServerName("mcp__srv__v2--ns--tool") // "srv__v2"
- * extractMcpServerName("bash") // undefined
- */
-export declare function extractMcpServerName(toolName: string): string | undefined;
-/**
- * Classify an MCP error message into a category for observability.
- *
- * Returns one of: "timeout", "connection", "tool_error", "transport", "unknown".
- */
-export declare function classifyMcpErrorType(errorText: string | undefined): string;
-/**
- * Convert a basic JSON Schema definition to a TypeBox TSchema.
- *
- * Handles primitive types, arrays, and objects. Complex schema features
- * (oneOf, allOf, $ref, etc.) fall back to Type.Any().
- *
- * This is intentionally simple -- MCP tool schemas are typically flat
- * objects with primitive properties. Complex schemas still work but
- * lose TypeBox-level validation detail.
- */
-export declare function jsonSchemaToTypeBox(schema: Record<string, unknown>): TSchema;
-/** Maximum characters for LLM-facing MCP tool descriptions. */
-export declare const MAX_LLM_DESCRIPTION_CHARS = 2048;
-/**
- * Sanitize a qualified MCP tool name for use as an LLM API tool name.
- *
- * LLM APIs (Anthropic, OpenAI) require tool names to match `^[a-zA-Z0-9_-]{1,128}$`.
- * Qualified names like "mcp:context7/resolve-library-id" contain invalid characters
- * (`:`, `/`). This function replaces them: "mcp:" -> "mcp__", "/" -> "--".
- *
- * Example: "mcp:context7/resolve-library-id" -> "mcp__context7--resolve-library-id"
- */
-export declare function sanitizeMcpToolName(qualifiedName: string): string;
-/**
- * Convert an array of MCP tool definitions to AgentTool instances.
- *
- * Each AgentTool's execute() delegates to the provided callTool function,
- * which dispatches to the correct MCP server connection. Error results
- * from the MCP server are returned as text content (not thrown), matching
- * the AgentTool contract.
- *
- * Successful results are capped to the resolved source profile's maxChars
- * limit, preventing oversized MCP responses from consuming agent context.
- *
- * @param tools - MCP tool definitions from McpClientManager.getTools()
- * @param callTool - McpClientManager.callTool bound function
- * @param toolSourceProfiles - Optional per-tool overrides for source profiles
- * @returns AgentTool instances ready for the agent executor
- */
-export declare function mcpToolsToAgentTools(tools: McpToolDefinition[], callTool: McpClientManager["callTool"], toolSourceProfiles?: Record<string, Partial<ToolSourceProfile>>): AgentTool<any>[];

package/node_modules/@comis/skills/dist/integrations/mcp-tool-bridge.js

@@ -1,235 +0,0 @@
-/**
- * MCP Tool Bridge: Converts MCP tool definitions to AgentTool instances.
- *
- * Follows the pattern established by skill-tool-bridge.ts for converting
- * external tool definitions into the AgentTool format expected by the
- * agent executor (pi-agent-core).
- *
- * Key functions:
- * - mcpToolsToAgentTools: Batch convert MCP tools to AgentTool[]
- * - jsonSchemaToTypeBox: Basic JSON Schema -> TypeBox conversion
- *
- * @module
- */
-import { Type } from "@sinclair/typebox";
-import { registerToolMetadata } from "@comis/core";
-import { resolveSourceProfile } from "../builtin/tool-source-profiles.js";
-import { sanitizeMcpToolResult } from "./mcp-result-sanitizer.js";
-// ---------------------------------------------------------------------------
-// MCP tool name parsing and error classification
-// ---------------------------------------------------------------------------
-/**
- * Extract the MCP server name from a sanitized tool name.
- *
- * Sanitized MCP tool names use the format `mcp__serverName--toolName`.
- * Returns `undefined` for non-MCP tools or malformed names.
- *
- * @example
- * extractMcpServerName("mcp__context7--resolve-library-id") // "context7"
- * extractMcpServerName("mcp__srv__v2--ns--tool") // "srv__v2"
- * extractMcpServerName("bash") // undefined
- */
-export function extractMcpServerName(toolName) {
-    if (!toolName.startsWith("mcp__"))
-        return undefined;
-    const rest = toolName.slice(5); // strip "mcp__"
-    const sepIdx = rest.indexOf("--");
-    if (sepIdx <= 0)
-        return undefined; // no separator or empty server name
-    return rest.slice(0, sepIdx);
-}
-/**
- * Classify an MCP error message into a category for observability.
- *
- * Returns one of: "timeout", "connection", "tool_error", "transport", "unknown".
- */
-export function classifyMcpErrorType(errorText) {
-    if (!errorText)
-        return "unknown";
-    const lower = errorText.toLowerCase();
-    if (lower.includes("timed out") || lower.includes("timeout"))
-        return "timeout";
-    if (lower.includes("not connected") || lower.includes("disconnected"))
-        return "connection";
-    if (lower.includes("crashed unexpectedly") || lower.includes("pipe") || lower.includes("epipe") || lower.includes("econnreset"))
-        return "transport";
-    if (lower.includes("mcp tool error:") || lower.includes("mcp tool returned an error"))
-        return "tool_error";
-    return "unknown";
-}
-// ---------------------------------------------------------------------------
-// JSON Schema -> TypeBox conversion
-// ---------------------------------------------------------------------------
-/**
- * Convert a basic JSON Schema definition to a TypeBox TSchema.
- *
- * Handles primitive types, arrays, and objects. Complex schema features
- * (oneOf, allOf, $ref, etc.) fall back to Type.Any().
- *
- * This is intentionally simple -- MCP tool schemas are typically flat
- * objects with primitive properties. Complex schemas still work but
- * lose TypeBox-level validation detail.
- */
-export function jsonSchemaToTypeBox(schema) {
-    const type = schema.type;
-    if (type === "string") {
-        return Type.String();
-    }
-    if (type === "number") {
-        return Type.Number();
-    }
-    if (type === "integer") {
-        return Type.Integer();
-    }
-    if (type === "boolean") {
-        return Type.Boolean();
-    }
-    if (type === "array") {
-        const items = schema.items;
-        if (items) {
-            return Type.Array(jsonSchemaToTypeBox(items));
-        }
-        return Type.Array(Type.Any());
-    }
-    if (type === "object") {
-        const properties = schema.properties;
-        const required = schema.required ?? [];
-        if (!properties) {
-            return Type.Object({});
-        }
-        const typeboxProps = {};
-        for (const [key, propSchema] of Object.entries(properties)) {
-            const converted = jsonSchemaToTypeBox(propSchema);
-            typeboxProps[key] = required.includes(key) ? converted : Type.Optional(converted);
-        }
-        return Type.Object(typeboxProps);
-    }
-    // Fallback for unknown or complex schema types
-    return Type.Any();
-}
-// ---------------------------------------------------------------------------
-// Description truncation (CTX-01)
-// ---------------------------------------------------------------------------
-/** Maximum characters for LLM-facing MCP tool descriptions. */
-export const MAX_LLM_DESCRIPTION_CHARS = 2048;
-const TRUNCATED_SUFFIX = " [truncated]";
-/**
- * Truncate a tool description for LLM consumption. Returns the original
- * string when it fits within the budget, or a truncated version with
- * "[truncated]" suffix. Returns undefined for undefined input.
- */
-function truncateDescription(desc) {
-    if (!desc || desc.length <= MAX_LLM_DESCRIPTION_CHARS)
-        return desc;
-    return desc.slice(0, MAX_LLM_DESCRIPTION_CHARS - TRUNCATED_SUFFIX.length) + TRUNCATED_SUFFIX;
-}
-// ---------------------------------------------------------------------------
-// MCP tool -> AgentTool conversion
-// ---------------------------------------------------------------------------
-/**
- * Extract the server name from a qualified tool name "mcp:{server}/{tool}".
- * Returns the full name as fallback.
- */
-function extractServerName(qualifiedName) {
-    const match = qualifiedName.match(/^mcp:([^/]+)\//);
-    return match ? match[1] : qualifiedName;
-}
-/**
- * Sanitize a qualified MCP tool name for use as an LLM API tool name.
- *
- * LLM APIs (Anthropic, OpenAI) require tool names to match `^[a-zA-Z0-9_-]{1,128}$`.
- * Qualified names like "mcp:context7/resolve-library-id" contain invalid characters
- * (`:`, `/`). This function replaces them: "mcp:" -> "mcp__", "/" -> "--".
- *
- * Example: "mcp:context7/resolve-library-id" -> "mcp__context7--resolve-library-id"
- */
-export function sanitizeMcpToolName(qualifiedName) {
-    return qualifiedName.replace(/:/g, "__").replace(/\//g, "--");
-}
-/**
- * Convert an array of MCP tool definitions to AgentTool instances.
- *
- * Each AgentTool's execute() delegates to the provided callTool function,
- * which dispatches to the correct MCP server connection. Error results
- * from the MCP server are returned as text content (not thrown), matching
- * the AgentTool contract.
- *
- * Successful results are capped to the resolved source profile's maxChars
- * limit, preventing oversized MCP responses from consuming agent context.
- *
- * @param tools - MCP tool definitions from McpClientManager.getTools()
- * @param callTool - McpClientManager.callTool bound function
- * @param toolSourceProfiles - Optional per-tool overrides for source profiles
- * @returns AgentTool instances ready for the agent executor
- */
-export function mcpToolsToAgentTools(tools, callTool, toolSourceProfiles) {
-    return tools.map((tool) => {
-        const typeboxSchema = jsonSchemaToTypeBox(tool.inputSchema);
-        const serverName = extractServerName(tool.qualifiedName);
-        const sanitizedName = sanitizeMcpToolName(tool.qualifiedName);
-        // CTX-02: Register full description as searchHint for BM25 scoring in discover_tools
-        registerToolMetadata(sanitizedName, { searchHint: tool.description ?? "" });
-        return {
-            name: sanitizedName,
-            label: tool.name,
-            // CTX-01: Truncate description for LLM token budget; full text preserved in searchHint above
-            description: truncateDescription(tool.description) ?? `MCP tool from ${serverName}`,
-            parameters: typeboxSchema,
-            async execute(_toolCallId, params) {
-                try {
-                    const result = await callTool(tool.qualifiedName, params);
-                    if (!result.ok) {
-                        return {
-                            content: [{ type: "text", text: `MCP tool error: ${result.error.message}` }],
-                            details: { success: false },
-                        };
-                    }
-                    const value = result.value;
-                    if (value.isError) {
-                        const errorText = value.content
-                            .filter((c) => c.type === "text" && c.text)
-                            .map((c) => c.text)
-                            .join("\n");
-                        return {
-                            content: [
-                                {
-                                    type: "text",
-                                    text: errorText || "MCP tool returned an error with no details",
-                                },
-                            ],
-                            details: { success: false },
-                        };
-                    }
-                    // Collect text content from the MCP result
-                    let textParts = value.content
-                        .filter((c) => c.type === "text" && c.text)
-                        .map((c) => c.text)
-                        .join("\n");
-                    // CTX-07: Sanitize MCP result (NFKC normalization + invisible char removal)
-                    textParts = sanitizeMcpToolResult(textParts);
-                    // Source-gate: cap text to resolved profile's maxChars limit
-                    const profile = resolveSourceProfile(sanitizedName, toolSourceProfiles?.[sanitizedName]);
-                    if (textParts.length > profile.maxChars) {
-                        const originalLen = textParts.length;
-                        textParts = textParts.slice(0, profile.maxChars) +
-                            `\n\n[MCP tool result truncated: ${originalLen} chars -> ${profile.maxChars} chars]`;
-                    }
-                    return {
-                        content: [{ type: "text", text: textParts || "Tool returned no text content" }],
-                        details: { success: true },
-                    };
-                }
-                catch (error) {
-                    // Defense-in-depth: callTool returns Result and should never throw,
-                    // but if something unexpected happens, return a clean error to the agent
-                    // instead of letting it propagate and produce an opaque SDK error message.
-                    const message = error instanceof Error ? error.message : String(error);
-                    return {
-                        content: [{ type: "text", text: `MCP tool "${tool.qualifiedName}" crashed unexpectedly: ${message}` }],
-                        details: { success: false },
-                    };
-                }
-            },
-        };
-    });
-}