catui-agent 1.0.0-beta.0

package/dist/core/tools/grep.d.ts

@@ -0,0 +1,58 @@
+import type { AgentTool } from "@catui/agent-core";
+import { type Static } from "@sinclair/typebox";
+import { type TruncationResult } from "./truncate.js";
+declare const grepSchema: import("@sinclair/typebox").TObject<{
+    pattern: import("@sinclair/typebox").TString;
+    path: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+    glob: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+    ignoreCase: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TBoolean>;
+    literal: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TBoolean>;
+    context: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TInteger>;
+    output_mode: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TUnion<[import("@sinclair/typebox").TLiteral<"content">, import("@sinclair/typebox").TLiteral<"files_with_matches">, import("@sinclair/typebox").TLiteral<"count">]>>;
+    type: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+    contextBefore: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TInteger>;
+    contextAfter: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TInteger>;
+    offset: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TInteger>;
+    multiline: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TBoolean>;
+    limit: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TInteger>;
+    head_limit: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TInteger>;
+}>;
+export type GrepToolInput = Static<typeof grepSchema>;
+export interface GrepToolDetails {
+    truncation?: TruncationResult;
+    matchLimitReached?: number;
+    linesTruncated?: boolean;
+}
+/**
+ * Pluggable operations for the grep tool.
+ * Override these to delegate search to remote systems (e.g., SSH).
+ */
+export interface GrepOperations {
+    /** Check if path is a directory. Throws if path doesn't exist. */
+    isDirectory: (absolutePath: string) => Promise<boolean> | boolean;
+    /** Read file contents for context lines */
+    readFile: (absolutePath: string) => Promise<string> | string;
+}
+export interface GrepToolOptions {
+    /** Custom operations for grep. Default: local filesystem + ripgrep */
+    operations?: GrepOperations;
+}
+export declare function createGrepTool(cwd: string, options?: GrepToolOptions): AgentTool<typeof grepSchema>;
+/** Default grep tool using process.cwd() - for backwards compatibility */
+export declare const grepTool: AgentTool<import("@sinclair/typebox").TObject<{
+    pattern: import("@sinclair/typebox").TString;
+    path: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+    glob: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+    ignoreCase: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TBoolean>;
+    literal: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TBoolean>;
+    context: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TInteger>;
+    output_mode: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TUnion<[import("@sinclair/typebox").TLiteral<"content">, import("@sinclair/typebox").TLiteral<"files_with_matches">, import("@sinclair/typebox").TLiteral<"count">]>>;
+    type: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+    contextBefore: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TInteger>;
+    contextAfter: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TInteger>;
+    offset: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TInteger>;
+    multiline: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TBoolean>;
+    limit: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TInteger>;
+    head_limit: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TInteger>;
+}>, any>;
+export {};

package/dist/core/tools/grep.js

