@mcoda/mswarm 0.1.57 → 0.1.60

package/dist/vendor/codali/tools/ToolRegistry.js

@@ -0,0 +1,263 @@
+import { ToolExecutionError, toolErrorCategoryForCode, } from "./ToolTypes.js";
+const isObject = (value) => {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+};
+const TOOL_SCHEMA_TYPES = new Set([
+    "string",
+    "number",
+    "integer",
+    "boolean",
+    "object",
+    "array",
+    "null",
+]);
+const buildToolError = (code, message, options = {}) => ({
+    code,
+    category: toolErrorCategoryForCode(code),
+    message,
+    retryable: options.retryable ?? code === "tool_timeout",
+    details: options.details,
+});
+const readSchemaTypes = (schema) => {
+    if (schema.type === undefined)
+        return undefined;
+    if (Array.isArray(schema.type))
+        return schema.type;
+    return [schema.type];
+};
+const schemaValidationError = (message, path, details = {}) => {
+    return buildToolError("tool_schema_invalid", message, {
+        retryable: false,
+        details: { path, ...details },
+    });
+};
+const validateSchema = (schema, path = "$") => {
+    if (!schema)
+        return undefined;
+    const types = readSchemaTypes(schema);
+    if (types && types.length === 0) {
+        return schemaValidationError("Invalid schema: empty type list", path);
+    }
+    if (types && types.some((type) => !TOOL_SCHEMA_TYPES.has(type))) {
+        return schemaValidationError("Invalid schema: unsupported type", path, { types });
+    }
+    if (schema.required && (!Array.isArray(schema.required) || schema.required.some((key) => typeof key !== "string"))) {
+        return schemaValidationError("Invalid schema: required must be a string array", path);
+    }
+    if (schema.properties !== undefined) {
+        if (!isObject(schema.properties)) {
+            return schemaValidationError("Invalid schema: properties must be an object", path);
+        }
+        for (const [key, child] of Object.entries(schema.properties)) {
+            const childError = validateSchema(child, `${path}.properties.${key}`);
+            if (childError)
+                return childError;
+        }
+    }
+    if (schema.items !== undefined) {
+        const childError = validateSchema(schema.items, `${path}.items`);
+        if (childError)
+            return childError;
+    }
+    if (schema.additionalProperties !== undefined && typeof schema.additionalProperties !== "boolean") {
+        return schemaValidationError("Invalid schema: additionalProperties must be boolean", path);
+    }
+    if (schema.enum !== undefined && !Array.isArray(schema.enum)) {
+        return schemaValidationError("Invalid schema: enum must be an array", path);
+    }
+    return undefined;
+};
+const runtimeTypeOf = (value) => {
+    if (value === null)
+        return "null";
+    if (Array.isArray(value))
+        return "array";
+    if (typeof value === "string")
+        return "string";
+    if (typeof value === "number")
+        return Number.isInteger(value) ? "integer" : "number";
+    if (typeof value === "boolean")
+        return "boolean";
+    if (isObject(value))
+        return "object";
+    return "unknown";
+};
+const matchesType = (value, type) => {
+    if (type === "string")
+        return typeof value === "string";
+    if (type === "number")
+        return typeof value === "number" && Number.isFinite(value);
+    if (type === "integer")
+        return typeof value === "number" && Number.isInteger(value);
+    if (type === "boolean")
+        return typeof value === "boolean";
+    if (type === "object")
+        return isObject(value);
+    if (type === "array")
+        return Array.isArray(value);
+    return value === null;
+};
+const argumentValidationError = (message, path, details = {}) => {
+    return buildToolError("tool_invalid_args", message, {
+        retryable: false,
+        details: { path, ...details },
+    });
+};
+const validateValue = (value, schema, path = "$") => {
+    const schemaTypes = readSchemaTypes(schema);
+    if (schemaTypes && schemaTypes.length > 0) {
+        const matched = schemaTypes.some((type) => matchesType(value, type));
+        if (!matched) {
+            return argumentValidationError("Invalid argument type", path, {
+                expected: schemaTypes,
+                actual: runtimeTypeOf(value),
+            });
+        }
+    }
+    if (schema.enum && !schema.enum.some((entry) => Object.is(entry, value))) {
+        return argumentValidationError("Invalid argument value", path, {
+            expected: schema.enum,
+            actual: value,
+        });
+    }
+    if (typeof value === "number") {
+        if (schema.minimum !== undefined && value < schema.minimum) {
+            return argumentValidationError("Argument is below minimum", path, {
+                minimum: schema.minimum,
+                actual: value,
+            });
+        }
+        if (schema.maximum !== undefined && value > schema.maximum) {
+            return argumentValidationError("Argument is above maximum", path, {
+                maximum: schema.maximum,
+                actual: value,
+            });
+        }
+    }
+    if (typeof value === "string") {
+        if (schema.minLength !== undefined && value.length < schema.minLength) {
+            return argumentValidationError("String argument is shorter than minimum length", path, {
+                minLength: schema.minLength,
+                actualLength: value.length,
+            });
+        }
+        if (schema.maxLength !== undefined && value.length > schema.maxLength) {
+            return argumentValidationError("String argument is longer than maximum length", path, {
+                maxLength: schema.maxLength,
+                actualLength: value.length,
+            });
+        }
+    }
+    if (Array.isArray(value) && schema.items) {
+        for (let index = 0; index < value.length; index += 1) {
+            const childError = validateValue(value[index], schema.items, `${path}[${index}]`);
+            if (childError)
+                return childError;
+        }
+    }
+    if (isObject(value)) {
+        const properties = schema.properties ?? {};
+        const required = schema.required ?? [];
+        for (const key of required) {
+            if (!(key in value)) {
+                return argumentValidationError("Missing required argument", `${path}.${key}`, {
+                    required: key,
+                });
+            }
+        }
+        const allowUnknown = schema.additionalProperties === true;
+        for (const [key, entry] of Object.entries(value)) {
+            const propertySchema = properties[key];
+            if (propertySchema) {
+                const childError = validateValue(entry, propertySchema, `${path}.${key}`);
+                if (childError)
+                    return childError;
+                continue;
+            }
+            if (!allowUnknown) {
+                return argumentValidationError("Unknown argument", `${path}.${key}`, {
+                    unknown: key,
+                });
+            }
+        }
+    }
+    return undefined;
+};
+const PERMISSION_DENIED_PATTERNS = [
+    "outside the workspace",
+    "outside allowed",
+    "not allowed",
+    "disallowed",
+    "permission",
+    "read-only",
+    "disabled",
+    "eacces",
+    "eperm",
+];
+const normalizeExecutionError = (error) => {
+    if (error instanceof ToolExecutionError) {
+        return error.toToolError();
+    }
+    const message = error instanceof Error ? error.message : String(error);
+    const normalized = message.toLowerCase();
+    if (normalized.includes("timeout") || normalized.includes("timed out") || normalized.includes("etimedout")) {
+        return buildToolError("tool_timeout", message, { retryable: true });
+    }
+    if (PERMISSION_DENIED_PATTERNS.some((pattern) => normalized.includes(pattern))) {
+        return buildToolError("tool_permission_denied", message, { retryable: false });
+    }
+    return buildToolError("tool_execution_failed", message, { retryable: true });
+};
+export class ToolRegistry {
+    constructor() {
+        this.tools = new Map();
+    }
+    register(tool) {
+        if (this.tools.has(tool.name)) {
+            throw new Error(`Tool already registered: ${tool.name}`);
+        }
+        this.tools.set(tool.name, tool);
+    }
+    list() {
+        return Array.from(this.tools.values());
+    }
+    describe() {
+        return this.list().map((tool) => ({
+            name: tool.name,
+            description: tool.description,
+            inputSchema: tool.inputSchema,
+        }));
+    }
+    async execute(name, args, context) {
+        const tool = this.tools.get(name);
+        if (!tool) {
+            return {
+                ok: false,
+                output: "",
+                error: buildToolError("tool_unknown", `Unknown tool: ${name}`, {
+                    retryable: false,
+                    details: { tool: name },
+                }),
+            };
+        }
+        const schemaError = validateSchema(tool.inputSchema);
+        if (schemaError) {
+            return { ok: false, output: "", error: schemaError };
+        }
+        const validationError = tool.inputSchema ? validateValue(args, tool.inputSchema) : undefined;
+        if (validationError) {
+            return { ok: false, output: "", error: validationError };
+        }
+        try {
+            const result = await tool.handler(args, context);
+            return { ok: true, output: result.output, data: result.data };
+        }
+        catch (error) {
+            return {
+                ok: false,
+                output: "",
+                error: normalizeExecutionError(error),
+            };
+        }
+    }
+}

