@pellux/goodvibes-sdk 0.18.3 → 0.18.12

package/dist/_internal/platform/tools/read/schema.js

@@ -0,0 +1,114 @@
+/**
+ * JSON Schema definition for the `read` tool.
+ *
+ * The read tool accepts a list of files and returns their content (or a
+ * transformed view of it) in one batched response.
+ */
+export const READ_TOOL_SCHEMA = {
+    type: 'object',
+    properties: {
+        files: {
+            type: 'array',
+            description: 'Files to read. Processed as a batch in one call.',
+            items: {
+                type: 'object',
+                properties: {
+                    path: {
+                        type: 'string',
+                        description: 'Relative or absolute path to the file.',
+                    },
+                    extract: {
+                        type: 'string',
+                        enum: ['content', 'outline', 'symbols', 'ast', 'lines'],
+                        description: 'Extraction mode. Overrides the global extract for this file.'
+                            + ' content: full text; outline: signatures without bodies;'
+                            + ' symbols: exported names only; lines: specific line range;'
+                            + ' ast: structural outline via tree-sitter (falls back to regex if grammar unavailable).',
+                    },
+                    range: {
+                        type: 'object',
+                        description: 'Line range to read (1-based, inclusive). Used with extract=lines.',
+                        properties: {
+                            start: { type: 'integer', minimum: 1 },
+                            end: { type: 'integer', minimum: 1 },
+                        },
+                        required: ['start', 'end'],
+                    },
+                    force: {
+                        type: 'boolean',
+                        description: 'Bypass cache and re-read the file from disk.',
+                    },
+                    pages: {
+                        type: 'string',
+                        description: 'Page range for PDF files (e.g. \'1-5\', \'3\', \'10-20\'). Max 20 pages per request.',
+                    },
+                    image_mode: {
+                        type: 'string',
+                        enum: ['default', 'unoptimized', 'metadata-only', 'thumbnail-only'],
+                        description: 'Image handling mode. default: resize to 1568px max edge (token-efficient).'
+                            + ' unoptimized: full resolution. metadata-only: dimensions/format/size only, no image data.'
+                            + ' thumbnail-only: aggressive 256px resize for previews.',
+                    },
+                },
+                required: ['path'],
+            },
+            minItems: 1,
+        },
+        extract: {
+            type: 'string',
+            enum: ['content', 'outline', 'symbols', 'ast', 'lines'],
+            description: 'Global extraction mode applied to all files unless overridden per-file.'
+                + ' Defaults to content.',
+        },
+        output: {
+            type: 'object',
+            description: 'Output formatting options.',
+            properties: {
+                format: {
+                    type: 'string',
+                    enum: ['count_only', 'minimal', 'standard', 'verbose'],
+                    description: 'count_only: file count + totals; minimal: paths + line counts;'
+                        + ' standard: full content with line numbers (default);'
+                        + ' verbose: full content + metadata.',
+                },
+                include_line_numbers: {
+                    type: 'boolean',
+                    description: 'Include line numbers in content output. Default true.',
+                },
+                max_per_item: {
+                    type: 'integer',
+                    minimum: 1,
+                    description: 'Maximum lines to return per file.',
+                },
+                max_tokens: {
+                    type: 'integer',
+                    minimum: 1,
+                    description: 'Hard token cap across the entire response.',
+                },
+            },
+        },
+        token_budget: {
+            type: 'integer',
+            minimum: 1,
+            description: 'Token budget for paginated reads. When set, results are binned into'
+                + ' pages that fit within the budget.',
+        },
+        page: {
+            type: 'integer',
+            minimum: 1,
+            description: 'Page number to return when using token_budget pagination. Default 1.',
+        },
+        image_mode: {
+            type: 'string',
+            enum: ['default', 'unoptimized', 'metadata-only', 'thumbnail-only'],
+            description: 'Global image handling mode. Per-file image_mode overrides this. Default: default.',
+        },
+        max_image_size: {
+            type: 'integer',
+            minimum: 1,
+            description: 'Maximum image file size in bytes. Images exceeding this return metadata only.'
+                + ' Default: 5242880 (5MB).',
+        },
+    },
+    required: ['files'],
+};

