@octocodeai/octocode-tools-core 16.2.0

package/dist/utils/pagination/boundary.d.ts

@@ -0,0 +1,11 @@
+export declare function isMidBlockCut(paginatedContent: string): boolean;
+export declare function findNextBlockBoundary(content: string, fromChar: number, filePath?: string): number | undefined;
+export declare function buildBlockBoundaryHint(paginatedContent: string, fullContent: string, cutPos: number, currentCharLength: number, filePath?: string): {
+    nextBlockChar: number;
+    hint: string;
+} | undefined;
+export type ChunkMode = 'semantic' | 'char-limit';
+export declare function snapToSemanticBoundary(content: string, charOffset: number, charLength: number, filePath?: string): {
+    length: number;
+    chunkMode: ChunkMode;
+};

package/dist/utils/pagination/charLimit.d.ts

@@ -0,0 +1,3 @@
+export declare function getOutputCharLimit(): number;
+export declare const MAX_DEFAULT_OUTPUT_CHAR_LENGTH = 100000;
+export declare function getBulkDefaultCharLength(queryCount: number): number;

package/dist/utils/pagination/core.d.ts

@@ -0,0 +1,15 @@
+import type { PaginationInfo } from '../../types/toolResults.js';
+import type { PaginationMetadata, ApplyPaginationOptions } from './types.js';
+export declare function applyPagination(content: string, offset?: number, length?: number, options?: ApplyPaginationOptions): PaginationMetadata;
+export declare function serializeForPagination(data: unknown, pretty?: boolean): string;
+export declare function createPaginationInfo(metadata: PaginationMetadata): PaginationInfo;
+export interface SliceByCharResult {
+    sliced: string;
+    actualOffset: number;
+    actualLength: number;
+    hasMore: boolean;
+    lineCount: number;
+    totalChars: number;
+    nextOffset?: number;
+}
+export declare function sliceByCharRespectLines(text: string, charOffset: number, charLength: number): SliceByCharResult;

package/dist/utils/pagination/hints.d.ts

@@ -0,0 +1,3 @@
+import type { PaginationMetadata, GeneratePaginationHintsOptions, StructurePaginationInfo, StructurePaginationHintContext } from './types.js';
+export declare function generatePaginationHints(metadata: PaginationMetadata, options?: GeneratePaginationHintsOptions): string[];
+export declare function generateStructurePaginationHints(pagination: StructurePaginationInfo, _context: StructurePaginationHintContext): string[];

package/dist/utils/pagination/outputSizeLimit.d.ts

@@ -0,0 +1,16 @@
+import type { PaginationInfo } from '../../types/toolResults.js';
+interface OutputSizeLimitOptions {
+    charOffset?: number;
+    charLength?: number;
+    maxOutputChars?: number;
+    recommendedCharLength?: number;
+}
+interface OutputSizeLimitResult {
+    content: string;
+    wasLimited: boolean;
+    pagination?: PaginationInfo;
+    warnings: string[];
+    paginationHints: string[];
+}
+export declare function applyOutputSizeLimit(content: string, options: OutputSizeLimitOptions): OutputSizeLimitResult;
+export {};

package/dist/utils/pagination/types.d.ts

@@ -0,0 +1,43 @@
+export interface PaginationMetadata {
+    paginatedContent: string;
+    byteOffset: number;
+    byteLength: number;
+    totalBytes: number;
+    nextByteOffset?: number;
+    charOffset: number;
+    charLength: number;
+    totalChars: number;
+    nextCharOffset?: number;
+    hasMore: boolean;
+    estimatedTokens?: number;
+    currentPage: number;
+    totalPages: number;
+}
+export interface ApplyPaginationOptions {
+    actualOffset?: number;
+    mode?: 'characters' | 'bytes';
+    pageSize?: number;
+}
+export interface GeneratePaginationHintsOptions {
+    enableWarnings?: boolean;
+    customHints?: string[];
+    toolName?: string;
+}
+export interface StructurePaginationInfo {
+    currentPage: number;
+    totalPages: number;
+    hasMore: boolean;
+    entriesPerPage: number;
+    totalEntries: number;
+}
+export interface StructurePaginationHintContext {
+    owner: string;
+    repo: string;
+    branch: string;
+    path?: string;
+    depth?: number;
+    pageFiles: number;
+    pageFolders: number;
+    allFiles: number;
+    allFolders: number;
+}