@@ -0,0 +1,13 @@
+var yt=Object.defineProperty;var o=(u,v)=>yt(u,"name",{value:v,configurable:!0});import{createInterface as wt}from"node:readline";import{Type as e}from"@sinclair/typebox";import{spawn as Lt}from"child_process";import{readFileSync as bt,statSync as xt}from"fs";import et from"path";import{ensureTool as Ot}from"../platform/utils/tools-manager.js";import{validateIntegerWindowOption as $}from"./input-validation.js";import{resolveToCwd as $t}from"./path-utils.js";import{DEFAULT_MAX_BYTES as nt,formatSize as vt,GREP_MAX_LINE_LENGTH as it,truncateHead as _t,truncateLine as St}from"./truncate.js";const Et=e.Object({pattern:e.String({description:"Search pattern (regex or literal string)"}),path:e.Optional(e.String({description:"Directory or file to search (default: current directory)"})),glob:e.Optional(e.String({description:"Filter files by glob pattern, e.g. '*.ts' or '**/*.spec.ts'"})),ignoreCase:e.Optional(e.Boolean({description:"Case-insensitive search (default: false)"})),literal:e.Optional(e.Boolean({description:"Treat pattern as literal string instead of regex (default: false)"})),context:e.Optional(e.Integer({minimum:0,description:"Number of lines to show before and after each match (default: 0)"})),output_mode:e.Optional(e.Union([e.Literal("content"),e.Literal("files_with_matches"),e.Literal("count")],{description:"Output mode: 'content' (default) returns matching lines, 'files_with_matches' returns only file paths, 'count' returns match counts per file"})),type:e.Optional(e.String({description:"File type filter, e.g. 'js', 'py', 'rust' (maps to rg --type)"})),contextBefore:e.Optional(e.Integer({minimum:0,description:"Lines to show before each match (overrides context)"})),contextAfter:e.Optional(e.Integer({minimum:0,description:"Lines to show after each match (overrides context)"})),offset:e.Optional(e.Integer({minimum:0,description:"Skip first N matches"})),multiline:e.Optional(e.Boolean({description:"Enable multiline matching (default: false)"})),limit:e.Optional(e.Integer({minimum:1,description:"Maximum number of matches to return (default: 250)"})),head_limit:e.Optional(e.Integer({minimum:1,description:"Alias for limit (CC compatibility)"}))}),rt=250,Tt={isDirectory:o(u=>xt(u).isDirectory(),"isDirectory"),readFile:o(u=>bt(u,"utf-8"),"readFile")};function It(u,v){const ot=v?.operations;return{name:"grep",label:"grep",description:`Search file contents for a pattern. Supports multiple output modes (content, files_with_matches, count), file type filters, multiline matching, and per-side context control (-A/-B). Respects .gitignore. Output is truncated to ${rt} matches or ${nt/1024}KB (whichever is hit first). Long lines are truncated to ${it} chars.`,parameters:Et,isConcurrencySafe:!0,execute:o(async(Ct,{pattern:at,path:st,glob:I,ignoreCase:ct,literal:lt,context:_,output_mode:ut,type:C,contextBefore:pt,contextAfter:mt,offset:F,multiline:ft,limit:M,head_limit:k},S)=>{$({name:"context",value:_,minimum:0}),$({name:"limit",value:M,minimum:1}),$({name:"head_limit",value:k,minimum:1}),$({name:"offset",value:F,minimum:0});const a=k??M??rt,E=F??0,A=ut??"content",B=pt??_??0,D=mt??_??0;return new Promise((w,p)=>{if(S?.aborted){p(new Error("Operation aborted"));return}let P=!1;const s=o(d=>{P||(P=!0,d())},"settle");(async()=>{try{const d=await Ot("rg",!0);if(!d){s(()=>p(new Error("ripgrep (rg) is not available and could not be downloaded")));return}const L=$t(st||".",u),R=ot??Tt;let U;try{U=await R.isDirectory(L)}catch{s(()=>p(new Error(`Path not found: ${L}`)));return}const j=o(n=>{if(U){const t=et.relative(L,n);if(t&&!t.startsWith(".."))return t.replace(/\\/g,"/")}return et.basename(n)},"formatPath"),G=new Map,dt=o(async n=>{let t=G.get(n);if(!t){try{t=(await R.readFile(n)).replace(/\r\n/g,`
+`).replace(/\r/g,`
+`).split(`
+`)}catch{t=[]}G.set(n,t)}return t},"getFileLines"),m=["--json","--line-number","--color=never","--hidden"];ct&&m.push("--ignore-case"),lt&&m.push("--fixed-strings"),I&&m.push("--glob",I),C&&m.push("--type",C),ft&&m.push("--multiline-dotall"),m.push(at,L);const h=Lt(d,m,{stdio:["ignore","pipe","pipe"]}),N=wt({input:h.stdout});let X="",g=0,b=!1,z=!1,H=!1,W=!1;const J=[],K=o(()=>{N.close(),S?.removeEventListener("abort",q)},"cleanup"),Y=o((n=!1)=>{h.killed||(W=n,h.kill())},"stopChild"),q=o(()=>{H=!0,Y()},"onAbort");S?.addEventListener("abort",q,{once:!0}),h.stderr?.on("data",n=>{X+=n.toString()});const ht=o(async(n,t)=>{const i=j(n),c=await dt(n);if(!c.length)return[`${i}:${t}: (unable to read file)`];const f=[],x=B>0?Math.max(1,t-B):t,l=D>0?Math.min(c.length,t+D):t;for(let r=x;r<=l;r++){const y=(c[r-1]??"").replace(/\r/g,""),Z=r===t,{text:tt,wasTruncated:gt}=St(y);gt&&(z=!0),Z?f.push(`${i}:${r}: ${tt}`):f.push(`${i}-${r}- ${tt}`)}return f},"formatBlock"),Q=[],V=new Set,T=new Map;N.on("line",n=>{if(!n.trim()||g>=a+E)return;let t;try{t=JSON.parse(n)}catch{return}if(t.type==="match"){g++;const i=t.data?.path?.text,c=t.data?.line_number;if(i&&T.set(i,(T.get(i)??0)+1),g<=E)return;i&&typeof c=="number"&&(Q.push({filePath:i,lineNumber:c}),V.add(i)),g>=a+E&&(b=!0,Y(!0))}}),h.on("error",n=>{K(),s(()=>p(new Error(`Failed to run ripgrep: ${n.message}`)))}),h.on("close",async n=>{if(K(),H){s(()=>p(new Error("Operation aborted")));return}if(!W&&n!==0&&n!==1){const l=X.trim()||`ripgrep exited with code ${n}`;s(()=>p(new Error(l)));return}if(g===0){s(()=>w({content:[{type:"text",text:"No matches found"}],details:void 0}));return}const t={},i=[];if(A==="files_with_matches"){let r=[...V].sort().join(`
+`);b&&(i.push(`${a} matches limit reached. Use limit=${a*2} for more, or refine pattern`),t.matchLimitReached=a),i.length>0&&(r+=`
+
+[${i.join(". ")}]`),s(()=>w({content:[{type:"text",text:r}],details:Object.keys(t).length>0?t:void 0}));return}if(A==="count"){let r=[...T.entries()].sort(([O],[y])=>O.localeCompare(y)).map(([O,y])=>`${j(O)}: ${y}`).join(`
+`);b&&(i.push(`${a} matches limit reached. Use limit=${a*2} for more, or refine pattern`),t.matchLimitReached=a),i.length>0&&(r+=`
+
+[${i.join(". ")}]`),s(()=>w({content:[{type:"text",text:r}],details:Object.keys(t).length>0?t:void 0}));return}for(const l of Q){const r=await ht(l.filePath,l.lineNumber);J.push(...r)}const c=J.join(`
+`),f=_t(c,{maxLines:Number.MAX_SAFE_INTEGER});let x=f.content;b&&(i.push(`${a} matches limit reached. Use limit=${a*2} for more, or refine pattern`),t.matchLimitReached=a),f.truncated&&(i.push(`${vt(nt)} limit reached`),t.truncation=f),z&&(i.push(`Some lines truncated to ${it} chars. Use read tool to see full lines`),t.linesTruncated=!0),i.length>0&&(x+=`
+
+[${i.join(". ")}]`),s(()=>w({content:[{type:"text",text:x}],details:Object.keys(t).length>0?t:void 0}))})}catch(d){s(()=>p(d))}})()})},"execute")}}o(It,"createGrepTool");const Gt=It(process.cwd());export{It as createGrepTool,Gt as grepTool};

package/dist/core/tools/index.d.ts

