@octocodeai/octocode-tools-core 16.2.0

package/dist/types/responseTypes.d.ts

@@ -0,0 +1,57 @@
+export type ContentRole = 'system' | 'assistant' | 'user';
+export interface RoleAnnotations {
+    audience?: Array<'user' | 'assistant'>;
+    priority?: number;
+    role?: ContentRole;
+    lastModified?: string;
+}
+export interface RoleContentBlock {
+    type: 'text';
+    text: string;
+    annotations?: RoleAnnotations;
+}
+interface ResponsePagination {
+    currentPage: number;
+    totalPages: number;
+    hasMore: boolean;
+    perPage?: number;
+    totalItems?: number;
+}
+interface SystemContentOptions {
+    instructions?: string;
+    hints?: string[];
+    pagination?: ResponsePagination;
+    warnings?: string[];
+}
+interface AssistantContentOptions {
+    summary: string;
+    details?: string;
+    format?: 'yaml' | 'json' | 'markdown' | 'plain';
+}
+interface UserContentOptions {
+    message: string;
+    emoji?: string;
+}
+export interface RoleBasedResultOptions {
+    system?: SystemContentOptions;
+    assistant: AssistantContentOptions;
+    user?: UserContentOptions;
+    data: unknown;
+    isError?: boolean;
+}
+export declare const StatusEmojis: {
+    readonly success: "✅";
+    readonly empty: "📭";
+    readonly error: "❌";
+    readonly partial: "⚠️";
+    readonly searching: "🔍";
+    readonly loading: "⏳";
+    readonly info: "ℹ️";
+    readonly file: "📄";
+    readonly folder: "📁";
+    readonly page: "📃";
+    readonly definition: "🎯";
+    readonly reference: "🔗";
+    readonly call: "📞";
+};
+export {};

package/dist/types/server.d.ts

@@ -0,0 +1,15 @@
+export type TokenSourceType = 'env:OCTOCODE_TOKEN' | 'env:GH_TOKEN' | 'env:GITHUB_TOKEN' | 'gh-cli' | 'octocode-storage' | 'none';
+export interface ServerConfig {
+    version: string;
+    githubApiUrl: string;
+    toolsToRun?: string[];
+    enableTools?: string[];
+    disableTools?: string[];
+    timeout: number;
+    maxRetries: number;
+    loggingEnabled: boolean;
+    enableLocal: boolean;
+    enableClone: boolean;
+    outputFormat: 'yaml' | 'json';
+    tokenSource: TokenSourceType;
+}

package/dist/types/session.d.ts

@@ -0,0 +1,29 @@
+export interface SessionData {
+    sessionId: string;
+    intent: 'init' | 'error' | 'tool_call' | 'rate_limit';
+    data: ToolCallData | ErrorData | RateLimitData | Record<string, never>;
+    timestamp: string;
+    version: string;
+}
+export interface ToolCallData {
+    tool_name: string;
+    repos: string[];
+    provider?: string;
+    mainResearchGoal?: string;
+    researchGoal?: string;
+    reasoning?: string;
+}
+export interface ErrorData {
+    error: string;
+    provider?: string;
+}
+export interface RateLimitData {
+    limit_type: 'primary' | 'secondary' | 'graphql' | 'precheck_blocked';
+    retry_after_seconds?: number;
+    rate_limit_remaining?: number;
+    rate_limit_reset_ms?: number;
+    api_method?: string;
+    api_url?: string;
+    details?: string;
+    provider?: string;
+}

package/dist/types/toolResults.d.ts