package/dist/vendor/codali/tools/ToolTypes.d.ts

@@ -0,0 +1,66 @@
+export interface ToolContext {
+    workspaceRoot: string;
+    runId?: string;
+    recordTouchedFile?: (path: string) => void;
+    allowOutsideWorkspace?: boolean;
+    allowedReadPaths?: string[];
+    allowedWritePaths?: string[];
+    allowShell?: boolean;
+    allowDestructiveOperations?: boolean;
+    shellAllowlist?: string[];
+}
+export type ToolSchemaPrimitiveType = "string" | "number" | "integer" | "boolean" | "object" | "array" | "null";
+export interface ToolSchemaDefinition extends Record<string, unknown> {
+    type?: ToolSchemaPrimitiveType | ToolSchemaPrimitiveType[];
+    properties?: Record<string, ToolSchemaDefinition>;
+    required?: string[];
+    items?: ToolSchemaDefinition;
+    additionalProperties?: boolean;
+    enum?: unknown[];
+    minimum?: number;
+    maximum?: number;
+    minLength?: number;
+    maxLength?: number;
+}
+export interface ToolInputSchema extends ToolSchemaDefinition {
+    type: "object";
+    properties?: Record<string, ToolSchemaDefinition>;
+    required?: string[];
+}
+export type ToolErrorCode = "tool_unknown" | "tool_schema_invalid" | "tool_invalid_args" | "tool_permission_denied" | "tool_timeout" | "tool_execution_failed";
+export type ToolErrorCategory = "lookup" | "schema" | "validation" | "permission" | "timeout" | "execution";
+export interface ToolError {
+    code: ToolErrorCode;
+    category: ToolErrorCategory;
+    message: string;
+    retryable: boolean;
+    details?: Record<string, unknown>;
+}
+export declare class ToolExecutionError extends Error {
+    readonly code: ToolErrorCode;
+    readonly category: ToolErrorCategory;
+    readonly retryable: boolean;
+    readonly details?: Record<string, unknown>;
+    constructor(code: ToolErrorCode, message: string, options?: {
+        retryable?: boolean;
+        details?: Record<string, unknown>;
+    });
+    toToolError(): ToolError;
+}
+export declare const toolErrorCategoryForCode: (code: ToolErrorCode) => ToolErrorCategory;
+export interface ToolHandlerResult {
+    output: string;
+    data?: unknown;
+}
+export interface ToolExecutionResult extends ToolHandlerResult {
+    ok: boolean;
+    error?: ToolError;
+}
+export type ToolHandler = (args: unknown, context: ToolContext) => Promise<ToolHandlerResult>;
+export interface ToolDefinition {
+    name: string;
+    description: string;
+    inputSchema?: ToolInputSchema;
+    handler: ToolHandler;
+}
+//# sourceMappingURL=ToolTypes.d.ts.map

