@phuetz/code-buddy 2.0.0 → 2.1.0

package/dist/tools/resource-catalog-tool.js

@@ -0,0 +1,46 @@
+import { z } from 'zod';
+import { publicResourceStatus, ResourceCatalog, resourceSchema, selectionWarning } from '../fleet/resource-catalog.js';
+import { RESOURCE_CATALOG_TOOL_DEF } from '../codebuddy/resource-catalog-tool-defs.js';
+const schema = z.discriminatedUnion('operation', [
+    z.object({ operation: z.literal('list') }).strict(),
+    z.object({ operation: z.literal('select'), capability: z.string().regex(/^[a-zA-Z0-9][a-zA-Z0-9._:-]{0,95}$/),
+        kind: resourceSchema.shape.kind.optional() }).strict(),
+]);
+export class ResourceCatalogTool {
+    catalog;
+    name = 'resource_catalog';
+    description = RESOURCE_CATALOG_TOOL_DEF.function.description;
+    constructor(catalog = new ResourceCatalog()) {
+        this.catalog = catalog;
+    }
+    getSchema() { return RESOURCE_CATALOG_TOOL_DEF.function; }
+    getMetadata() {
+        return { name: this.name, description: this.description, category: 'system',
+            keywords: ['resource', 'catalog', 'network', 'fleet', 'ragchat', 'available', 'ressources', 'réseau'],
+            priority: 7, modifiesFiles: false, makesNetworkRequests: false };
+    }
+    isAvailable() { return true; }
+    validate(input) {
+        return schema.safeParse(input).success ? { valid: true } : { valid: false, errors: ['Paramètres du catalogue invalides.'] };
+    }
+    async execute(input) {
+        const parsed = schema.safeParse(input);
+        if (!parsed.success)
+            return { success: false, error: 'Paramètres du catalogue invalides ; seules list et select sont disponibles.' };
+        try {
+            const args = parsed.data;
+            const result = args.operation === 'list' ? { resources: (await this.catalog.list()).map(publicResourceStatus) }
+                : await this.catalog.select(args.capability, args.kind).then(choice => {
+                    const warning = selectionWarning(choice.selected);
+                    return { excluded: choice.excluded, reason: choice.reason,
+                        selected: choice.selected ? publicResourceStatus(choice.selected) : null, ...(warning ? { warning } : {}) };
+                });
+            return { success: true, output: JSON.stringify({ ...result, dispatched: false, probed: false,
+                    instruction: 'Déclarations explicites, santé observée sans preuve d’usage et charge inconnue. Aucune sonde ni exécution effectuée. Une sélection ne change pas les endpoints des autres outils ; ragchat_search utilise RAGCHAT_BASE_URL configuré séparément.' }) };
+        }
+        catch {
+            return { success: false, error: 'Catalogue indisponible ou invalide ; aucune sonde, écriture ni exécution effectuée.' };
+        }
+    }
+}
+//# sourceMappingURL=resource-catalog-tool.js.map

package/dist/tools/skills-inspection-tool.js

@@ -6,6 +6,16 @@ function serializePayload(payload) {
         data: payload,
     };
 }