@@ -0,0 +1,62 @@
+import type { GitHubAPIError } from '../github/githubAPI.js';
+export type QueryStatus = 'empty' | 'error';
+interface ToolResult {
+    status?: QueryStatus;
+    hints?: string[];
+    [key: string]: unknown;
+}
+export interface ToolErrorResult extends ToolResult {
+    status: 'error';
+    error: string | GitHubAPIError;
+}
+export interface ToolSuccessResult extends ToolResult {
+    status?: 'empty';
+}
+export interface PaginationInfo {
+    currentPage: number;
+    totalPages: number;
+    hasMore: boolean;
+    charOffset?: number;
+    charLength?: number;
+    totalChars?: number;
+    nextCharOffset?: number;
+    chunkMode?: 'semantic' | 'char-limit';
+    nextBlockChar?: number;
+    perPage?: number;
+    itemsPerPage?: number;
+    filesPerPage?: number;
+    totalFiles?: number;
+    entriesPerPage?: number;
+    totalEntries?: number;
+    matchesPerPage?: number;
+    totalMatches?: number;
+    reportedTotalMatches?: number;
+    reachableTotalMatches?: number;
+    totalMatchesKind?: 'exact' | 'reported' | 'lowerBound';
+    totalMatchesCapped?: boolean;
+    uniqueFileCount?: number;
+}
+export type ToolInvocationCallback = (toolName: string, queries: unknown[]) => Promise<void>;
+export interface ProcessedBulkResult {
+    data?: Record<string, unknown>;
+    error?: string | GitHubAPIError;
+    status?: QueryStatus;
+    hints?: readonly string[] | string[];
+    [key: string]: unknown;
+}
+export interface FlatQueryResult {
+    id: string;
+    status?: QueryStatus;
+    data: Record<string, unknown>;
+}
+export interface QueryError {
+    queryIndex: number;
+    error: string;
+}
+export interface StructuredToolResponse {
+    data?: unknown;
+    hints?: string[];
+    instructions?: string;
+    [key: string]: unknown;
+}
+export {};

package/dist/utils/contextUtils.d.ts

@@ -0,0 +1,31 @@
+import type * as NativeContextUtils from '@octocodeai/octocode-context-utils';
+export type { ExtractMatchingLinesOptions, ExtractMatchingLinesResult, FilterPatchOptions, FileSystemEntry, FileSystemQueryOptions, FileSystemQueryResult, MinifyResult, JsonInput, RipgrepParseOptions, RipgrepParseResult, SliceContentOptions, SliceContentResult, StructuralMatch, YamlConversionConfig, } from '@octocodeai/octocode-context-utils';
+type NativeContextUtilsModule = typeof NativeContextUtils;
+type NativeLoader = () => NativeContextUtilsModule;
+export declare class ContextUtilsLoadError extends Error {
+    readonly cause: unknown;
+    constructor(cause: unknown);
+}
+export declare function setContextUtilsNativeLoaderForTesting(loader: NativeLoader): void;
+export declare function resetContextUtilsNativeLoaderForTesting(): void;
+export declare const contextUtils: {
+    applyContentViewMinification(content: string, filePath: string): string;
+    applyMinification(content: string, filePath: string): string;
+    minifyContent(content: string, filePath: string): Promise<NativeContextUtils.MinifyResult>;
+    minifyContentSync(content: string, filePath: string): string;
+    minifyContentResult(content: string, filePath: string): NativeContextUtils.MinifyResult;
+    minifyMarkdownCore(content: string): string;
+    extractSignatures(content: string, filePath: string): string | null;
+    structuralSearch(content: string, filePath: string, pattern?: string | null, rule?: string | null): NativeContextUtils.StructuralMatch[];
+    getSemanticBoundaryOffsets(content: string, filePath: string): number[];
+    jsonToYamlString(jsonObject: NativeContextUtils.JsonInput, config?: NativeContextUtils.YamlConversionConfig | null): string;
+    parseRipgrepJson(stdout: string, options?: NativeContextUtils.RipgrepParseOptions | null): NativeContextUtils.RipgrepParseResult;
+    queryFileSystem(options: NativeContextUtils.FileSystemQueryOptions): NativeContextUtils.FileSystemQueryResult;
+    extractMatchingLines(content: string, pattern: string, options?: NativeContextUtils.ExtractMatchingLinesOptions | null): NativeContextUtils.ExtractMatchingLinesResult;
+    filterPatch(patch: string, options?: NativeContextUtils.FilterPatchOptions | null): string;
+    charToByteOffset(content: string, charIndex: number): number;
+    byteToCharOffset(content: string, byteOffset: number): number;
+    byteSliceContent(content: string, byteStart: number, byteEnd: number): string;
+    sliceContent(content: string, charOffset: number, charLength: number, options?: NativeContextUtils.SliceContentOptions | null): NativeContextUtils.SliceContentResult;
+    readonly SIGNATURES_ONLY_HINT: string;
+};

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