package/dist/vendor/codali/tools/ToolTypes.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ToolTypes.d.ts","sourceRoot":"","sources":["../../src/tools/ToolTypes.ts"],"names":[],"mappings":"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"}

package/dist/vendor/codali/tools/ToolTypes.js

@@ -0,0 +1,32 @@
+export class ToolExecutionError extends Error {
+    constructor(code, message, options = {}) {
+        super(message);
+        this.name = "ToolExecutionError";
+        this.code = code;
+        this.category = toolErrorCategoryForCode(code);
+        this.retryable = options.retryable ?? code === "tool_timeout";
+        this.details = options.details;
+    }
+    toToolError() {
+        return {
+            code: this.code,
+            category: this.category,
+            message: this.message,
+            retryable: this.retryable,
+            details: this.details,
+        };
+    }
+}
+export const toolErrorCategoryForCode = (code) => {
+    if (code === "tool_unknown")
+        return "lookup";
+    if (code === "tool_schema_invalid")
+        return "schema";
+    if (code === "tool_invalid_args")
+        return "validation";
+    if (code === "tool_permission_denied")
+        return "permission";
+    if (code === "tool_timeout")
+        return "timeout";
+    return "execution";
+};

package/dist/vendor/codali/tools/diff/DiffTool.d.ts