@@ -0,0 +1,116 @@
+/**
+ * [WHO]: Tool registry, all tool creators and types
+ * [FROM]: Depends on bash.ts, read.ts, edit.ts, write.ts, grep.ts, find.ts, ls.ts, source.ts
+ * [TO]: Consumed by index.ts, main.ts, cli/args.ts, modes/interactive/components/tool-execution.ts, extensions/builtin/team/index.ts, and test files
+ * [HERE]: Tool system public API; consumed by SDK and orchestrator
+ */
+export { fileStateCache, type FileState } from "./file-state-cache.js";
+export { type BashOperations, type BashSandboxOptions, type BashSpawnContext, type BashSpawnHook, type BashToolDetails, type BashToolInput, type BashToolOptions, bashTool, createBashTool, createSandboxHook, } from "./bash.js";
+export { createEditTool, type EditOperations, type EditToolDetails, type EditToolInput, type EditToolOptions, editTool, } from "./edit.js";
+export { createFindTool, type FindOperations, type FindToolDetails, type FindToolInput, type FindToolOptions, findTool, } from "./find.js";
+export { createGrepTool, type GrepOperations, type GrepToolDetails, type GrepToolInput, type GrepToolOptions, grepTool, } from "./grep.js";
+export { createLsTool, type LsOperations, type LsToolDetails, type LsToolInput, type LsToolOptions, lsTool, } from "./ls.js";
+export { createReadTool, type ReadOperations, type ReadToolDetails, type ReadToolInput, type ReadToolOptions, readTool, } from "./read.js";
+export { createTimeTool, type TimeToolInput, timeTool } from "./time.js";
+export { DEFAULT_MAX_BYTES, DEFAULT_MAX_LINES, formatSize, type TruncationOptions, type TruncationResult, truncateHead, truncateLine, truncateTail, } from "./truncate.js";
+export { createWriteTool, type WriteOperations, type WriteToolInput, type WriteToolOptions, writeTool, } from "./write.js";
+export { createWorkspaceWriteGuard, isPathWithinRoot } from "./write-guard.js";
+import type { AgentTool } from "@catui/agent-core";
+import { type BashToolOptions } from "./bash.js";
+import { type EditToolOptions } from "./edit.js";
+import { type ReadToolOptions } from "./read.js";
+import { type WriteToolOptions } from "./write.js";
+/** Tool type (AgentTool from catui-ai) */
+export type Tool = AgentTool<any>;
+export declare const codingTools: Tool[];
+export declare const readOnlyTools: Tool[];
+export declare const allTools: {
+    read: AgentTool<import("@sinclair/typebox").TObject<{
+        path: import("@sinclair/typebox").TString;
+        offset: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TInteger>;
+        limit: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TInteger>;
+        pages: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+    }>, any>;
+    bash: AgentTool<import("@sinclair/typebox").TObject<{
+        command: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+        timeout: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TNumber>;
+        description: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+        run_in_background: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TBoolean>;
+        task_id: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+    }>, any>;
+    edit: AgentTool<import("@sinclair/typebox").TObject<{
+        path: import("@sinclair/typebox").TString;
+        oldText: import("@sinclair/typebox").TString;
+        newText: import("@sinclair/typebox").TString;
+    }>, any>;
+    write: AgentTool<import("@sinclair/typebox").TObject<{
+        path: import("@sinclair/typebox").TString;
+        content: import("@sinclair/typebox").TString;
+    }>, any>;
+    grep: AgentTool<import("@sinclair/typebox").TObject<{
+        pattern: import("@sinclair/typebox").TString;
+        path: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+        glob: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+        ignoreCase: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TBoolean>;
+        literal: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TBoolean>;
+        context: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TInteger>;
+        output_mode: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TUnion<[import("@sinclair/typebox").TLiteral<"content">, import("@sinclair/typebox").TLiteral<"files_with_matches">, import("@sinclair/typebox").TLiteral<"count">]>>;
+        type: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+        contextBefore: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TInteger>;
+        contextAfter: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TInteger>;
+        offset: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TInteger>;
+        multiline: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TBoolean>;
+        limit: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TInteger>;
+        head_limit: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TInteger>;
+    }>, any>;
+    find: AgentTool<import("@sinclair/typebox").TObject<{
+        pattern: import("@sinclair/typebox").TString;
+        path: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+        limit: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TInteger>;
+        sort: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+    }>, any>;
+    ls: AgentTool<import("@sinclair/typebox").TObject<{
+        path: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+        limit: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TInteger>;
+    }>, any>;
+    time: AgentTool<import("@sinclair/typebox").TObject<{
+        timeZone: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+        locale: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+    }>, any>;
+};
+export type ToolName = keyof typeof allTools;
+export interface ToolsOptions {
+    /** Options for the read tool */
+    read?: ReadToolOptions;
+    /** Options for the bash tool */
+    bash?: BashToolOptions;
+    /** Options for the edit tool */
+    edit?: EditToolOptions;
+    /** Options for the write tool */
+    write?: WriteToolOptions;
+}
+/**
+ * Create coding tools configured for a specific working directory.
+ */
+export declare function createCodingTools(cwd: string, options?: ToolsOptions): Tool[];
+/**
+ * Create read-only tools configured for a specific working directory.
+ */
+export declare function createReadOnlyTools(cwd: string, options?: ToolsOptions): Tool[];
+/**
+ * Create all tools configured for a specific working directory.
+ */
+export declare function createAllTools(cwd: string, options?: ToolsOptions): Record<ToolName, Tool>;
+/**
+ * Tool guidance for system prompt.
+ * These are usage guidelines shown to the AI to help it use tools correctly.
+ */
+export declare const toolGuidance: Record<string, string>;
+/**
+ * Get guidance for a specific tool
+ */
+export declare function getToolGuidance(toolName: string): string | undefined;
+/**
+ * Get guidance for multiple tools
+ */
+export declare function getToolsGuidance(toolNames: string[]): Record<string, string>;

package/dist/core/tools/index.js