@@ -0,0 +1,2 @@
+export declare function ignoreBestEffortFailure(reason: string): (error: unknown) => void;
+export declare function fallbackOnBestEffortFailure<T>(reason: string, fallback: T): (error: unknown) => T;

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

@@ -0,0 +1 @@
+export declare function compareIsoDateDescending(left?: string, right?: string): number;

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

@@ -0,0 +1,47 @@
+export declare const DEFAULTS: {
+    readonly COMMAND_TIMEOUT: 30000;
+    readonly MAX_OUTPUT_SIZE: number;
+    readonly MAX_RESULTS: 100;
+    readonly CONTEXT_LINES: 5;
+};
+export declare const RESOURCE_LIMITS: {
+    readonly MCP_MAX_TOKENS: 25000;
+    readonly CHARS_PER_TOKEN: 4;
+    readonly MAX_FETCH_CONTENT_CHARS: 50000;
+    readonly MAX_OUTPUT_SIZE_BYTES: number;
+    readonly LARGE_FILE_THRESHOLD_KB: 100;
+    readonly MAX_ENTRIES_BEFORE_PAGINATION: 100;
+    readonly MAX_FILES_DEFAULT: 1000;
+    readonly DEFAULT_ENTRIES_PER_PAGE: 100;
+    readonly MAX_ENTRIES_PER_PAGE: 200;
+    readonly MAX_LIST_ITEMS_DETAILED: 100;
+    readonly MAX_LIST_ITEMS_SIMPLE: 200;
+    readonly MAX_ARCHIVE_ENTRIES_PER_PAGE: 100;
+    readonly MAX_DIR_ENTRIES_PER_PAGE: 100;
+    readonly MAX_DIR_ENTRIES_TREE: 1000;
+    readonly DEFAULT_EXEC_TIMEOUT_MS: 30000;
+    readonly DEFAULT_MAX_MATCHES_PER_FILE: 3;
+    readonly DEFAULT_CONTEXT_LINES: 5;
+    readonly DEFAULT_MATCH_CONTENT_LENGTH: 500;
+    readonly MAX_MATCH_CONTENT_LENGTH: 800;
+    readonly DEFAULT_MATCHES_PER_PAGE: 10;
+    readonly MAX_MATCHES_PER_PAGE: 100;
+    readonly DEFAULT_FILES_PER_PAGE: 20;
+    readonly MAX_FILES_PER_PAGE: 50;
+    readonly MAX_RIPGREP_DIRECTORY_SIZE_MB: 100;
+    readonly MAX_FILE_COUNT_FOR_SEARCH: 1000;
+    readonly ESTIMATED_AVG_FILE_SIZE_BYTES: number;
+    readonly LARGE_RESULT_BYTES_HINT: number;
+    readonly BINARY_MAX_BYTES: number;
+    readonly BINARY_DEFAULT_HEX_LINES: 20;
+    readonly BINARY_DEFAULT_MIN_STRING_LENGTH: 6;
+    readonly MAX_ARCHIVE_FILES: 1000;
+    readonly DEFAULT_ARCHIVE_MAX_FILES: 200;
+    readonly GLOBAL_MEMORY_LIMIT_BYTES: number;
+    readonly PER_OPERATION_MEMORY_LIMIT_BYTES: number;
+    readonly MEMORY_RESERVATION_TIMEOUT_MS: number;
+    readonly TOKEN_CRITICAL_THRESHOLD: 50000;
+    readonly TOKEN_HIGH_THRESHOLD: 25000;
+    readonly TOKEN_MODERATE_THRESHOLD: 10000;
+    readonly TOKEN_NOTICE_THRESHOLD: 2500;
+};

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

@@ -0,0 +1,2 @@
+import type { PromiseResult, PromiseExecutionOptions } from '../../types/promise.js';
+export declare function executeWithErrorIsolation<T>(promises: Array<() => Promise<T>>, options?: PromiseExecutionOptions): Promise<PromiseResult<T>[]>;

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

@@ -0,0 +1,5 @@
+export declare function checkRegexSafety(pattern: string): {
+    safe: boolean;
+    reason?: string;
+};
+export declare function createSafeRegExp(pattern: string, flags?: string): RegExp;

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