+/** Activity telemetry is best-effort: a failure never changes the tool result. */
+async function recordView(name) {
+    try {
+        const { recordSkillActivity } = await import('../skills/skill-usage-store.js');
+        recordSkillActivity(name, 'view', { source: 'skill_view' });
+    }
+    catch {
+        // Telemetry must never make skill inspection fail.
+    }
+}
 function stripUsage(skill) {
     const { usage: _usage, ...rest } = skill;
     return rest;
@@ -19,8 +29,16 @@ export async function executeSkillsListTool(input) {
         const includeUsage = input.include_usage !== false;
         const shown = includeDisabled ? all : all.filter((skill) => skill.enabled !== false);
         const skills = includeUsage ? shown : shown.map(stripUsage);
+        const { readLocalSkillInventory } = await import('../skills/local-inventory.js');
+        const inventory = await readLocalSkillInventory(all);
+        const availableSkills = inventory.entries.filter((skill) => skill.available);
         return serializePayload({
             action: 'skills_list',
+            availableSkills,
+            availableCount: availableSkills.length,
+            unavailableSkills: inventory.entries.filter((skill) => !skill.available),
+            discoveryErrors: inventory.errors,
+            guidance: 'Use availableSkills to answer which skills can be used. Requirements may need tools or external configuration. The skills/count/total fields below describe only hub records, not the complete local catalogue. Missing files are not configuration errors.',
             count: skills.length,
             total: all.length,
             includeDisabled,
@@ -40,9 +58,20 @@ export async function executeSkillViewTool(input) {
         const { getSkillsHub } = await import('../skills/hub.js');
         const result = getSkillsHub().info(name);
         if (!result) {
-            return { success: false, error: `skill_view: skill not found: ${name}` };
+            const { readLocalSkillInventory, readLocalSkillContent } = await import('../skills/local-inventory.js');
+            const inventory = await readLocalSkillInventory(getSkillsHub().listWithIntegrity());
+            const skill = inventory.entries.find((entry) => entry.name === name);
+            if (!skill)
+                return { success: false, error: `skill_view: skill not found: ${name}` };
+            await recordView(name);
+            return serializePayload({
+                action: 'skill_view',
+                skill,
+                ...(input.include_content !== false ? { content: await readLocalSkillContent(skill) } : {}),
+            });
         }
         const includeContent = input.include_content !== false;
+        await recordView(name);
         return serializePayload({
             action: 'skill_view',
             installed: result.installed,

package/dist/tools/stream-tool-output.d.ts

@@ -0,0 +1,3 @@
+import type { ToolResult } from '../types/index.js';
+/** Adapt a callback-based guarded tool invocation without bypassing its dispatch pipeline. */
+export declare function streamToolOutput(run: (signal: AbortSignal, emit: (delta: string) => void) => Promise<ToolResult>, signal?: AbortSignal): AsyncGenerator<string, ToolResult, undefined>;

package/dist/tools/stream-tool-output.js

@@ -0,0 +1,33 @@
+import { BoundedOutput } from '../utils/bounded-output.js';
+/** Adapt a callback-based guarded tool invocation without bypassing its dispatch pipeline. */
+export async function* streamToolOutput(run, signal) {
+    const controller = new AbortController();
+    const abort = () => controller.abort();
+    signal?.addEventListener('abort', abort, { once: true });
+    if (signal?.aborted)
+        abort();
+    const pending = new BoundedOutput(64 * 1024);
+    let result;
+    let wake;
+    const notify = () => { wake?.(); wake = undefined; };
+    const completion = Promise.resolve().then(() => run(controller.signal, delta => { pending.append(delta); notify(); }))
+        .then(value => { result = value; })
+        .catch(error => { result = { success: false, error: error instanceof Error ? error.message : String(error) }; })
+        .finally(notify);
+    try {
+        while (!result || pending.retainedBytes) {
+            if (pending.retainedBytes)
+                yield pending.drain();
+            else
+                await new Promise(resolve => { wake = resolve; });
+        }
+        return result;
+    }
+    finally {
+        abort();
+        signal?.removeEventListener('abort', abort);
+        // Observe completion without blocking a consumer that intentionally stops.
+        void completion;
+    }
+}
+//# sourceMappingURL=stream-tool-output.js.map

package/dist/tools/tool-call-scheduler.d.ts

@@ -0,0 +1,10 @@
+/** FIFO barriers for mutations, bounded parallelism for explicitly safe reads. */
+export declare class ToolCallScheduler {
+    private readonly concurrency;
+    private active;
+    private exclusive;
+    private queue;
+    constructor(concurrency?: number);
+    schedule<T>(parallel: boolean, action: () => Promise<T>, signal?: AbortSignal): Promise<T>;
+    private pump;
+}

package/dist/tools/tool-call-scheduler.js

@@ -0,0 +1,58 @@
+/** FIFO barriers for mutations, bounded parallelism for explicitly safe reads. */
+export class ToolCallScheduler {
+    concurrency;
+    active = 0;
+    exclusive = false;
+    queue = [];
+    constructor(concurrency = 4) {
+        this.concurrency = concurrency;
+        if (!Number.isSafeInteger(concurrency) || concurrency < 1 || concurrency > 64)
+            throw new Error('Concurrency must be an integer between 1 and 64');
+    }
+    schedule(parallel, action, signal) {
+        return new Promise((resolve, reject) => {
+            if (signal?.aborted) {
+                reject(new Error('Tool call cancelled'));
+                return;
+            }
+            const entry = { parallel, run: async () => {
+                    signal?.removeEventListener('abort', abort);
+                    try {
+                        resolve(await action());
+                    }
+                    catch (error) {
+                        reject(error);
+                    }
+                } };
+            const abort = () => {
+                const index = this.queue.indexOf(entry);
+                if (index < 0)
+                    return;
+                this.queue.splice(index, 1);
+                signal?.removeEventListener('abort', abort);
+                reject(new Error('Tool call cancelled'));
+                this.pump();
+            };
+            signal?.addEventListener('abort', abort, { once: true });
+            this.queue.push(entry);
+            this.pump();
+        });
+    }
+    pump() {
+        while (!this.exclusive && this.active < this.concurrency && this.queue.length) {
+            const next = this.queue[0];
+            if (!next.parallel && this.active)
+                return;
+            this.queue.shift();
+            this.active++;
+            this.exclusive = !next.parallel;
+            void next.run().finally(() => {
+                this.active--;
+                if (!next.parallel)
+                    this.exclusive = false;
+                this.pump();
+            });
+        }
+    }
+}
+//# sourceMappingURL=tool-call-scheduler.js.map

package/dist/tools/tool-effect.d.ts

@@ -0,0 +1,5 @@
+import { type ToolEffectClass, type ToolMetadata } from './types.js';
+/** Resolve a tool's declared effect class. Missing catalog/MCP entries warn once and return `unknown`. */
+export declare function resolveToolEffect(name: string, metadata?: Pick<ToolMetadata, 'effect'> | null): ToolEffectClass | 'unknown';
+/** Test hook: unique-warning latch. */
+export declare function resetToolEffectWarningLatch(): void;

package/dist/tools/tool-effect.js

@@ -0,0 +1,26 @@
+import { logger } from '../utils/logger.js';
+import { TOOL_METADATA } from './metadata.js';
+import { TOOL_EFFECT_CLASSES } from './types.js';
+// Runtime warnings live here so the tool catalog can also serve browser previews.
+const missingEffectWarned = new Set();
+function isToolEffectClass(value) {
+    return TOOL_EFFECT_CLASSES.includes(value);
+}
+/** Resolve a tool's declared effect class. Missing catalog/MCP entries warn once and return `unknown`. */
+export function resolveToolEffect(name, metadata) {
+    if (isToolEffectClass(metadata?.effect))
+        return metadata.effect;
+    const catalog = TOOL_METADATA.find((entry) => entry.name === name)?.effect;
+    if (isToolEffectClass(catalog))
+        return catalog;
+    if (!missingEffectWarned.has(name)) {
+        missingEffectWarned.add(name);
+        logger.warn('tool metadata missing effect class; treating as unknown', { tool: name });
+    }
+    return 'unknown';
+}
+/** Test hook: unique-warning latch. */
+export function resetToolEffectWarningLatch() {
+    missingEffectWarned.clear();
+}
+//# sourceMappingURL=tool-effect.js.map

package/dist/tools/tool-search.d.ts

@@ -9,21 +9,26 @@
  */
 import { BaseTool, ParameterDefinition } from './base-tool.js';
 import { ToolResult } from '../types/index.js';
+import type { IToolExecutionContext } from './registry/types.js';
+export interface SearchableTool {
+    name: string;
+    description: string;
+    keywords?: string[];
+    parameters?: unknown;
+}
 /**
  * Build a BM25 index from tool definitions.
  */
 export declare class BM25Index {
     private documents;
     private avgDL;
+    private catalog;
+    getTool(name: string): SearchableTool | undefined;
     private idf;
     /**
      * Add tool definitions to the index.
      */
-    index(tools: Array<{
-        name: string;
-        description: string;
-        keywords?: string[];
-    }>): void;
+    index(tools: SearchableTool[]): void;
     /**
      * Search for tools matching a query.
      * Returns results sorted by BM25 score (highest first).
@@ -37,11 +42,7 @@ export declare class BM25Index {
 /**
  * Initialize the BM25 index with available tools.
  */
-export declare function initToolSearchIndex(tools: Array<{
-    name: string;
-    description: string;
-    keywords?: string[];
-}>): void;
+export declare function initToolSearchIndex(tools: SearchableTool[]): void;
 /**
  * Get the BM25 index (creates empty if not initialized).
  */
@@ -50,5 +51,5 @@ export declare class ToolSearchTool extends BaseTool {
     readonly name = "tool_search";
     readonly description = "Search for available tools by keyword. Useful when you need to find a specific tool from a large set (especially MCP tools).";
     protected getParameters(): Record<string, ParameterDefinition>;
-    execute(input: Record<string, unknown>): Promise<ToolResult>;
+    execute(input: Record<string, unknown>, context?: IToolExecutionContext): Promise<ToolResult>;
 }

package/dist/tools/tool-search.js

@@ -8,10 +8,36 @@
  * Inspired by OpenAI Codex CLI's tool_search with BM25.
  */
 import { BaseTool } from './base-tool.js';
-import { resolveToolEffect } from './metadata.js';
+import { resolveToolEffect } from './tool-effect.js';
 // ============================================================================
 // BM25 Implementation
 // ============================================================================
+const QUERY_EQUIVALENTS = {
+    lire: ['read', 'view'],
+    voir: ['view', 'read'],
+    contenu: ['content', 'contents'],
+    contenus: ['content', 'contents'],
+    consulter: ['view', 'read'],
+    ouvrir: ['open', 'read', 'view'],
+    afficher: ['show', 'display', 'view', 'list'],
+    fichier: ['file'],
+    fichiers: ['file', 'files'],
+    dossier: ['directory', 'folder'],
+    dossiers: ['directory', 'directories', 'folder', 'folders'],
+    repertoire: ['directory', 'folder'],
+    repertoires: ['directory', 'directories', 'folder', 'folders'],
+    chercher: ['search', 'find'],
+    rechercher: ['search', 'find'],
+    trouver: ['find', 'search'],
+    modifier: ['edit', 'replace'],
+    remplacer: ['replace', 'edit'],
+    creer: ['create'],
+    supprimer: ['delete', 'remove'],
+    memoire: ['memory'],
+    executer: ['execute', 'run'],
+    lancer: ['run', 'execute'],
+    commande: ['command'],
+};
 /** BM25 parameters */
 const K1 = 1.2; // Term frequency saturation
 const B = 0.75; // Length normalization
@@ -20,10 +46,11 @@ const B = 0.75; // Length normalization
  */
 function tokenize(text) {
     return text
+        .replace(/([a-z\d])([A-Z])/g, '$1 $2')
+        .normalize('NFKD').replace(/\p{M}/gu, '')
         .toLowerCase()
-        .replace(/[^a-z0-9_-]/g, ' ')
-        .split(/\s+/)
-        .filter(t => t.length > 1);
+        .split(/[^\p{L}\p{N}]+/u)
+        .filter(Boolean);
 }
 /**
  * Build a BM25 index from tool definitions.
@@ -31,14 +58,18 @@ function tokenize(text) {
 export class BM25Index {
     documents = [];
     avgDL = 0;
+    catalog = new Map();
+    getTool(name) { return this.catalog.get(name); }
     idf = new Map();
     /**
      * Add tool definitions to the index.
      */
     index(tools) {
-        this.documents = tools.map(t => {
+        this.idf.clear();
+        this.catalog = new Map(tools.map(tool => [tool.name, tool]));
+        this.documents = [...this.catalog.values()].map(t => {
             const tokens = [
-                ...tokenize(t.name),
+                ...Array.from({ length: 3 }, () => tokenize(t.name)).flat(),
                 ...tokenize(t.description),
                 ...(t.keywords ?? []).flatMap(k => tokenize(k)),
             ];
@@ -59,14 +90,13 @@ export class BM25Index {
         this.avgDL = this.documents.reduce((sum, d) => sum + d.length, 0) / Math.max(this.documents.length, 1);
         // Compute IDF for all terms
         const N = this.documents.length;
-        const allTerms = new Set();
+        const frequencies = new Map();
         for (const doc of this.documents) {
             for (const token of doc.tf.keys()) {
-                allTerms.add(token);
+                frequencies.set(token, (frequencies.get(token) ?? 0) + 1);
             }
         }
-        for (const term of allTerms) {
-            const df = this.documents.filter(d => d.tf.has(term)).length;
+        for (const [term, df] of frequencies) {
             this.idf.set(term, Math.log((N - df + 0.5) / (df + 0.5) + 1));
         }
     }
@@ -75,11 +105,12 @@ export class BM25Index {
      * Returns results sorted by BM25 score (highest first).
      */
     search(query, maxResults = 10) {
-        const queryTokens = tokenize(query);
+        const queryTokens = [...new Set(tokenize(query).flatMap(term => [term, ...(QUERY_EQUIVALENTS[term] ?? [])]))];
+        const limit = Number.isFinite(maxResults) ? Math.max(1, Math.min(50, Math.floor(maxResults))) : 10;
         if (queryTokens.length === 0)
             return [];
         const scored = this.documents.map(doc => {
-            let score = 0;
+            let score = doc.name.toLowerCase() === query.trim().toLowerCase() ? 100 : 0;
             for (const qToken of queryTokens) {
                 const tf = doc.tf.get(qToken) ?? 0;
                 const idf = this.idf.get(qToken) ?? 0;
@@ -88,12 +119,15 @@ export class BM25Index {
                 const denominator = tf + K1 * (1 - B + B * (doc.length / this.avgDL));
                 score += idf * (numerator / denominator);
             }
+            const nameTerms = new Set(tokenize(doc.name));
+            if (queryTokens.every(term => nameTerms.has(term)))
+                score += 5;
             return { name: doc.name, description: doc.description, score };
         });
         return scored
             .filter(s => s.score > 0)
-            .sort((a, b) => b.score - a.score)
-            .slice(0, maxResults);
+            .sort((a, b) => b.score - a.score || a.name.localeCompare(b.name))
+            .slice(0, limit);
     }
 }
 // ============================================================================
@@ -133,12 +167,17 @@ export class ToolSearchTool extends BaseTool {
             },
         };
     }
-    async execute(input) {
+    async execute(input, context) {
         const query = input.query;
-        if (!query)
-            return this.error('query is required');
+        if (typeof query !== 'string' || !query.trim() || query.length > 2000)
+            return this.error('query must be a nonempty string of at most 2000 characters');
+        if (input.max_results !== undefined && (typeof input.max_results !== 'number' || !Number.isInteger(input.max_results) || input.max_results < 1 || input.max_results > 50))
+            return this.error('max_results must be an integer between 1 and 50');
         const maxResults = typeof input.max_results === 'number' ? input.max_results : 10;
-        const index = getToolSearchIndex();
+        const catalog = context?.extra?.toolSearchCatalog;
+        const index = Array.isArray(catalog) ? new BM25Index() : getToolSearchIndex();
+        if (Array.isArray(catalog))
+            index.index(catalog);
         const results = index.search(query, maxResults);
         if (results.length === 0) {
             return this.success(`No tools found matching "${query}".`);
@@ -154,22 +193,24 @@ export class ToolSearchTool extends BaseTool {
         catch {
             // tools.js not available — skip deferred schema resolution
         }
-        const lines = results.map((r, i) => {
+        const tools = results.map(result => ({
+            ...result,
+            effect: resolveToolEffect(result.name),
+            parameters: index.getTool(result.name)?.parameters ??
+                deferredSchemas?.get(result.name)?.function?.parameters,
+        }));
+        const lines = tools.map((r, i) => {
             const effect = resolveToolEffect(r.name);
             let line = `${i + 1}. **${r.name}** (score: ${r.score.toFixed(2)})\n   effect: ${effect}\n   ${r.description}`;
-            // If deferred, include the full schema so the LLM can call it
-            if (deferredSchemas?.has(r.name)) {
-                const fullTool = deferredSchemas.get(r.name);
-                if (fullTool?.function?.parameters) {
-                    line += `\n   Schema: ${JSON.stringify(fullTool.function.parameters)}`;
-                }
-            }
+            if (r.parameters)
+                line += `\n   Schema: ${JSON.stringify(r.parameters)}`;
             return line;
         });
         // data.names lets the executor EXPAND the current turn's tool selection
         // with what was discovered — finding a tool must make it invocable on the
         // next round (true progressive disclosure), not just describe it.
         return this.success(`Found ${results.length} tools:\n\n${lines.join('\n\n')}`, {
+            tools,
             names: results.map((r) => r.name),
             effects: Object.fromEntries(results.map((r) => [r.name, resolveToolEffect(r.name)])),
         });

package/dist/tools/types.d.ts

@@ -49,6 +49,12 @@ export interface ToolMetadata {
      * silently filtered out from peer-visible tool lists.
      */
     fleetSafe?: boolean;
+    /**
+     * Polling/status tool that may legitimately be called repeatedly with the
+     * same arguments and result (e.g. waiting on a background job). The tool
+     * loop guard (`src/agent/execution/tool-loop-guard.ts`) never counts it.
+     */
+    repeatSafe?: boolean;
 }
 /**
  * Result of classifying a user query into tool categories.

package/dist/ui/components/ChatHistory.d.ts

@@ -6,5 +6,5 @@ interface ChatHistoryProps {
     /** Maximum number of messages to display (default: 50) */
     maxMessages?: number;
 }
-export declare function ChatHistory({ entries, isConfirmationActive, maxMessages, }: ChatHistoryProps): React.JSX.Element;
+export declare const ChatHistory: React.NamedExoticComponent<ChatHistoryProps>;
 export {};

package/dist/ui/components/ChatHistory.js

@@ -265,7 +265,7 @@ const MemoizedChatEntry = React.memo(({ entry, index, colors, avatars }) => {
     }
 });
 MemoizedChatEntry.displayName = "MemoizedChatEntry";
-export function ChatHistory({ entries, isConfirmationActive = false, maxMessages = 50, }) {
+export const ChatHistory = React.memo(function ChatHistory({ entries, isConfirmationActive = false, maxMessages = 50, }) {
     const { colors, avatars } = useTheme();
     // Number of entries permanently committed to <Static> (monotonically increasing)
     // Entries start in the dynamic section and move to static AFTER being finalized
@@ -336,5 +336,5 @@ export function ChatHistory({ entries, isConfirmationActive = false, maxMessages
                 " in scrollback"))),
         React.createElement(Static, { items: staticItems }, (entry) => (React.createElement(MemoizedChatEntry, { key: entry.uniqueKey, entry: entry, index: 0, colors: colors, avatars: avatars }))),
         dynamicItems.map((entry, index) => (React.createElement(MemoizedChatEntry, { key: entry.uniqueKey, entry: entry, index: index, colors: colors, avatars: avatars })))));
-}
+});
 //# sourceMappingURL=ChatHistory.js.map

package/dist/ui/components/ChatInput.d.ts

@@ -1,4 +1,4 @@
-import React from "react";
+import React from 'react';
 interface ChatInputProps {
     input: string;
     cursorPosition: number;
@@ -6,5 +6,6 @@ interface ChatInputProps {
     isStreaming: boolean;
     mode?: string;
 }
+/** A bounded draft viewport. Editing remains available while the agent works. */
 export declare const ChatInput: React.NamedExoticComponent<ChatInputProps>;
 export {};