@@ -0,0 +1 @@
+var E=Object.defineProperty;var t=(e,o)=>E(e,"name",{value:o,configurable:!0});import{fileStateCache as Y}from"./file-state-cache.js";import{bashTool as z,createBashTool as I,createSandboxHook as N}from"./bash.js";import{createEditTool as J,editTool as K}from"./edit.js";import{createFindTool as V,findTool as Z}from"./find.js";import{createGrepTool as ee,grepTool as oe}from"./grep.js";import{createLsTool as re,lsTool as ie}from"./ls.js";import{createReadTool as ne,readTool as le}from"./read.js";import{createTimeTool as ce,timeTool as fe}from"./time.js";import{DEFAULT_MAX_BYTES as de,DEFAULT_MAX_LINES as Te,formatSize as pe,truncateHead as ue,truncateLine as he,truncateTail as xe}from"./truncate.js";import{createWriteTool as be,writeTool as ye}from"./write.js";import{createWorkspaceWriteGuard as Ee,isPathWithinRoot as Ge}from"./write-guard.js";import{bashTool as f,createBashTool as m}from"./bash.js";import{createEditTool as d,editTool as T}from"./edit.js";import{createFindTool as p,findTool as u}from"./find.js";import{createGrepTool as h,grepTool as x}from"./grep.js";import{createLsTool as g,lsTool as b}from"./ls.js";import{createReadTool as r,readTool as i}from"./read.js";import{createTimeTool as a,timeTool as n}from"./time.js";import{createWriteTool as y,writeTool as S}from"./write.js";const k=[i,f,T,S,n],w=[i,x,u,b,n],B={read:i,bash:f,edit:T,write:S,grep:x,find:u,ls:b,time:n};function C(e,o){return[r(e,o?.read),m(e,o?.bash),d(e,o?.edit),y(e,o?.write),a()]}t(C,"createCodingTools");function P(e,o){return[r(e,o?.read),h(e),p(e),g(e),a()]}t(P,"createReadOnlyTools");function D(e,o){return{read:r(e,o?.read),bash:m(e,o?.bash),edit:d(e,o?.edit),write:y(e,o?.write),grep:h(e),find:p(e),ls:g(e),time:a()}}t(D,"createAllTools");const l={read:"Read file contents. Prefer this tool to view files; do not use cat or other commands.",bash:"Execute bash commands (ls, grep, find, etc.) for file operations and system interaction.",edit:"Perform precise edits on files. Uses find-and-replace; old text must match exactly. Use read to view the file before editing.",write:"Create or overwrite files. Use only when creating new files or doing complete rewrites.",grep:"Search for patterns in file contents (respects .gitignore). Suitable for finding specific strings in code.",find:"Find files by glob pattern (respects .gitignore). Suitable for finding files with specific names.",ls:"List directory contents."};l.time="Get the real current system time. You must use this for current time/date questions, today/tomorrow/yesterday, deadlines, schedules, or any temporal reasoning that depends on the live system clock.";function H(e){return l[e]}t(H,"getToolGuidance");function M(e){const o={};for(const s of e){const c=l[s];c&&(o[s]=c)}return o}t(M,"getToolsGuidance");export{de as DEFAULT_MAX_BYTES,Te as DEFAULT_MAX_LINES,B as allTools,z as bashTool,k as codingTools,D as createAllTools,I as createBashTool,C as createCodingTools,J as createEditTool,V as createFindTool,ee as createGrepTool,re as createLsTool,P as createReadOnlyTools,ne as createReadTool,N as createSandboxHook,ce as createTimeTool,Ee as createWorkspaceWriteGuard,be as createWriteTool,K as editTool,Y as fileStateCache,Z as findTool,pe as formatSize,H as getToolGuidance,M as getToolsGuidance,oe as grepTool,Ge as isPathWithinRoot,ie as lsTool,w as readOnlyTools,le as readTool,fe as timeTool,l as toolGuidance,ue as truncateHead,he as truncateLine,xe as truncateTail,ye as writeTool};

package/dist/core/tools/input-validation.d.ts

@@ -0,0 +1,13 @@
+/**
+ * [WHO]: Provides validateIntegerWindowOption(), validatePositiveNumberOption()
+ * [FROM]: No external dependencies
+ * [TO]: Consumed by read/find/grep/ls tools for numeric window validation
+ * [HERE]: core/tools/input-validation.ts - shared input invariant helpers for tool schemas
+ */
+export interface IntegerWindowOption {
+    name: string;
+    value: number | undefined;
+    minimum: number;
+}
+export declare function validateIntegerWindowOption({ name, value, minimum }: IntegerWindowOption): void;
+export declare function validatePositiveNumberOption(name: string, value: number | undefined): void;

package/dist/core/tools/input-validation.js

@@ -0,0 +1 @@
+var i=Object.defineProperty;var t=(r,e)=>i(r,"name",{value:e,configurable:!0});function f({name:r,value:e,minimum:n}){if(e!==void 0&&(!Number.isInteger(e)||e<n))throw new Error(`${r} must be an integer greater than or equal to ${n}`)}t(f,"validateIntegerWindowOption");function u(r,e){if(e!==void 0&&(!Number.isFinite(e)||e<=0))throw new Error(`${r} must be a positive number`)}t(u,"validatePositiveNumberOption");export{f as validateIntegerWindowOption,u as validatePositiveNumberOption};

package/dist/core/tools/ls.d.ts

@@ -0,0 +1,45 @@
+/**
+ * [WHO]: LsTool, lsTool, createLsTool, LsToolInput
+ * [FROM]: Depends on agent-core, node:fs, path-utils.ts, truncate.ts
+ * [TO]: Consumed by core/tools/index.ts
+ * [HERE]: core/tools/ls.ts - directory listing with metadata; consumed by orchestrator
+ */
+import type { AgentTool } from "@catui/agent-core";
+import { type Static } from "@sinclair/typebox";
+import { type TruncationResult } from "./truncate.js";
+declare const lsSchema: import("@sinclair/typebox").TObject<{
+    path: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+    limit: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TInteger>;
+}>;
+export type LsToolInput = Static<typeof lsSchema>;
+export interface LsToolDetails {
+    truncation?: TruncationResult;
+    entryLimitReached?: number;
+}
+/**
+ * Pluggable operations for the ls tool.
+ * Override these to delegate directory listing to remote systems (e.g., SSH).
+ */
+export interface LsOperations {
+    /** Check if path exists */
+    exists: (absolutePath: string) => Promise<boolean> | boolean;
+    /** Get file/directory stats. Throws if not found. */
+    stat: (absolutePath: string) => Promise<{
+        isDirectory: () => boolean;
+    }> | {
+        isDirectory: () => boolean;
+    };
+    /** Read directory entries */
+    readdir: (absolutePath: string) => Promise<string[]> | string[];
+}
+export interface LsToolOptions {
+    /** Custom operations for directory listing. Default: local filesystem */
+    operations?: LsOperations;
+}
+export declare function createLsTool(cwd: string, options?: LsToolOptions): AgentTool<typeof lsSchema>;
+/** Default ls tool using process.cwd() - for backwards compatibility */
+export declare const lsTool: AgentTool<import("@sinclair/typebox").TObject<{
+    path: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+    limit: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TInteger>;
+}>, any>;
+export {};

package/dist/core/tools/ls.js