@@ -0,0 +1,50 @@
+export interface ExecResult {
+    code: number | null;
+    stdout: string;
+    stderr: string;
+    success: boolean;
+}
+export interface ExecOptions {
+    cwd?: string;
+    timeout?: number;
+    env?: Record<string, string>;
+    maxOutputSize?: number;
+    toolName?: string;
+}
+export interface PaginationInfo {
+    currentPage: number;
+    totalPages: number;
+    hasMore: boolean;
+    charOffset?: number;
+    charLength?: number;
+    totalChars?: number;
+    chunkMode?: 'semantic' | 'char-limit';
+    nextBlockChar?: number;
+    perPage?: number;
+    itemsPerPage?: number;
+    filesPerPage?: number;
+    totalFiles?: number;
+    entriesPerPage?: number;
+    totalEntries?: number;
+    matchesPerPage?: number;
+    totalMatches?: number;
+    reportedTotalMatches?: number;
+    reachableTotalMatches?: number;
+    totalMatchesKind?: 'exact' | 'reported' | 'lowerBound';
+    totalMatchesCapped?: boolean;
+}
+export interface SearchStats {
+    matchCount?: number;
+    matchedLines?: number;
+    filesMatched?: number;
+    filesSearched?: number;
+    bytesSearched?: number;
+    searchTime?: string;
+}
+export interface CacheStats {
+    hits: number;
+    misses: number;
+    sets: number;
+    totalKeys: number;
+    lastReset: Date;
+}

package/dist/utils/environment/environmentDetection.d.ts

@@ -0,0 +1,5 @@
+type Environment = 'vscode' | 'claude-code-mcp' | 'cursor' | 'standalone';
+export declare function detectEnvironment(): Environment;
+export declare function shouldUseMCPLsp(): boolean;
+export declare function getLspEnvironmentHint(): string | null;
+export {};

package/dist/utils/exec/commandAvailability.d.ts

@@ -0,0 +1,19 @@
+interface CommandAvailabilityResult {
+    available: boolean;
+    command: string;
+    version?: string;
+    error?: string;
+}
+export declare const REQUIRED_COMMANDS: {
+    readonly rg: {
+        readonly name: "ripgrep";
+        readonly versionFlag: "--version";
+        readonly tool: "localSearchCode";
+    };
+};
+type CommandName = keyof typeof REQUIRED_COMMANDS;
+export declare function checkCommandAvailability(command: CommandName, forceCheck?: boolean): Promise<CommandAvailabilityResult>;
+export declare function checkAllCommandsAvailability(): Promise<Map<CommandName, CommandAvailabilityResult>>;
+export declare function getMissingCommandError(command: CommandName): string;
+export declare function clearAvailabilityCache(): void;
+export {};

package/dist/utils/exec/npm.d.ts

@@ -0,0 +1,16 @@
+declare const ALLOWED_NPM_COMMANDS: readonly ["view", "search", "ping", "config", "whoami"];
+type NpmCommand = (typeof ALLOWED_NPM_COMMANDS)[number];
+type NpmExecOptions = {
+    timeout?: number;
+    cwd?: string;
+    env?: Record<string, string>;
+};
+interface NpmExecResult {
+    stdout: string;
+    stderr: string;
+    error?: Error;
+    exitCode?: number;
+}
+export declare function checkNpmAvailability(timeoutMs?: number): Promise<boolean>;
+export declare function executeNpmCommand(command: NpmCommand, args: string[], options?: NpmExecOptions): Promise<NpmExecResult>;
+export {};

package/dist/utils/exec/ripgrepBinary.d.ts

@@ -0,0 +1,3 @@
+export declare function resolveRipgrepBinary(): string;
+export declare function allowRipgrepCommandName(binaryPath: string): void;
+export declare function resolveRgFromPath(): string | null;

package/dist/utils/exec/safe.d.ts

@@ -0,0 +1,2 @@
+import type { ExecResult, ExecOptions } from '../core/types.js';
+export declare function safeExec(command: string, args?: string[], options?: ExecOptions): Promise<ExecResult>;

package/dist/utils/exec/spawn.d.ts