package/dist/utils/parsers/diff.d.ts

@@ -0,0 +1,2 @@
+export declare function filterPatch(patch: string, additions?: number[], deletions?: number[]): string;
+export declare function trimDiffContext(patch: string): string;

package/dist/utils/parsers/ripgrep.d.ts

@@ -0,0 +1,11 @@
+import type { LocalSearchCodeFile } from '@octocodeai/octocode-core/types';
+import type { SearchStats } from '../core/types.js';
+interface RipgrepParserQuery {
+    contextLines?: number;
+    matchContentLength?: number;
+}
+export declare function parseRipgrepJson(jsonOutput: string, query: RipgrepParserQuery): {
+    files: LocalSearchCodeFile[];
+    stats: SearchStats;
+};
+export {};

package/dist/utils/parsers/schemas.d.ts

@@ -0,0 +1,72 @@
+import { z } from 'zod';
+export declare const RipgrepJsonMessageSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    type: z.ZodLiteral<"match">;
+    data: z.ZodObject<{
+        path: z.ZodObject<{
+            text: z.ZodString;
+        }, z.core.$strip>;
+        lines: z.ZodObject<{
+            text: z.ZodString;
+        }, z.core.$strip>;
+        line_number: z.ZodNumber;
+        absolute_offset: z.ZodNumber;
+        submatches: z.ZodArray<z.ZodObject<{
+            match: z.ZodOptional<z.ZodObject<{
+                text: z.ZodString;
+            }, z.core.$strip>>;
+            start: z.ZodNumber;
+            end: z.ZodNumber;
+        }, z.core.$strip>>;
+    }, z.core.$strip>;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"context">;
+    data: z.ZodObject<{
+        path: z.ZodObject<{
+            text: z.ZodString;
+        }, z.core.$strip>;
+        lines: z.ZodObject<{
+            text: z.ZodString;
+        }, z.core.$strip>;
+        line_number: z.ZodNumber;
+        absolute_offset: z.ZodNumber;
+    }, z.core.$strip>;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"begin">;
+    data: z.ZodObject<{
+        path: z.ZodObject<{
+            text: z.ZodString;
+        }, z.core.$strip>;
+    }, z.core.$strip>;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"end">;
+    data: z.ZodObject<{
+        path: z.ZodObject<{
+            text: z.ZodString;
+        }, z.core.$strip>;
+        stats: z.ZodOptional<z.ZodObject<{
+            elapsed: z.ZodObject<{
+                human: z.ZodString;
+            }, z.core.$strip>;
+            searches: z.ZodNumber;
+            searches_with_match: z.ZodNumber;
+        }, z.core.$strip>>;
+    }, z.core.$strip>;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"summary">;
+    data: z.ZodObject<{
+        elapsed_total: z.ZodObject<{
+            human: z.ZodString;
+        }, z.core.$strip>;
+        stats: z.ZodObject<{
+            elapsed: z.ZodObject<{
+                human: z.ZodString;
+            }, z.core.$strip>;
+            searches: z.ZodNumber;
+            searches_with_match: z.ZodNumber;
+            bytes_searched: z.ZodNumber;
+            bytes_printed: z.ZodNumber;
+            matched_lines: z.ZodNumber;
+            matches: z.ZodNumber;
+        }, z.core.$strip>;
+    }, z.core.$strip>;
+}, z.core.$strip>], "type">;

package/dist/utils/response/bulk.d.ts