package/dist/_internal/platform/tools/read/text.d.ts

@@ -0,0 +1,11 @@
+import { CodeIntelligence } from '../../intelligence/facade.js';
+export declare function extractOutlineRegex(lines: string[], includeLineNumbers: boolean): string;
+export declare function extractSymbolsRegex(lines: string[], includeLineNumbers: boolean): string;
+export declare function extractOutline(filePath: string, rawContent: string, lines: string[], includeLineNumbers: boolean, codeIntelligence?: Pick<CodeIntelligence, 'getOutline' | 'getSymbols'>): Promise<string>;
+export declare function extractSymbols(filePath: string, rawContent: string, lines: string[], includeLineNumbers: boolean, codeIntelligence?: Pick<CodeIntelligence, 'getOutline' | 'getSymbols'>): Promise<string>;
+export declare function extractAst(filePath: string, rawContent: string, lines: string[], includeLineNumbers: boolean, codeIntelligence?: Pick<CodeIntelligence, 'getOutline' | 'getSymbols'>): Promise<string>;
+export declare function formatContent(lines: string[], includeLineNumbers: boolean, range?: {
+    start: number;
+    end: number;
+}, maxPerItem?: number): string;
+//# sourceMappingURL=text.d.ts.map

package/dist/_internal/platform/tools/read/text.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"text.d.ts","sourceRoot":"","sources":["../../../../../src/_internal/platform/tools/read/text.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,gBAAgB,EAAE,MAAM,8BAA8B,CAAC;AAsChE,wBAAgB,mBAAmB,CAAC,KAAK,EAAE,MAAM,EAAE,EAAE,kBAAkB,EAAE,OAAO,GAAG,MAAM,CAexF;AAED,wBAAgB,mBAAmB,CAAC,KAAK,EAAE,MAAM,EAAE,EAAE,kBAAkB,EAAE,OAAO,GAAG,MAAM,CAexF;AAuBD,wBAAsB,cAAc,CAClC,QAAQ,EAAE,MAAM,EAChB,UAAU,EAAE,MAAM,EAClB,KAAK,EAAE,MAAM,EAAE,EACf,kBAAkB,EAAE,OAAO,EAC3B,gBAAgB,CAAC,EAAE,IAAI,CAAC,gBAAgB,EAAE,YAAY,GAAG,YAAY,CAAC,GACrE,OAAO,CAAC,MAAM,CAAC,CASjB;AAED,wBAAsB,cAAc,CAClC,QAAQ,EAAE,MAAM,EAChB,UAAU,EAAE,MAAM,EAClB,KAAK,EAAE,MAAM,EAAE,EACf,kBAAkB,EAAE,OAAO,EAC3B,gBAAgB,CAAC,EAAE,IAAI,CAAC,gBAAgB,EAAE,YAAY,GAAG,YAAY,CAAC,GACrE,OAAO,CAAC,MAAM,CAAC,CAUjB;AAED,wBAAsB,UAAU,CAC9B,QAAQ,EAAE,MAAM,EAChB,UAAU,EAAE,MAAM,EAClB,KAAK,EAAE,MAAM,EAAE,EACf,kBAAkB,EAAE,OAAO,EAC3B,gBAAgB,CAAC,EAAE,IAAI,CAAC,gBAAgB,EAAE,YAAY,GAAG,YAAY,CAAC,GACrE,OAAO,CAAC,MAAM,CAAC,CAYjB;AAED,wBAAgB,aAAa,CAC3B,KAAK,EAAE,MAAM,EAAE,EACf,kBAAkB,EAAE,OAAO,EAC3B,KAAK,CAAC,EAAE;IAAE,KAAK,EAAE,MAAM,CAAC;IAAC,GAAG,EAAE,MAAM,CAAA;CAAE,EACtC,UAAU,CAAC,EAAE,MAAM,GAClB,MAAM,CAsBR"}