@@ -0,0 +1,34 @@
+interface SpawnWithTimeoutOptions {
+    timeout?: number;
+    cwd?: string;
+    env?: Record<string, string | undefined>;
+    allowEnvVars?: readonly string[];
+    maxOutputSize?: number;
+}
+export declare const SENSITIVE_ENV_VARS: readonly ["NODE_OPTIONS", "GITHUB_TOKEN", "GH_TOKEN", "OCTOCODE_TOKEN", "GITHUB_PERSONAL_ACCESS_TOKEN", "NPM_TOKEN", "AWS_SECRET_ACCESS_KEY", "AWS_SESSION_TOKEN"];
+export declare const CORE_ALLOWED_ENV_VARS: readonly ["PATH", "TMPDIR", "TMP", "TEMP", "SYSTEMROOT", "WINDIR", "COMSPEC", "PATHEXT"];
+export declare const TOOLING_ALLOWED_ENV_VARS: readonly ["PATH", "TMPDIR", "TMP", "TEMP", "SYSTEMROOT", "WINDIR", "COMSPEC", "PATHEXT", "HOME", "USERPROFILE", "APPDATA", "LOCALAPPDATA"];
+export declare const PROXY_ENV_VARS: readonly ["HTTP_PROXY", "HTTPS_PROXY", "NO_PROXY", "http_proxy", "https_proxy", "no_proxy"];
+export declare function buildChildProcessEnv(envOverrides?: Record<string, string | undefined>, allowEnvVars?: readonly string[]): typeof process.env;
+interface SpawnResult {
+    stdout: string;
+    stderr: string;
+    exitCode: number | null;
+    success: boolean;
+    error?: Error;
+    timedOut?: boolean;
+    outputLimitExceeded?: boolean;
+}
+export declare function spawnWithTimeout(command: string, args: string[], options?: SpawnWithTimeoutOptions): Promise<SpawnResult>;
+export declare function spawnCheckSuccess(command: string, args: string[], timeoutMs?: number, options?: {
+    allowEnvVars?: readonly string[];
+}): Promise<boolean>;
+export declare function spawnCollectStdout(command: string, args: string[], timeoutMs?: number, options?: {
+    allowEnvVars?: readonly string[];
+    maxOutputSize?: number;
+}): Promise<string | null>;
+export declare function validateArgs(args: string[], maxLength?: number): {
+    valid: boolean;
+    error?: string;
+};
+export {};

package/dist/utils/file/byteOffset.d.ts

@@ -0,0 +1,12 @@
+import { type SliceContentOptions, type SliceContentResult } from '../contextUtils.js';
+export declare function byteSlice(content: string, byteStart: number, byteEnd: number): string;
+export declare function byteToCharIndex(content: string, byteOffset: number): number;
+export declare function charToByteIndex(content: string, charIndex: number): number;
+export declare function getByteLength(content: string): number;
+export declare function convertByteMatchToChar(content: string, byteOffset: number, byteLength: number): {
+    charOffset: number;
+    charLength: number;
+    text: string;
+};
+export declare function sliceContent(content: string, charOffset: number, charLength: number, options?: SliceContentOptions): SliceContentResult;
+export type { SliceContentOptions, SliceContentResult };

package/dist/utils/file/filters.d.ts

@@ -0,0 +1,11 @@
+export declare const IGNORED_FOLDER_NAMES: string[];
+export declare const IGNORED_FILE_NAMES: string[];
+export declare const IGNORED_FILE_EXTENSIONS: string[];
+export declare function shouldIgnoreDir(folderName: string): boolean;
+export declare function shouldIgnoreFile(filePath: string): boolean;
+interface GetExtensionOptions {
+    lowercase?: boolean;
+    fallback?: string;
+}
+export declare function getExtension(filePath: string, options?: GetExtensionOptions): string;
+export {};

package/dist/utils/file/size.d.ts

@@ -0,0 +1,2 @@
+export declare function formatFileSize(bytes: number): string;
+export declare function parseFileSize(sizeStr: string): number;

package/dist/utils/file/toolHelpers.d.ts