@@ -0,0 +1,5 @@
+import { CallToolResult } from '@modelcontextprotocol/sdk/types';
+import type { ProcessedBulkResult } from '../../types/toolResults.js';
+import type { BulkResponseConfig, BulkResponsePagination } from '../../types/bulk.js';
+export declare function computeQueryTimeout(queryCount: number, concurrency: number, minTimeoutMs?: number): number;
+export declare function executeBulkOperation<TQuery extends object, TOutput extends Record<string, unknown> = Record<string, unknown>>(queries: Array<TQuery>, processor: (query: TQuery, index: number) => Promise<ProcessedBulkResult>, config: BulkResponseConfig<TQuery, TOutput>, pagination?: BulkResponsePagination): Promise<CallToolResult>;

package/dist/utils/response/callToolResult.d.ts

@@ -0,0 +1,3 @@
+import { type CallToolResult } from '@modelcontextprotocol/sdk/types.js';
+export declare function sanitizeCallToolResult(result: CallToolResult): CallToolResult;
+export declare function buildToolErrorResult(toolName: string, error: unknown): CallToolResult;

package/dist/utils/response/charSavings.d.ts

@@ -0,0 +1,3 @@
+export declare function countSerializedChars(value: unknown): number;
+export declare function attachRawResponseChars<T extends object>(result: T, rawResponse: unknown): T;
+export declare function getRawResponseChars(value: unknown): number | undefined;

package/dist/utils/response/error.d.ts

@@ -0,0 +1,20 @@
+import type { GitHubAPIError } from '../../github/githubAPI.js';
+import type { BaseQueryLocal } from '@octocodeai/octocode-core/extra-types';
+type PartialBaseQuery = Partial<BaseQueryLocal>;
+export interface UnifiedErrorResult {
+    status: 'error';
+    error?: string | GitHubAPIError;
+    errorCode?: string;
+    hints?: string[];
+    [key: string]: unknown;
+}
+interface CreateErrorResultOptions {
+    toolName?: string;
+    hintContext?: Record<string, unknown>;
+    extra?: Record<string, unknown>;
+    customHints?: string[];
+    hintSourceError?: GitHubAPIError;
+    rawResponse?: unknown;
+}
+export declare function createErrorResult(error: unknown, _query: PartialBaseQuery, options?: CreateErrorResultOptions): UnifiedErrorResult;
+export {};

package/dist/utils/response/groupedFinalizer.d.ts

@@ -0,0 +1,37 @@
+import type { BulkFinalizerOutput } from '../../types/bulk.js';
+import type { FlatQueryResult } from '../../types/toolResults.js';
+export type CharPagination = {
+    currentPage: number;
+    totalPages: number;
+    hasMore: boolean;
+    charOffset: number;
+    charLength: number;
+    totalChars: number;
+};
+export type QueryWithPagination = {
+    id?: unknown;
+    charLength?: unknown;
+    charOffset?: unknown;
+};
+type CharWindowConfig<TGroup, TItem> = {
+    groups: TGroup[];
+    getItems: (group: TGroup) => readonly TItem[];
+    setItems: (group: TGroup, items: TItem[]) => TGroup;
+    getItemText?: (item: TItem) => string | undefined;
+    setItemText?: (item: TItem, text: string) => TItem;
+    charOffset: number;
+    charLength: number;
+    maxItems?: number;
+};
+export declare function paginateGroupsCharWindow<TGroup, TItem>({ groups, getItems, setItems, getItemText, setItemText, charOffset, charLength, maxItems, }: CharWindowConfig<TGroup, TItem>): {
+    groups: TGroup[];
+    pagination: CharPagination;
+};
+export declare function dedupeHints(hints: readonly string[]): string[];
+export declare function collectFlatErrors(results: readonly FlatQueryResult[]): Array<{
+    id: string;
+    error: string;
+    hints?: string[];
+}>;
+export declare function formatFinalizedResponse<T extends Record<string, unknown>>(responseData: T, keysPriority: readonly string[], isError?: boolean): BulkFinalizerOutput<T>;
+export {};

package/dist/utils/response/pathRelativize.d.ts