package/dist/_internal/platform/tools/read/text.js

@@ -0,0 +1,138 @@
+import { logger } from '../../utils/logger.js';
+import { CodeIntelligence } from '../../intelligence/facade.js';
+import { summarizeError } from '../../utils/error-display.js';
+const SIGNATURE_PATTERNS = [
+    /^\s*export\s+(async\s+)?function\s+/,
+    /^\s*export\s+(abstract\s+)?class\s+/,
+    /^\s*export\s+interface\s+/,
+    /^\s*export\s+type\s+\w+/,
+    /^\s*export\s+enum\s+/,
+    /^\s*export\s+const\s+/,
+    /^\s*export\s+let\s+/,
+    /^\s*export\s+var\s+/,
+    /^\s*export\s+default\s+/,
+    /^(async\s+)?function\s+\w+/,
+    /^(abstract\s+)?class\s+\w+/,
+];
+const EXPORT_DECLARATION_RE = /^\s*export\s+(?:async\s+)?(?:abstract\s+)?(function|class|interface|type|enum|const|let|var)\s+(\w+)/;
+const KIND_MAP = {
+    function: 'function',
+    class: 'class',
+    interface: 'interface',
+    type: 'type',
+    enum: 'enum',
+    const: 'constant',
+    let: 'variable',
+    var: 'variable',
+};
+const TS_KIND_MAP = {
+    const: 'constant',
+    let: 'variable',
+    var: 'variable',
+};
+export function extractOutlineRegex(lines, includeLineNumbers) {
+    const result = [];
+    for (let i = 0; i < lines.length; i++) {
+        const line = lines[i];
+        if (SIGNATURE_PATTERNS.some((p) => p.test(line))) {
+            const lineNo = i + 1;
+            let sig = line.trimEnd();
+            const braceIdx = sig.indexOf('{');
+            if (braceIdx !== -1) {
+                sig = sig.slice(0, braceIdx).trimEnd();
+            }
+            result.push(includeLineNumbers ? `${String(lineNo).padStart(5)} | ${sig}` : sig);
+        }
+    }
+    return result.join('\n');
+}
+export function extractSymbolsRegex(lines, includeLineNumbers) {
+    const result = [];
+    for (let i = 0; i < lines.length; i++) {
+        const line = lines[i];
+        const m = line.match(EXPORT_DECLARATION_RE);
+        if (m) {
+            const kw = m[1];
+            const name = m[2];
+            const kind = KIND_MAP[kw] ?? 'export';
+            const lineNo = i + 1;
+            const entry = `${kind} ${name}`;
+            result.push(includeLineNumbers ? `${String(lineNo).padStart(5)} | ${entry}` : entry);
+        }
+    }
+    return result.join('\n');
+}
+function normalizeTsKind(kind) {
+    return TS_KIND_MAP[kind] ?? kind;
+}
+function formatOutlineEntries(entries, includeLineNumbers) {
+    return entries.map((e) => includeLineNumbers ? `${String(e.line).padStart(5)} | ${e.signature}` : e.signature).join('\n');
+}
+function formatSymbolEntries(symbols, includeLineNumbers) {
+    return symbols
+        .map((s) => {
+        const kind = normalizeTsKind(s.kind);
+        const entry = `${kind} ${s.name}`;
+        return includeLineNumbers ? `${String(s.line).padStart(5)} | ${entry}` : entry;
+    })
+        .join('\n');
+}
+export async function extractOutline(filePath, rawContent, lines, includeLineNumbers, codeIntelligence) {
+    try {
+        const ci = codeIntelligence ?? new CodeIntelligence({});
+        const entries = await ci.getOutline(filePath, rawContent);
+        if (entries.length > 0)
+            return formatOutlineEntries(entries, includeLineNumbers);
+    }
+    catch (err) {
+        logger.debug('read tool: tree-sitter outline failed, using regex fallback', { filePath, error: summarizeError(err) });
+    }
+    return extractOutlineRegex(lines, includeLineNumbers);
+}
+export async function extractSymbols(filePath, rawContent, lines, includeLineNumbers, codeIntelligence) {
+    try {
+        const ci = codeIntelligence ?? new CodeIntelligence({});
+        const symbols = await ci.getSymbols(filePath, rawContent);
+        const exported = symbols.filter((s) => s.exported);
+        if (exported.length > 0)
+            return formatSymbolEntries(exported, includeLineNumbers);
+    }
+    catch (err) {
+        logger.debug('read tool: tree-sitter symbols failed, using regex fallback', { filePath, error: summarizeError(err) });
+    }
+    return extractSymbolsRegex(lines, includeLineNumbers);
+}
+export async function extractAst(filePath, rawContent, lines, includeLineNumbers, codeIntelligence) {
+    try {
+        const ci = codeIntelligence ?? new CodeIntelligence({});
+        const entries = await ci.getOutline(filePath, rawContent);
+        if (entries.length > 0)
+            return formatOutlineEntries(entries, includeLineNumbers);
+    }
+    catch (err) {
+        logger.debug('read tool: tree-sitter ast failed, using outline fallback', { filePath, error: summarizeError(err) });
+    }
+    return ('# Note: tree-sitter outline unavailable for this file. Falling back to regex.\n'
+        + extractOutlineRegex(lines, includeLineNumbers));
+}
+export function formatContent(lines, includeLineNumbers, range, maxPerItem) {
+    let slice;
+    let startLine;
+    if (range) {
+        const start = Math.max(0, range.start - 1);
+        const end = Math.min(lines.length, range.end);
+        slice = lines.slice(start, end);
+        startLine = range.start;
+    }
+    else {
+        slice = lines;
+        startLine = 1;
+    }
+    if (maxPerItem !== undefined) {
+        slice = slice.slice(0, maxPerItem);
+    }
+    if (includeLineNumbers) {
+        return slice.map((l, idx) => `${String(startLine + idx).padStart(5)} | ${l}`).join('\n');
+    }
+    return slice.join('\n');
+}