@@ -0,0 +1,28 @@
+import type { BaseQueryLocal } from '@octocodeai/octocode-core/extra-types';
+type PartialBaseQueryLocal = Partial<BaseQueryLocal>;
+import { createErrorResult, type UnifiedErrorResult } from '../response/error.js';
+type LocalErrorResult = UnifiedErrorResult;
+export { createErrorResult };
+type ToolPathValidationResult = {
+    isValid: false;
+    errorResult: LocalErrorResult;
+    sanitizedPath?: undefined;
+} | {
+    isValid: true;
+    sanitizedPath: string;
+    errorResult?: undefined;
+};
+export declare function validateToolPath(query: PartialBaseQueryLocal & {
+    path?: string;
+}, toolName: string): ToolPathValidationResult;
+interface LargeOutputSafetyOptions {
+    threshold?: number;
+    itemType?: string;
+    detailed?: boolean;
+}
+interface LargeOutputSafetyResult {
+    shouldBlock: boolean;
+    errorCode?: string;
+    hints?: string[];
+}
+export declare function checkLargeOutputSafety(itemCount: number, hasCharLength: boolean, options?: LargeOutputSafetyOptions): LargeOutputSafetyResult;

package/dist/utils/http/cache.d.ts

@@ -0,0 +1,16 @@
+import type { CacheStats } from '../core/types.js';
+export declare function generateCacheKey(prefix: string, params: unknown, sessionId?: string): string;
+export declare function withDataCache<T>(cacheKey: string, operation: () => Promise<T>, options?: {
+    ttl?: number;
+    skipCache?: boolean;
+    forceRefresh?: boolean;
+    shouldCache?: (value: T) => boolean;
+}): Promise<T>;
+export declare function clearAllCache(): void;
+export declare function clearLocalToolCache(): number;
+export declare function clearLSPToolCache(): number;
+export declare function clearRemoteAPICache(): number;
+export declare function getCacheStats(): CacheStats & {
+    hitRate: number;
+    cacheSize: number;
+};

package/dist/utils/http/circuitBreaker.d.ts

@@ -0,0 +1,17 @@
+export interface CircuitBreakerOptions {
+    failureThreshold?: number;
+    cooldownMs?: number;
+}
+export declare const DEFAULT_CIRCUIT_FAILURE_THRESHOLD = 5;
+export declare class CircuitOpenError extends Error {
+    readonly retryable = false;
+    readonly host: string;
+    readonly retryAfterMs: number;
+    constructor(host: string, retryAfterMs: number);
+}
+export declare function assertCircuitAvailable(url: string, now?: number): void;
+export declare function recordCircuitSuccess(url: string): void;
+export declare function recordCircuitFailure(url: string, now?: number): void;
+export declare function resetCircuitBreaker(): void;
+export declare function configureCircuitBreaker(options: CircuitBreakerOptions): void;
+export declare function isCircuitOpen(url: string, now?: number): boolean;

package/dist/utils/http/fetch.d.ts

@@ -0,0 +1,13 @@
+interface FetchWithRetriesOptions {
+    maxRetries?: number;
+    initialDelayMs?: number;
+    maxDelayMs?: number;
+    headers?: Record<string, string>;
+    method?: string;
+    includeVersion?: boolean;
+    signal?: AbortSignal;
+    rateLimitProvider?: string;
+    packageRegistry?: string;
+}
+export declare function fetchWithRetries(url: string, options?: FetchWithRetriesOptions): Promise<unknown>;
+export {};

package/dist/utils/package/common.d.ts

@@ -0,0 +1,5 @@
+import { checkNpmDeprecation } from './npm.js';
+import type { NpmSearchAPIResult, NpmSearchError, NpmSearchInput } from './types.js';
+export type { DeprecationInfo, MinimalPackageResult, NpmPackageResult, PackageResult, NpmSearchAPIResult, NpmSearchError, NpmSearchInput, } from './types.js';
+export declare function searchPackage(query: NpmSearchInput): Promise<NpmSearchAPIResult | NpmSearchError>;
+export { checkNpmDeprecation };

package/dist/utils/package/npm.d.ts

@@ -0,0 +1,8 @@
+import type { NpmSearchAPIResult, NpmSearchError, DeprecationInfo } from './types.js';
+export declare function getNpmRegistryUrl(): Promise<string>;
+export declare function _resetNpmRegistryUrlCache(): void;
+export declare function checkNpmRegistryReachable(): Promise<boolean>;
+export declare function isExactPackageName(query: string): boolean;
+export declare function _packageNameToSearchKeywords(packageName: string): string;
+export declare function searchNpmPackage(packageName: string, limit: number, fetchMetadata: boolean, from?: number): Promise<NpmSearchAPIResult | NpmSearchError>;
+export declare function checkNpmDeprecation(packageName: string): Promise<DeprecationInfo | null>;

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