@@ -0,0 +1,4 @@
+var $=Object.defineProperty;var o=(e,l)=>$(e,"name",{value:l,configurable:!0});import{Type as i}from"@sinclair/typebox";import{existsSync as g,readdirSync as C,statSync as I}from"fs";import A from"path";import{validateIntegerWindowOption as _}from"./input-validation.js";import{resolveToCwd as D}from"./path-utils.js";import{DEFAULT_MAX_BYTES as S,formatSize as M,truncateHead as P}from"./truncate.js";const R=i.Object({path:i.Optional(i.String({description:"Directory to list (default: current directory)"})),limit:i.Optional(i.Integer({minimum:1,description:"Maximum number of entries to return (default: 500)"}))}),O=500,F={exists:g,stat:I,readdir:C};function N(e){return e instanceof Error?e.message:String(e)}o(N,"getErrorMessage");function U(e,l){const s=l?.operations??F;return{name:"ls",label:"ls",description:`List directory contents. Returns entries sorted alphabetically, with '/' suffix for directories. Includes dotfiles. Output is truncated to ${O} entries or ${S/1024}KB (whichever is hit first).`,parameters:R,isConcurrencySafe:!0,execute:o(async(k,{path:v,limit:w},a)=>(_({name:"limit",value:w,minimum:1}),new Promise((E,r)=>{if(a?.aborted){r(new Error("Operation aborted"));return}const m=o(()=>r(new Error("Operation aborted")),"onAbort");a?.addEventListener("abort",m,{once:!0}),(async()=>{try{const t=D(v||".",e),c=w??O;if(!await s.exists(t)){r(new Error(`Path not found: ${t}`));return}if(!(await s.stat(t)).isDirectory()){r(new Error(`Not a directory: ${t}`));return}let p;try{p=await s.readdir(t)}catch(n){r(new Error(`Cannot read directory: ${N(n)}`));return}p.sort((n,h)=>n.toLowerCase().localeCompare(h.toLowerCase()));const u=[];let L=!1;for(const n of p){if(u.length>=c){L=!0;break}const h=A.join(t,n);let x="";try{(await s.stat(h)).isDirectory()&&(x="/")}catch{continue}u.push(n+x)}if(a?.removeEventListener("abort",m),u.length===0){E({content:[{type:"text",text:"(empty directory)"}],details:void 0});return}const T=u.join(`
+`),y=P(T,{maxLines:Number.MAX_SAFE_INTEGER});let b=y.content;const d={},f=[];L&&(f.push(`${c} entries limit reached. Use limit=${c*2} for more`),d.entryLimitReached=c),y.truncated&&(f.push(`${M(S)} limit reached`),d.truncation=y),f.length>0&&(b+=`
+
+[${f.join(". ")}]`),E({content:[{type:"text",text:b}],details:Object.keys(d).length>0?d:void 0})}catch(t){a?.removeEventListener("abort",m),r(t)}})()})),"execute")}}o(U,"createLsTool");const q=U(process.cwd());export{U as createLsTool,q as lsTool};

package/dist/core/tools/orchestrator.d.ts

@@ -0,0 +1,76 @@
+/**
+ * [WHO]: ToolInfo, ToolOrchestrator class
+ * [FROM]: Depends on agent-core, extensions
+ * [TO]: Consumed by core/runtime/agent-session.ts
+ * [HERE]: core/tools/orchestrator.ts - runtime tool registry, lookup, and active-tool resolution
+ */
+import type { AgentTool } from "@catui/agent-core";
+import type { ToolDefinition, ToolInfo } from "../extensions-host/index.js";
+export interface ToolOrchestratorOptions {
+    /** Initial custom tools from SDK options */
+    customTools?: ToolDefinition[];
+    /** Initial active tool names */
+    initialActiveToolNames?: string[];
+    /** Tool registry from extensions */
+    getExtensionTools: () => Map<string, ToolDefinition>;
+}
+export declare class ToolOrchestrator {
+    private _toolRegistry;
+    private _activeToolNames;
+    private _customTools;
+    private _initialActiveToolNames?;
+    private _getExtensionTools;
+    constructor(options: ToolOrchestratorOptions);
+    /**
+     * Get all registered tool names
+     */
+    getToolNames(): string[];
+    /**
+     * Get the names of currently active tools
+     */
+    getActiveToolNames(): string[];
+    /**
+     * Replace the runtime registry after tools are rebuilt.
+     */
+    replaceTools(tools: Iterable<AgentTool>, activeToolNames?: string[]): void;
+    /**
+     * Get all configured tools with name, description, and parameter schema
+     */
+    getAllTools(): ToolInfo[];
+    /**
+     * Get tool by name
+     */
+    getTool(name: string): AgentTool | undefined;
+    /**
+     * Check if tool exists
+     */
+    hasTool(name: string): boolean;
+    /**
+     * Set active tools by name
+     * Returns the tools that were actually set and valid tool names
+     */
+    setActiveToolsByName(toolNames: string[]): {
+        tools: AgentTool[];
+        validToolNames: string[];
+    };
+    /**
+     * Register a tool
+     */
+    registerTool(name: string, tool: AgentTool): void;
+    /**
+     * Get custom tools
+     */
+    getCustomTools(): ToolDefinition[];
+    /**
+     * Replace custom tools after dynamic MCP refresh.
+     */
+    setCustomTools(customTools: ToolDefinition[]): void;
+    /**
+     * Get initial active tool names
+     */
+    getInitialActiveToolNames(): string[] | undefined;
+    /**
+     * Get extension tools map
+     */
+    getExtensionTools(): Map<string, ToolDefinition>;
+}

package/dist/core/tools/orchestrator.js