@@ -0,0 +1,3 @@
+import type { ToolDefinition } from "../ToolTypes.js";
+export declare const createDiffTool: () => ToolDefinition;
+//# sourceMappingURL=DiffTool.d.ts.map

package/dist/vendor/codali/tools/diff/DiffTool.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"DiffTool.d.ts","sourceRoot":"","sources":["../../../src/tools/diff/DiffTool.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAe,cAAc,EAAE,MAAM,iBAAiB,CAAC;AAanE,eAAO,MAAM,cAAc,QAAO,cAsBhC,CAAC"}

package/dist/vendor/codali/tools/diff/DiffTool.js

@@ -0,0 +1,34 @@
+import { spawnSync } from "node:child_process";
+const runGitStatus = (cwd) => {
+    const result = spawnSync("git", ["status", "--porcelain"], { cwd, encoding: "utf8" });
+    if (result.error) {
+        return { ok: false, output: "", error: result.error.message };
+    }
+    if (result.status !== 0) {
+        return { ok: false, output: result.stdout ?? "", error: result.stderr ?? "git status failed" };
+    }
+    return { ok: true, output: result.stdout ?? "" };
+};
+export const createDiffTool = () => ({
+    name: "diff_summary",
+    description: "Show a git status summary of workspace changes.",
+    inputSchema: {
+        type: "object",
+        properties: {
+            maxLines: { type: "number" },
+        },
+    },
+    handler: async (args, context) => {
+        const { maxLines = 200 } = args ?? {};
+        const result = runGitStatus(context.workspaceRoot);
+        if (!result.ok) {
+            throw new Error(result.error ?? "git status failed");
+        }
+        const lines = result.output.split("\n").filter(Boolean);
+        const clipped = lines.slice(0, maxLines);
+        return {
+            output: clipped.join("\n"),
+            data: { count: clipped.length, total: lines.length },
+        };
+    },
+});

package/dist/vendor/codali/tools/docdex/DocdexTools.d.ts

@@ -0,0 +1,4 @@
+import type { ToolDefinition } from "../ToolTypes.js";
+import type { DocdexClient } from "../../docdex/DocdexClient.js";
+export declare const createDocdexTools: (client: DocdexClient) => ToolDefinition[];
+//# sourceMappingURL=DocdexTools.d.ts.map

package/dist/vendor/codali/tools/docdex/DocdexTools.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"DocdexTools.d.ts","sourceRoot":"","sources":["../../../src/tools/docdex/DocdexTools.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,iBAAiB,CAAC;AACtD,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,8BAA8B,CAAC;AAOjE,eAAO,MAAM,iBAAiB,GAAI,QAAQ,YAAY,KAAG,cAAc,EA8ftE,CAAC"}