@@ -0,0 +1,60 @@
+import { z } from 'zod';
+export declare const NpmViewResultSchema: z.ZodObject<{
+    name: z.ZodString;
+    version: z.ZodString;
+    repository: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+        url: z.ZodOptional<z.ZodString>;
+        type: z.ZodOptional<z.ZodString>;
+        directory: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>]>>;
+    main: z.ZodOptional<z.ZodString>;
+    module: z.ZodOptional<z.ZodString>;
+    type: z.ZodOptional<z.ZodString>;
+    exports: z.ZodOptional<z.ZodUnknown>;
+    types: z.ZodOptional<z.ZodString>;
+    typings: z.ZodOptional<z.ZodString>;
+    description: z.ZodOptional<z.ZodString>;
+    keywords: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    license: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+        type: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>]>>;
+    homepage: z.ZodOptional<z.ZodString>;
+    author: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+        name: z.ZodOptional<z.ZodString>;
+        email: z.ZodOptional<z.ZodString>;
+        url: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>]>>;
+    maintainers: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        name: z.ZodOptional<z.ZodString>;
+        email: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>>;
+    engines: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+    dependencies: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+    devDependencies: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+    peerDependencies: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+    time: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodOptional<z.ZodString>>>;
+}, z.core.$loose>;
+export declare const NpmRegistrySearchSchema: z.ZodObject<{
+    objects: z.ZodArray<z.ZodObject<{
+        package: z.ZodObject<{
+            name: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            version: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            description: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            links: z.ZodOptional<z.ZodNullable<z.ZodObject<{
+                npm: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+                homepage: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+                repository: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            }, z.core.$loose>>>;
+        }, z.core.$loose>;
+        score: z.ZodOptional<z.ZodNullable<z.ZodObject<{
+            final: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+            detail: z.ZodOptional<z.ZodNullable<z.ZodObject<{
+                quality: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+                popularity: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+                maintenance: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+            }, z.core.$loose>>>;
+        }, z.core.$loose>>>;
+    }, z.core.$loose>>;
+    total: z.ZodOptional<z.ZodUnion<readonly [z.ZodNumber, z.ZodString]>>;
+}, z.core.$loose>;
+export declare const NpmDeprecationOutputSchema: z.ZodUnion<readonly [z.ZodString, z.ZodBoolean, z.ZodNumber, z.ZodNull, z.ZodRecord<z.ZodString, z.ZodUnknown>]>;

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

@@ -0,0 +1,55 @@
+export interface NpmSearchInput {
+    name: string;
+    itemsPerPage?: number;
+    page?: number;
+    mainResearchGoal?: string;
+    researchGoal?: string;
+    reasoning?: string;
+}
+export interface MinimalPackageResult {
+    name: string;
+    repository: string | null;
+    owner?: string;
+    repo?: string;
+}
+export interface NpmPackageResult {
+    name: string;
+    npmUrl: string;
+    repoUrl: string | null;
+    path?: string;
+    version: string;
+    source?: 'cli' | 'registry' | 'cdn' | 'web';
+    mainEntry?: string | null;
+    moduleEntry?: string | null;
+    typeDefinitions?: string | null;
+    packageType?: 'module' | 'commonjs' | 'types-only' | 'unknown';
+    exports?: string[];
+    bin?: string[];
+    repositoryDirectory?: string;
+    lastPublished?: string;
+    owner?: string;
+    repo?: string;
+    description?: string;
+    license?: string;
+    weeklyDownloads?: number;
+    keywords?: string[];
+    homepage?: string;
+    author?: string;
+    engines?: Record<string, string>;
+    dependencies?: Record<string, string>;
+    peerDependencies?: Record<string, string>;
+}
+export type PackageResult = MinimalPackageResult | NpmPackageResult;
+export interface NpmSearchAPIResult {
+    packages: PackageResult[];
+    totalFound: number;
+    rawResponseChars?: number;
+}
+export interface NpmSearchError {
+    error: string;
+    hints?: string[];
+}
+export interface DeprecationInfo {
+    deprecated: boolean;
+    message?: string;
+}