patchwork-os 0.2.0-alpha.0

package/dist/tools/typeHierarchy.js

@@ -0,0 +1,86 @@
+import { ExtensionTimeoutError, } from "../extensionClient.js";
+import { error, extensionRequired, optionalInt, optionalString, requireInt, requireString, resolveFilePath, successStructured, } from "./utils.js";
+export function createGetTypeHierarchyTool(workspace, extensionClient) {
+    return {
+        schema: {
+            name: "getTypeHierarchy",
+            description: "Type hierarchy: supertypes (parents) and subtypes (impls/subclasses). Requires LSP support.",
+            annotations: { readOnlyHint: true },
+            extensionRequired: true,
+            inputSchema: {
+                $schema: "http://json-schema.org/draft-07/schema#",
+                type: "object",
+                required: ["file", "line", "column"],
+                properties: {
+                    file: {
+                        type: "string",
+                        description: "Workspace or absolute path",
+                    },
+                    line: {
+                        type: "integer",
+                        description: "Line number (1-based)",
+                    },
+                    column: {
+                        type: "integer",
+                        description: "Column (1-based)",
+                    },
+                    direction: {
+                        type: "string",
+                        enum: ["supertypes", "subtypes", "both"],
+                        description: "Which direction to traverse (default: both)",
+                    },
+                    maxResults: {
+                        type: "integer",
+                        description: "Max results per direction (default: 20)",
+                    },
+                },
+                additionalProperties: false,
+            },
+            outputSchema: {
+                type: "object",
+                properties: {
+                    found: { type: "boolean" },
+                    message: { type: "string" },
+                    supertypes: {
+                        type: "array",
+                        items: { type: "object" },
+                    },
+                    subtypes: {
+                        type: "array",
+                        items: { type: "object" },
+                    },
+                },
+                required: ["found"],
+            },
+        },
+        async handler(args, signal) {
+            if (!extensionClient.isConnected()) {
+                return extensionRequired("getTypeHierarchy");
+            }
+            const file = resolveFilePath(requireString(args, "file"), workspace);
+            const line = requireInt(args, "line", 1, 1_000_000);
+            const column = requireInt(args, "column", 1, 100_000);
+            const direction = optionalString(args, "direction") ?? "both";
+            if (!["supertypes", "subtypes", "both"].includes(direction)) {
+                return error('direction must be "supertypes", "subtypes", or "both"');
+            }
+            const maxResults = optionalInt(args, "maxResults", 1, 200) ?? 20;
+            try {
+                const result = await extensionClient.getTypeHierarchy(file, line, column, direction, maxResults, signal);
+                if (result === null)
+                    return successStructured({
+                        found: false,
+                        message: "No type hierarchy at this position — ensure a language server is active",
+                    });
+                return successStructured(result);
+            }
+            catch (err) {
+                if (err instanceof ExtensionTimeoutError) {
+                    return error("Extension timed out getting type hierarchy");
+                }
+                throw err;
+            }
+        },
+    };
+}
+//# sourceMappingURL=typeHierarchy.js.map

package/dist/tools/typeHierarchy.js.map

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

package/dist/tools/utils.d.ts