@@ -0,0 +1,9 @@
+export declare function commonDirPrefix(paths: readonly string[]): string;
+export declare function relativizeResultPaths(results: ReadonlyArray<{
+    data?: unknown;
+} | null | undefined>): string | undefined;
+type SharedValue = string | number | boolean;
+export declare function hoistSharedFields(results: ReadonlyArray<{
+    data?: unknown;
+} | null | undefined>): Record<string, SharedValue> | undefined;
+export {};

package/dist/utils/response/structuredPagination.d.ts

@@ -0,0 +1,9 @@
+import type { BulkToolResponse } from '../../types/bulk.js';
+import type { FlatQueryResult } from '../../types/toolResults.js';
+interface PaginationRequest {
+    offset?: number;
+    length?: number;
+}
+export declare function applyQueryOutputPagination(queryResult: FlatQueryResult, originalQuery: Record<string, unknown>, toolName: string): FlatQueryResult;
+export declare function applyBulkResponsePagination(response: BulkToolResponse, request: PaginationRequest, toolName: string): BulkToolResponse;
+export {};

package/dist/zod.d.ts

@@ -0,0 +1 @@
+export { z } from 'zod';

package/dist/zod.js

@@ -0,0 +1,8 @@
+#!/usr/bin/env node
+import { createRequire as __createRequire } from 'module';
+import { fileURLToPath as __fileURLToPath } from 'url';
+import { dirname as __dirname_fn } from 'path';
+const require = __createRequire(import.meta.url);
+const __filename = __fileURLToPath(import.meta.url);
+const __dirname = __dirname_fn(__filename);
+import{z as e}from"zod";export{e as z};

package/package.json

@@ -0,0 +1,66 @@
+{
+  "name": "@octocodeai/octocode-tools-core",
+  "version": "16.2.0",
+  "description": "Core tool implementations for Octocode: GitHub, local filesystem, LSP, and package search tools.",
+  "author": "Guy Bary <bgauryy@octocodeai.com>",
+  "license": "MIT",
+  "type": "module",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    },
+    "./direct": {
+      "types": "./dist/direct.d.ts",
+      "import": "./dist/direct.js"
+    },
+    "./zod": {
+      "types": "./dist/zod.d.ts",
+      "import": "./dist/zod.js"
+    }
+  },
+  "files": [
+    "dist",
+    "LICENSE"
+  ],
+  "engines": {
+    "node": ">=20.0.0"
+  },
+  "scripts": {
+    "build": "yarn clean && node build.mjs && tsc --emitDeclarationOnly -p tsconfig.build.json",
+    "build:dev": "node build.mjs && tsc --emitDeclarationOnly -p tsconfig.build.json",
+    "clean": "rm -rf dist/",
+    "lint": "eslint src",
+    "lint:fix": "eslint src --fix",
+    "test": "vitest run --coverage",
+    "test:quiet": "vitest run --reporter=dot --silent",
+    "typecheck": "tsc --noEmit --skipLibCheck -p tsconfig.json",
+    "verify": "yarn lint && yarn typecheck && yarn test"
+  },
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.29.0",
+    "@octocodeai/octocode-context-utils": "^16.3.0",
+    "@octocodeai/octocode-core": "^16.2.0",
+    "@octokit/plugin-throttling": "^11.0.3",
+    "@vscode/ripgrep": "^1.18.0",
+    "node-cache": "^5.1.2",
+    "octocode-lsp": "^16.3.0",
+    "octocode-security": "^16.3.0",
+    "octocode-shared": "workspace:^",
+    "octokit": "^5.0.5",
+    "zod": "^4.3.6"
+  },
+  "devDependencies": {
+    "@octokit/core": "^7.0.6",
+    "@octokit/openapi-types": "^27.0.0",
+    "@octokit/plugin-rest-endpoint-methods": "^17.0.0",
+    "@types/node": "^25.9.3",
+    "@vitest/coverage-v8": "^4.0.16",
+    "esbuild": "^0.28.1",
+    "eslint": "^9.18.0",
+    "typescript": "^5.9.3",
+    "vitest": "^4.0.16"
+  }
+}