@@ -0,0 +1 @@
+var a=Object.defineProperty;var r=(i,o)=>a(i,"name",{value:o,configurable:!0});class T{static{r(this,"ToolOrchestrator")}_toolRegistry=new Map;_activeToolNames=[];_customTools=[];_initialActiveToolNames;_getExtensionTools;constructor(o){this._customTools=o.customTools||[],this._initialActiveToolNames=o.initialActiveToolNames,this._activeToolNames=o.initialActiveToolNames??[],this._getExtensionTools=o.getExtensionTools}getToolNames(){return Array.from(this._toolRegistry.keys())}getActiveToolNames(){return[...this._activeToolNames]}replaceTools(o,s){this._toolRegistry=new Map(Array.from(o,t=>[t.name,t]));const e=s??this._activeToolNames;this._activeToolNames=e.filter(t=>this._toolRegistry.has(t))}getAllTools(){return Array.from(this._toolRegistry.values()).map(o=>({name:o.name,description:o.description,parameters:o.parameters}))}getTool(o){return this._toolRegistry.get(o)}hasTool(o){return this._toolRegistry.has(o)}setActiveToolsByName(o){const s=[],e=[];for(const t of o){const l=this._toolRegistry.get(t);l&&(s.push(l),e.push(t))}return this._activeToolNames=e,{tools:s,validToolNames:e}}registerTool(o,s){this._toolRegistry.set(o,s)}getCustomTools(){return this._customTools}setCustomTools(o){this._customTools=o}getInitialActiveToolNames(){return this._initialActiveToolNames}getExtensionTools(){return this._getExtensionTools()}}export{T as ToolOrchestrator};

package/dist/core/tools/path-utils.d.ts

@@ -0,0 +1,7 @@
+export declare function expandPath(filePath: string): string;
+/**
+ * Resolve a path relative to the given cwd.
+ * Handles ~ expansion and absolute paths.
+ */
+export declare function resolveToCwd(filePath: string, cwd: string): string;
+export declare function resolveReadPath(filePath: string, cwd: string): string;

package/dist/core/tools/path-utils.js