package/dist/_internal/platform/tools/registry-tool/index.d.ts

@@ -0,0 +1,14 @@
+import type { Tool } from '../../types/tools.js';
+import type { ToolRegistry } from '../registry.js';
+export interface RegistryToolRoots {
+    readonly workingDirectory: string;
+    readonly homeDirectory?: string;
+}
+/**
+ * Create the `registry` tool bound to the given ToolRegistry.
+ *
+ * Returns a Tool object conforming to the Tool interface.
+ * Never throws from execute().
+ */
+export declare function createRegistryTool(toolRegistry: ToolRegistry, roots: RegistryToolRoots): Tool;
+//# sourceMappingURL=index.d.ts.map

package/dist/_internal/platform/tools/registry-tool/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/_internal/platform/tools/registry-tool/index.ts"],"names":[],"mappings":"AAYA,OAAO,KAAK,EAAE,IAAI,EAAkB,MAAM,sBAAsB,CAAC;AACjE,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,gBAAgB,CAAC;AAmCnD,MAAM,WAAW,iBAAiB;IAChC,QAAQ,CAAC,gBAAgB,EAAE,MAAM,CAAC;IAClC,QAAQ,CAAC,aAAa,CAAC,EAAE,MAAM,CAAC;CACjC;AAiID;;;;;GAKG;AACH,wBAAgB,kBAAkB,CAAC,YAAY,EAAE,YAAY,EAAE,KAAK,EAAE,iBAAiB,GAAG,IAAI,CAwC7F"}