@@ -0,0 +1,124 @@
+import type { AbsPath } from "../fp/brandedTypes.js";
+export declare function requireString(args: Record<string, unknown>, key: string, maxLength?: number): string;
+export declare function optionalString(args: Record<string, unknown>, key: string, maxLength?: number): string | undefined;
+export declare function optionalInt(args: Record<string, unknown>, key: string, min?: number, max?: number): number | undefined;
+export declare function optionalBool(args: Record<string, unknown>, key: string): boolean | undefined;
+/** Require args[key] to be an array. Throws on failure. */
+export declare function requireArray(args: Record<string, unknown>, key: string): unknown[];
+/** Return args[key] if it is an array, undefined if absent, throw if wrong type. */
+export declare function optionalArray(args: Record<string, unknown>, key: string): unknown[] | undefined;
+export declare function resolveFilePath(filePath: string, workspace: string, opts?: {
+    write?: boolean;
+}): AbsPath;
+export declare function findLineNumber(filePath: string, text: string): Promise<number | null>;
+export declare function success(data: unknown): {
+    content: Array<{
+        type: string;
+        text: string;
+    }>;
+};
+/**
+ * Like `success()` but also emits `structuredContent` per MCP 2025-06-18 spec.
+ * Use for tools that declare `outputSchema` — enables reliable tool chaining
+ * without clients having to parse text blobs.
+ */
+export declare function successStructured(data: unknown): {
+    content: Array<{
+        type: string;
+        text: string;
+    }>;
+    structuredContent: unknown;
+};
+/**
+ * Like `success()` but annotates the content block with
+ * `_meta["anthropic/maxResultSizeChars"]` so Claude Code persists up to 500K
+ * chars instead of applying its default truncation. Use for tools that return
+ * large outputs (file contents, diffs, search results, dependency trees).
+ */
+export declare function successLarge(data: unknown): {
+    content: Array<{
+        type: string;
+        text: string;
+        _meta?: Record<string, unknown>;
+    }>;
+};
+/**
+ * Like `successStructured()` but with the large-result `_meta` annotation.
+ */
+export declare function successStructuredLarge(data: unknown): {
+    content: Array<{
+        type: string;
+        text: string;
+        _meta?: Record<string, unknown>;
+    }>;
+    structuredContent: unknown;
+};
+export declare function error(data: string | Record<string, unknown>, code?: string): {
+    content: Array<{
+        type: string;
+        text: string;
+    }>;
+    isError: true;
+};
+export declare function extensionRequired(feature: string, alternatives?: string[]): {
+    content: Array<{
+        type: string;
+        text: string;
+    }>;
+    isError: true;
+};
+export declare function requireInt(args: Record<string, unknown>, key: string, min?: number, max?: number): number;
+export declare function toFileUri(absPath: string): string;
+export declare function truncateOutput(str: string, maxBytes: number): {
+    text: string;
+    truncated: boolean;
+};
+export interface ExecSafeResult {
+    stdout: string;
+    stderr: string;
+    exitCode: number;
+    timedOut: boolean;
+    durationMs: number;
+}
+export declare function execSafe(cmd: string, args: string[], opts?: {
+    cwd?: string;
+    timeout?: number;
+    maxBuffer?: number;
+    signal?: AbortSignal;
+    stdin?: string;
+    env?: NodeJS.ProcessEnv;
+}): Promise<ExecSafeResult>;
+/**
+ * Wraps a long-running async operation with periodic progress heartbeat
+ * notifications so MCP clients don't time out waiting for a response.
+ *
+ * Sends a progress ping every `intervalMs` (default 5s) until the operation
+/**
+ * Streaming variant of execSafe — calls `onLine` for each complete stdout line and
+ * `onStderrLine` for each complete stderr line as the process runs, while still
+ * collecting both streams for the final result.
+ * Falls back to regular execSafe behavior when neither callback is provided.
+ */
+export declare function execSafeStreaming(cmd: string, args: string[], opts?: {
+    cwd?: string;
+    timeout?: number;
+    maxBuffer?: number;
+    signal?: AbortSignal;
+    env?: NodeJS.ProcessEnv;
+    onLine?: (line: string) => void;
+    onStderrLine?: (line: string) => void;
+}): Promise<ExecSafeResult>;
+/**
+ * resolves. Progress value increments from 1 toward 99 (never reaches 100 —
+ * the caller is responsible for sending the final progress(100) on success).
+ *
+ * Safe to call with `progress = undefined` — no-ops cleanly.
+ */
+export declare function withHeartbeat<T>(fn: () => Promise<T>, progress: ((value: number, total: number, message?: string) => void) | undefined, opts?: {
+    intervalMs?: number;
+    message?: string;
+}): Promise<T>;
+export declare const LANGUAGE_ID_MAP: Record<string, string>;
+export declare function languageIdFromPath(filePath: string): string;
+export declare function mimeTypeFromPath(filePath: string): string;
+export declare function makeRelative(absPath: string, workspace: string): string;