@@ -0,0 +1 @@
+var l=Object.defineProperty;var e=(r,n)=>l(r,"name",{value:n,configurable:!0});import{accessSync as m,constants as d}from"node:fs";import*as s from"node:os";import{isAbsolute as p,resolve as A}from"node:path";const h=/[\u00A0\u2000-\u200A\u202F\u205F\u3000]/g,y="\u202F";function x(r){return r.replace(h," ")}e(x,"normalizeUnicodeSpaces");function P(r){return r.replace(/ (AM|PM)\./g,`${y}$1.`)}e(P,"tryMacOSScreenshotPath");function S(r){return r.normalize("NFD")}e(S,"tryNFDVariant");function f(r){return r.replace(/'/g,"\u2019")}e(f,"tryCurlyQuoteVariant");function o(r){try{return m(r,d.F_OK),!0}catch{return!1}}e(o,"fileExists");function C(r){return r.startsWith("@")?r.slice(1):r}e(C,"normalizeAtPrefix");function F(r){const n=x(C(r));return n==="~"?s.homedir():n.startsWith("~/")?s.homedir()+n.slice(1):n}e(F,"expandPath");function V(r,n){const t=F(r);return p(t)?t:A(n,t)}e(V,"resolveToCwd");function O(r,n){const t=V(r,n);if(o(t))return t;const i=P(t);if(i!==t&&o(i))return i;const u=S(t);if(u!==t&&o(u))return u;const a=f(t);if(a!==t&&o(a))return a;const c=f(u);return c!==t&&o(c)?c:t}e(O,"resolveReadPath");export{F as expandPath,O as resolveReadPath,V as resolveToCwd};

package/dist/core/tools/pdf-extract.d.ts

@@ -0,0 +1,11 @@
+/**
+ * [WHO]: extractPdfPages
+ * [FROM]: Depends on pdf-lib
+ * [TO]: Consumed by ./read.ts for PDF page extraction
+ * [HERE]: core/tools/pdf-extract.ts - extract specific pages from a PDF buffer
+ */
+/**
+ * Extract specific pages from a PDF buffer and return a new PDF as base64.
+ * Uses pdf-lib to copy selected pages into a new PDF document.
+ */
+export declare function extractPdfPages(pdfBuffer: Buffer, pageRange: string): Promise<string>;

package/dist/core/tools/pdf-extract.js

@@ -0,0 +1 @@
+var d=Object.defineProperty;var g=(r,a)=>d(r,"name",{value:a,configurable:!0});import{PDFDocument as u}from"pdf-lib";const l=20;function w(r,a){const i=r.split(",").map(t=>t.trim()),n=[];for(const t of i)if(t.includes("-")){const[e,c]=t.split("-").map(o=>o.trim()),s=parseInt(e,10),p=parseInt(c,10);if(isNaN(s)||isNaN(p)||s<1||p<s)throw new Error(`Invalid page range: ${t}`);for(let o=s;o<=Math.min(p,a);o++)n.push(o-1)}else{const e=parseInt(t,10);if(isNaN(e)||e<1)throw new Error(`Invalid page number: ${t}`);e<=a&&n.push(e-1)}if(n.length===0)throw new Error("No valid pages in range");return[...new Set(n)].sort((t,e)=>t-e).slice(0,l)}g(w,"parsePageRange");async function h(r,a){const i=await u.load(r),n=i.getPageCount(),f=w(a,n),t=await u.create(),e=await t.copyPages(i,f);for(const s of e)t.addPage(s);const c=await t.save();return Buffer.from(c).toString("base64")}g(h,"extractPdfPages");export{h as extractPdfPages};

package/dist/core/tools/read.d.ts

@@ -0,0 +1,46 @@
+/**
+ * [WHO]: ReadTool, readTool, createReadTool, ReadToolInput
+ * [FROM]: Depends on agent-core, ai, node:fs, modes/utils/image-resize
+ * [TO]: Consumed by core/tools/index.ts
+ * [HERE]: core/tools/read.ts - filesystem read boundary; consumed by orchestrator
+ */
+import type { AgentTool } from "@catui/agent-core";
+import { type Static } from "@sinclair/typebox";
+import { type TruncationResult } from "./truncate.js";
+declare const readSchema: import("@sinclair/typebox").TObject<{
+    path: import("@sinclair/typebox").TString;
+    offset: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TInteger>;
+    limit: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TInteger>;
+    pages: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+}>;
+export type ReadToolInput = Static<typeof readSchema>;
+export interface ReadToolDetails {
+    truncation?: TruncationResult;
+}
+/**
+ * Pluggable operations for the read tool.
+ * Override these to delegate file reading to remote systems (e.g., SSH).
+ */
+export interface ReadOperations {
+    /** Read file contents as a Buffer */
+    readFile: (absolutePath: string) => Promise<Buffer>;
+    /** Check if file is readable (throw if not) */
+    access: (absolutePath: string) => Promise<void>;
+    /** Detect image MIME type, return null/undefined for non-images */
+    detectImageMimeType?: (absolutePath: string) => Promise<string | null | undefined>;
+}
+export interface ReadToolOptions {
+    /** Whether to auto-resize images to 2000x2000 max. Default: true */
+    autoResizeImages?: boolean;
+    /** Custom operations for file reading. Default: local filesystem */
+    operations?: ReadOperations;
+}
+export declare function createReadTool(cwd: string, options?: ReadToolOptions): AgentTool<typeof readSchema>;
+/** Default read tool using process.cwd() - for backwards compatibility */
+export declare const readTool: AgentTool<import("@sinclair/typebox").TObject<{
+    path: import("@sinclair/typebox").TString;
+    offset: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TInteger>;
+    limit: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TInteger>;
+    pages: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+}>, any>;
+export {};

package/dist/core/tools/read.js

@@ -0,0 +1,11 @@
+var _=Object.defineProperty;var g=(c,$)=>_(c,"name",{value:$,configurable:!0});import{Type as r}from"@sinclair/typebox";import{constants as U}from"fs";import{access as z,readFile as A,stat as C}from"fs/promises";import{fileStateCache as B}from"./file-state-cache.js";import{formatDimensionNote as j,resizeImage as K}from"../../modes/utils/image-resize.js";import{detectSupportedImageMimeTypeFromFile as W}from"../../utils/mime.js";import{validateIntegerWindowOption as N}from"./input-validation.js";import{resolveReadPath as X}from"./path-utils.js";import{DEFAULT_MAX_BYTES as S,DEFAULT_MAX_LINES as k,formatSize as D,truncateHead as q}from"./truncate.js";const H=r.Object({path:r.String({description:"Path to the file to read (relative or absolute)"}),offset:r.Optional(r.Integer({minimum:1,description:"Line number to start reading from (1-indexed)"})),limit:r.Optional(r.Integer({minimum:1,description:"Maximum number of lines to read"})),pages:r.Optional(r.String({description:"Page range for PDF files, e.g. '1-5', '3', '10-20'. Max 20 pages per request."}))}),Y={readFile:g(c=>A(c),"readFile"),access:g(c=>z(c,U.R_OK),"access"),detectImageMimeType:W};function G(c,$){const O=$?.autoResizeImages??!0,p=$?.operations??Y;return{name:"read",label:"read",description:`Read the contents of a file. Supports text files, images (jpg, png, gif, webp), and PDFs. Images are sent as attachments. PDFs are sent as document content blocks (max 100 pages). For text files, output is truncated to ${k} lines or ${S/1024}KB (whichever is hit first). Use offset/limit for large files. Use pages param for PDF page ranges.`,parameters:H,isConcurrencySafe:!0,execute:g(async(J,{path:M,offset:x,limit:L,pages:T},f)=>{N({name:"offset",value:x,minimum:1}),N({name:"limit",value:L,minimum:1});const o=X(M,c);return new Promise((E,P)=>{if(f?.aborted){P(new Error("Operation aborted"));return}let w=!1;const I=g(()=>{w=!0,P(new Error("Operation aborted"))},"onAbort");f&&f.addEventListener("abort",I,{once:!0}),(async()=>{try{if(await p.access(o),w)return;const d=p.detectImageMimeType?await p.detectImageMimeType(o):void 0;let m,R;if(d){const l=(await p.readFile(o)).toString("base64");if(O){const t=await K({type:"image",data:l,mimeType:d}),e=j(t);let u=`Read image file [${t.mimeType}]`;e&&(u+=`
+${e}`),m=[{type:"text",text:u},{type:"image",data:t.data,mimeType:t.mimeType}]}else m=[{type:"text",text:`Read image file [${d}]`},{type:"image",data:l,mimeType:d}]}else if(o.toLowerCase().endsWith(".pdf")){const y=await p.readFile(o),l=y.toString("base64");if(T)try{const{extractPdfPages:t}=await import("./pdf-extract.js"),e=await t(y,T);m=[{type:"text",text:`Read PDF pages ${T} [application/pdf]`},{type:"document",source:{type:"base64",media_type:"application/pdf",data:e}}]}catch{m=[{type:"text",text:"Read PDF file [application/pdf] (page extraction unavailable, returning full document)"},{type:"document",source:{type:"base64",media_type:"application/pdf",data:l}}]}else m=[{type:"text",text:"Read PDF file [application/pdf]"},{type:"document",source:{type:"base64",media_type:"application/pdf",data:l}}]}else{const y=await C(o),t=(await p.readFile(o)).toString("utf-8"),e=t.split(`
+`),u=e.length,n=x?Math.max(0,x-1):0,b=n+1;if(n>=e.length)throw new Error(`Offset ${x} is beyond end of file (${e.length} lines total)`);let v,h;if(L!==void 0){const i=Math.min(n+L,e.length);v=e.slice(n,i).join(`
+`),h=i-n}else v=e.slice(n).join(`
+`);const a=q(v);let s;if(a.firstLineExceedsLimit){const i=D(Buffer.byteLength(e[n],"utf-8"));s=`[Line ${b} is ${i}, exceeds ${D(S)} limit. Use bash: sed -n '${b}p' ${M} | head -c ${S}]`,R={truncation:a}}else if(a.truncated){const i=b+a.outputLines-1,F=i+1;s=a.content,a.truncatedBy==="lines"?s+=`
+
+[Showing lines ${b}-${i} of ${u}. Use offset=${F} to continue.]`:s+=`
+
+[Showing lines ${b}-${i} of ${u} (${D(S)} limit). Use offset=${F} to continue.]`,R={truncation:a}}else if(h!==void 0&&n+h<e.length){const i=e.length-(n+h),F=n+h+1;s=a.content,s+=`
+
+[${i} more lines in file. Use offset=${F} to continue.]`}else s=a.content;m=[{type:"text",text:s}],B.set(o,{content:t,timestamp:Math.floor(y.mtimeMs),offset:x,limit:L})}if(w)return;f&&f.removeEventListener("abort",I),E({content:m,details:R})}catch(d){f&&f.removeEventListener("abort",I),w||P(d)}})()})},"execute")}}g(G,"createReadTool");const re=G(process.cwd());export{G as createReadTool,re as readTool};

package/dist/core/tools/source.d.ts

@@ -0,0 +1,78 @@
+/**
+ * [WHO]: ToolSourceType, ToolSource, SourceTool
+ * [FROM]: Depends on extensions/types
+ * [TO]: Consumed by core/tools/index.ts (not directly imported)
+ * [HERE]: core/tools/source.ts - tool source abstraction (builtin, MCP, extension)
+ */
+import type { ToolDefinition } from "../extensions-host/types.js";
+export type ToolSourceType = "builtin" | "mcp" | "extension";
+/**
+ * Tool source interface
+ * Implement this to add new tool sources (MCP, custom protocols, etc.)
+ */
+export interface ToolSource {
+    /** Unique identifier for this tool source */
+    id: string;
+    /** Type of tool source */
+    type: ToolSourceType;
+    /** Human-readable name */
+    name: string;
+    /** Description of what this source provides */
+    description?: string;
+    /** Load tools from this source */
+    load(): Promise<ToolDefinition[]>;
+    /** Unload tools from this source */
+    unload(): Promise<void>;
+    /** Check if this source is enabled */
+    isEnabled(): boolean;
+}
+/**
+ * Tool source registry
+ * Manages multiple tool sources
+ */
+export declare class ToolSourceRegistry {
+    private sources;
+    /**
+     * Register a tool source
+     */
+    register(source: ToolSource): void;
+    /**
+     * Unregister a tool source
+     */
+    unregister(id: string): void;
+    /**
+     * Get a tool source by ID
+     */
+    get(id: string): ToolSource | undefined;
+    /**
+     * Get all registered tool sources
+     */
+    getAll(): ToolSource[];
+    /**
+     * Get tool sources by type
+     */
+    getByType(type: ToolSourceType): ToolSource[];
+    /**
+     * Load all enabled tool sources
+     */
+    loadAll(): Promise<ToolDefinition[]>;
+    /**
+     * Unload all tool sources
+     */
+    unloadAll(): Promise<void>;
+}
+/**
+ * Builtin tool source
+ * Wraps built-in tools as a ToolSource
+ */
+export declare class BuiltinToolSource implements ToolSource {
+    readonly id = "builtin";
+    readonly type: ToolSourceType;
+    readonly name = "Built-in Tools";
+    readonly description = "Core editing and file operation tools";
+    private tools;
+    constructor(tools?: ToolDefinition[]);
+    isEnabled(): boolean;
+    load(): Promise<ToolDefinition[]>;
+    unload(): Promise<void>;
+}

package/dist/core/tools/source.js

@@ -0,0 +1 @@
+var l=Object.defineProperty;var e=(s,t)=>l(s,"name",{value:t,configurable:!0});class n{static{e(this,"ToolSourceRegistry")}sources=new Map;register(t){this.sources.has(t.id)||this.sources.set(t.id,t)}unregister(t){this.sources.delete(t)}get(t){return this.sources.get(t)}getAll(){return Array.from(this.sources.values())}getByType(t){return this.getAll().filter(o=>o.type===t)}async loadAll(){const t=[];for(const o of this.getAll())if(o.isEnabled())try{const r=await o.load();t.push(...r)}catch{}return t}async unloadAll(){for(const t of this.getAll())try{await t.unload()}catch{}}}class a{static{e(this,"BuiltinToolSource")}id="builtin";type="builtin";name="Built-in Tools";description="Core editing and file operation tools";tools=[];constructor(t=[]){this.tools=t}isEnabled(){return!0}async load(){return this.tools}async unload(){}}export{a as BuiltinToolSource,n as ToolSourceRegistry};

package/dist/core/tools/time.d.ts

@@ -0,0 +1,19 @@
+/**
+ * [WHO]: TimeTool, timeTool, createTimeTool
+ * [FROM]: Depends on agent-core, typebox
+ * [TO]: Consumed by core/tools/index.ts
+ * [HERE]: core/tools/time.ts - current time tool
+ */
+import type { AgentTool } from "@catui/agent-core";
+import { type Static } from "@sinclair/typebox";
+declare const timeSchema: import("@sinclair/typebox").TObject<{
+    timeZone: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+    locale: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+}>;
+export type TimeToolInput = Static<typeof timeSchema>;
+export declare function createTimeTool(): AgentTool<typeof timeSchema>;
+export declare const timeTool: AgentTool<import("@sinclair/typebox").TObject<{
+    timeZone: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+    locale: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+}>, any>;
+export {};

package/dist/core/tools/time.js

@@ -0,0 +1,2 @@
+var c=Object.defineProperty;var n=(i,e)=>c(i,"name",{value:e,configurable:!0});import{Type as o}from"@sinclair/typebox";const l=o.Object({timeZone:o.Optional(o.String({description:"Optional IANA time zone like Asia/Shanghai or America/Los_Angeles"})),locale:o.Optional(o.String({description:"Optional locale like en-US or zh-CN for formatting"}))});function d(i,e="en-US"){const t=new Date,s=Intl.DateTimeFormat().resolvedOptions().timeZone||"UTC",r=i||s,a=t.toISOString(),m=t.toLocaleString(e,{weekday:"long",year:"numeric",month:"long",day:"numeric",hour:"2-digit",minute:"2-digit",second:"2-digit",timeZone:r,timeZoneName:"short"});return[`Current system time: ${a}`,`Formatted time: ${m}`,`Time zone: ${r}`,`Epoch ms: ${t.getTime()}`].join(`
+`)}n(d,"formatTimeSnapshot");function u(){return{name:"time",label:"time",description:"Get the current system time. You must use this for time-sensitive questions such as 'what time is it', 'what day is it', 'today', 'tomorrow', 'yesterday', deadlines, schedules, elapsed time, or any request that depends on the real current date/time instead of prompt context.",parameters:l,isConcurrencySafe:!0,execute:n(async(i,{timeZone:e,locale:t})=>({content:[{type:"text",text:d(e,t)}],details:{timeZone:e||Intl.DateTimeFormat().resolvedOptions().timeZone||"UTC",locale:t||"en-US"}}),"execute")}}n(u,"createTimeTool");const y=u();export{u as createTimeTool,y as timeTool};