@travisennis/acai 0.0.10 → 0.0.12

package/dist/tools/index.d.ts

@@ -1,6 +1,7 @@
 import type { AsyncReturnType } from "@travisennis/stdlib/types";
 import type { Tool } from "ai";
 import type { WorkspaceContext } from "../index.ts";
+import { ActivatedSkillsTracker } from "../skills/activated-tracker.ts";
 export type CompleteToolSet = {
     -readonly [K in keyof AsyncReturnType<typeof initTools>]: AsyncReturnType<typeof initTools>[K];
 };
@@ -8,15 +9,34 @@ export type CompleteTools = {
     -readonly [K in keyof AsyncReturnType<typeof initTools>]: Tool<unknown, string>;
 };
 export type CompleteToolNames = keyof CompleteToolSet;
+/**
+ * Returns the activated skills tracker instance.
+ * Used to reset the tracker when a new session starts.
+ */
+export declare function getActivatedSkillsTracker(): ActivatedSkillsTracker;
 export declare function initTools({ workspace, }: {
     workspace: WorkspaceContext;
 }): Promise<{
+    readonly ApplyPatch: {
+        toolDef: {
+            description: string;
+            inputSchema: import("zod").ZodObject<{
+                patchText: import("zod").ZodString;
+            }, import("zod/v4/core").$strip>;
+        };
+        display({ patchText }: {
+            patchText: string;
+        }): string;
+        execute({ patchText }: {
+            patchText: string;
+        }, { abortSignal }: import("./types.ts").ToolExecutionOptions): Promise<string>;
+    };
     readonly Edit: {
         toolDef: {
             description: string;
             inputSchema: import("zod").ZodObject<{
                 path: import("zod").ZodString;
-                edits: import("zod").ZodPipe<import("zod").ZodTransform<unknown, unknown>, import("zod").ZodArray<import("zod").ZodObject<{
+                edits: import("zod").ZodPreprocess<import("zod").ZodArray<import("zod").ZodObject<{
                     oldText: import("zod").ZodString;
                     newText: import("zod").ZodString;
                 }, import("zod/v4/core").$strip>>>;
@@ -42,8 +62,8 @@ export declare function initTools({ workspace, }: {
             description: string;
             inputSchema: import("zod").ZodObject<{
                 command: import("zod").ZodString;
-                cwd: import("zod").ZodPipe<import("zod").ZodTransform<unknown, unknown>, import("zod").ZodNullable<import("zod").ZodString>>;
-                timeout: import("zod").ZodPipe<import("zod").ZodTransform<unknown, unknown>, import("zod").ZodNullable<import("zod").ZodCoercedNumber<unknown>>>;
+                cwd: import("zod").ZodPreprocess<import("zod").ZodNullable<import("zod").ZodString>>;
+                timeout: import("zod").ZodPreprocess<import("zod").ZodNullable<import("zod").ZodCoercedNumber<unknown>>>;
                 background: import("zod").ZodOptional<import("zod").ZodBoolean>;
             }, import("zod/v4/core").$strip>;
         };
@@ -67,14 +87,14 @@ export declare function initTools({ workspace, }: {
                 path: import("zod").ZodString;
                 content: import("zod").ZodString;
                 encoding: import("zod").ZodDefault<import("zod").ZodEnum<{
+                    base64: "base64";
+                    base64url: "base64url";
                     utf8: "utf8";
                     ascii: "ascii";
                     "utf-8": "utf-8";
                     utf16le: "utf16le";
                     ucs2: "ucs2";
                     "ucs-2": "ucs-2";
-                    base64: "base64";
-                    base64url: "base64url";
                     latin1: "latin1";
                     binary: "binary";
                     hex: "hex";
@@ -84,12 +104,12 @@ export declare function initTools({ workspace, }: {
         display({ path }: {
             path: string;
             content: string;
-            encoding: "utf8" | "ascii" | "utf-8" | "utf16le" | "ucs2" | "ucs-2" | "base64" | "base64url" | "latin1" | "binary" | "hex";
+            encoding: "base64" | "base64url" | "utf8" | "ascii" | "utf-8" | "utf16le" | "ucs2" | "ucs-2" | "latin1" | "binary" | "hex";
         }): string;
         execute({ path: userPath, content, encoding }: {
             path: string;
             content: string;
-            encoding: "utf8" | "ascii" | "utf-8" | "utf16le" | "ucs2" | "ucs-2" | "base64" | "base64url" | "latin1" | "binary" | "hex";
+            encoding: "base64" | "base64url" | "utf8" | "ascii" | "utf-8" | "utf16le" | "ucs2" | "ucs-2" | "latin1" | "binary" | "hex";
         }, { abortSignal }: import("./types.ts").ToolExecutionOptions): Promise<string>;
     };
     readonly Read: {
@@ -98,50 +118,47 @@ export declare function initTools({ workspace, }: {
             inputSchema: import("zod").ZodObject<{
                 path: import("zod").ZodString;
                 encoding: import("zod").ZodDefault<import("zod").ZodNullable<import("zod").ZodEnum<{
+                    base64: "base64";
+                    base64url: "base64url";
                     utf8: "utf8";
                     ascii: "ascii";
                     "utf-8": "utf-8";
                     utf16le: "utf16le";
                     ucs2: "ucs2";
                     "ucs-2": "ucs-2";
-                    base64: "base64";
-                    base64url: "base64url";
                     latin1: "latin1";
                     binary: "binary";
                     hex: "hex";
                 }>>>;
-                startLine: import("zod").ZodPipe<import("zod").ZodTransform<unknown, unknown>, import("zod").ZodNullable<import("zod").ZodCoercedNumber<unknown>>>;
-                lineCount: import("zod").ZodPipe<import("zod").ZodTransform<unknown, unknown>, import("zod").ZodNullable<import("zod").ZodCoercedNumber<unknown>>>;
-                maxBytes: import("zod").ZodPipe<import("zod").ZodTransform<unknown, unknown>, import("zod").ZodNullable<import("zod").ZodCoercedNumber<unknown>>>;
+                startLine: import("zod").ZodPreprocess<import("zod").ZodNullable<import("zod").ZodCoercedNumber<unknown>>>;
+                lineCount: import("zod").ZodPreprocess<import("zod").ZodNullable<import("zod").ZodCoercedNumber<unknown>>>;
             }, import("zod/v4/core").$strip>;
         };
         display({ path: providedPath, startLine, lineCount }: {
             path: string;
-            encoding: "utf8" | "ascii" | "utf-8" | "utf16le" | "ucs2" | "ucs-2" | "base64" | "base64url" | "latin1" | "binary" | "hex" | null;
+            encoding: "base64" | "base64url" | "utf8" | "ascii" | "utf-8" | "utf16le" | "ucs2" | "ucs-2" | "latin1" | "binary" | "hex" | null;
             startLine: number | null;
             lineCount: number | null;
-            maxBytes: number | null;
         }): string;
-        execute({ path: providedPath, encoding, startLine, lineCount, maxBytes, }: {
+        execute({ path: providedPath, encoding, startLine, lineCount, }: {
             path: string;
-            encoding: "utf8" | "ascii" | "utf-8" | "utf16le" | "ucs2" | "ucs-2" | "base64" | "base64url" | "latin1" | "binary" | "hex" | null;
+            encoding: "base64" | "base64url" | "utf8" | "ascii" | "utf-8" | "utf16le" | "ucs2" | "ucs-2" | "latin1" | "binary" | "hex" | null;
             startLine: number | null;
             lineCount: number | null;
-            maxBytes: number | null;
         }, { abortSignal }: import("./types.ts").ToolExecutionOptions): Promise<string>;
     };
     readonly Glob: {
         toolDef: {
             description: string;
             inputSchema: import("zod").ZodObject<{
-                patterns: import("zod").ZodPipe<import("zod").ZodTransform<{}, unknown>, import("zod").ZodUnion<readonly [import("zod").ZodString, import("zod").ZodArray<import("zod").ZodString>]>>;
-                path: import("zod").ZodPipe<import("zod").ZodTransform<{}, unknown>, import("zod").ZodString>;
-                gitignore: import("zod").ZodPipe<import("zod").ZodTransform<unknown, unknown>, import("zod").ZodNullable<import("zod").ZodCoercedBoolean<unknown>>>;
-                recursive: import("zod").ZodPipe<import("zod").ZodTransform<unknown, unknown>, import("zod").ZodNullable<import("zod").ZodCoercedBoolean<unknown>>>;
-                expandDirectories: import("zod").ZodPipe<import("zod").ZodTransform<unknown, unknown>, import("zod").ZodNullable<import("zod").ZodCoercedBoolean<unknown>>>;
-                ignoreFiles: import("zod").ZodPipe<import("zod").ZodTransform<{} | null | undefined, unknown>, import("zod").ZodNullable<import("zod").ZodUnion<readonly [import("zod").ZodString, import("zod").ZodArray<import("zod").ZodString>]>>>;
-                cwd: import("zod").ZodPipe<import("zod").ZodTransform<unknown, unknown>, import("zod").ZodNullable<import("zod").ZodCoercedString<unknown>>>;
-                maxResults: import("zod").ZodPipe<import("zod").ZodTransform<unknown, unknown>, import("zod").ZodNullable<import("zod").ZodCoercedNumber<unknown>>>;
+                patterns: import("zod").ZodDefault<import("zod").ZodPreprocess<import("zod").ZodUnion<readonly [import("zod").ZodString, import("zod").ZodArray<import("zod").ZodString>]>>>;
+                path: import("zod").ZodDefault<import("zod").ZodPreprocess<import("zod").ZodString>>;
+                gitignore: import("zod").ZodDefault<import("zod").ZodPreprocess<import("zod").ZodNullable<import("zod").ZodCoercedBoolean<unknown>>>>;
+                recursive: import("zod").ZodDefault<import("zod").ZodPreprocess<import("zod").ZodNullable<import("zod").ZodCoercedBoolean<unknown>>>>;
+                expandDirectories: import("zod").ZodDefault<import("zod").ZodPreprocess<import("zod").ZodNullable<import("zod").ZodCoercedBoolean<unknown>>>>;
+                ignoreFiles: import("zod").ZodDefault<import("zod").ZodPreprocess<import("zod").ZodNullable<import("zod").ZodUnion<readonly [import("zod").ZodString, import("zod").ZodArray<import("zod").ZodString>]>>>>;
+                cwd: import("zod").ZodDefault<import("zod").ZodPreprocess<import("zod").ZodNullable<import("zod").ZodCoercedString<unknown>>>>;
+                maxResults: import("zod").ZodDefault<import("zod").ZodPreprocess<import("zod").ZodNullable<import("zod").ZodCoercedNumber<unknown>>>>;
             }, import("zod/v4/core").$strip>;
         };
         display({ patterns, path }: {
@@ -171,13 +188,13 @@ export declare function initTools({ workspace, }: {
             inputSchema: import("zod").ZodObject<{
                 pattern: import("zod").ZodString;
                 path: import("zod").ZodString;
-                recursive: import("zod").ZodPipe<import("zod").ZodTransform<unknown, unknown>, import("zod").ZodNullable<import("zod").ZodCoercedBoolean<unknown>>>;
-                ignoreCase: import("zod").ZodPipe<import("zod").ZodTransform<unknown, unknown>, import("zod").ZodNullable<import("zod").ZodCoercedBoolean<unknown>>>;
-                filePattern: import("zod").ZodPipe<import("zod").ZodTransform<unknown, unknown>, import("zod").ZodNullable<import("zod").ZodCoercedString<unknown>>>;
-                contextLines: import("zod").ZodPipe<import("zod").ZodTransform<unknown, unknown>, import("zod").ZodNullable<import("zod").ZodCoercedNumber<unknown>>>;
-                searchIgnored: import("zod").ZodPipe<import("zod").ZodTransform<unknown, unknown>, import("zod").ZodNullable<import("zod").ZodCoercedBoolean<unknown>>>;
-                literal: import("zod").ZodPipe<import("zod").ZodTransform<unknown, unknown>, import("zod").ZodNullable<import("zod").ZodCoercedBoolean<unknown>>>;
-                maxResults: import("zod").ZodPipe<import("zod").ZodTransform<unknown, unknown>, import("zod").ZodNullable<import("zod").ZodCoercedNumber<unknown>>>;
+                recursive: import("zod").ZodDefault<import("zod").ZodPreprocess<import("zod").ZodNullable<import("zod").ZodCoercedBoolean<unknown>>>>;
+                ignoreCase: import("zod").ZodDefault<import("zod").ZodPreprocess<import("zod").ZodNullable<import("zod").ZodCoercedBoolean<unknown>>>>;
+                filePattern: import("zod").ZodDefault<import("zod").ZodPreprocess<import("zod").ZodNullable<import("zod").ZodCoercedString<unknown>>>>;
+                contextLines: import("zod").ZodDefault<import("zod").ZodPreprocess<import("zod").ZodNullable<import("zod").ZodCoercedNumber<unknown>>>>;
+                searchIgnored: import("zod").ZodDefault<import("zod").ZodPreprocess<import("zod").ZodNullable<import("zod").ZodCoercedBoolean<unknown>>>>;
+                literal: import("zod").ZodDefault<import("zod").ZodPreprocess<import("zod").ZodNullable<import("zod").ZodCoercedBoolean<unknown>>>>;
+                maxResults: import("zod").ZodDefault<import("zod").ZodPreprocess<import("zod").ZodNullable<import("zod").ZodCoercedNumber<unknown>>>>;
             }, import("zod/v4/core").$strip>;
         };
         display({ pattern, path, filePattern, recursive, ignoreCase, contextLines, }: {
@@ -203,57 +220,13 @@ export declare function initTools({ workspace, }: {
             maxResults: number | null;
         }, { abortSignal }: import("./types.ts").ToolExecutionOptions): Promise<string>;
     };
-    readonly CodeSearch: {
-        toolDef: {
-            description: string;
-            inputSchema: import("zod").ZodObject<{
-                query: import("zod").ZodString;
-                path: import("zod").ZodDefault<import("zod").ZodString>;
-                regexPattern: import("zod").ZodPipe<import("zod").ZodTransform<unknown, unknown>, import("zod").ZodNullable<import("zod").ZodString>>;
-                filePattern: import("zod").ZodPipe<import("zod").ZodTransform<unknown, unknown>, import("zod").ZodNullable<import("zod").ZodString>>;
-                excludePattern: import("zod").ZodPipe<import("zod").ZodTransform<unknown, unknown>, import("zod").ZodNullable<import("zod").ZodString>>;
-                excludeDir: import("zod").ZodPipe<import("zod").ZodTransform<unknown, unknown>, import("zod").ZodNullable<import("zod").ZodString>>;
-                maxResults: import("zod").ZodPipe<import("zod").ZodTransform<unknown, unknown>, import("zod").ZodNullable<import("zod").ZodCoercedNumber<unknown>>>;
-                contextLines: import("zod").ZodPipe<import("zod").ZodTransform<unknown, unknown>, import("zod").ZodNullable<import("zod").ZodCoercedNumber<unknown>>>;
-                filesOnly: import("zod").ZodPipe<import("zod").ZodTransform<unknown, unknown>, import("zod").ZodNullable<import("zod").ZodCoercedBoolean<unknown>>>;
-                showContent: import("zod").ZodPipe<import("zod").ZodTransform<unknown, unknown>, import("zod").ZodNullable<import("zod").ZodCoercedBoolean<unknown>>>;
-                codeOnly: import("zod").ZodPipe<import("zod").ZodTransform<unknown, unknown>, import("zod").ZodNullable<import("zod").ZodCoercedBoolean<unknown>>>;
-            }, import("zod/v4/core").$strip>;
-        };
-        display({ query, path, regexPattern, filePattern, excludePattern, excludeDir, maxResults, contextLines, filesOnly, showContent, codeOnly, }: {
-            query: string;
-            path: string;
-            regexPattern: string | null;
-            filePattern: string | null;
-            excludePattern: string | null;
-            excludeDir: string | null;
-            maxResults: number | null;
-            contextLines: number | null;
-            filesOnly: boolean | null;
-            showContent: boolean | null;
-            codeOnly: boolean | null;
-        }): string;
-        execute({ query, path, regexPattern, filePattern, excludePattern, excludeDir, maxResults, contextLines, filesOnly, showContent, codeOnly, }: {
-            query: string;
-            path: string;
-            regexPattern: string | null;
-            filePattern: string | null;
-            excludePattern: string | null;
-            excludeDir: string | null;
-            maxResults: number | null;
-            contextLines: number | null;
-            filesOnly: boolean | null;
-            showContent: boolean | null;
-            codeOnly: boolean | null;
-        }, { abortSignal }: import("./types.ts").ToolExecutionOptions): Promise<string>;
-    };
     readonly DirectoryTree: {
         toolDef: {
             description: string;
             inputSchema: import("zod").ZodObject<{
                 path: import("zod").ZodString;
-                maxResults: import("zod").ZodPipe<import("zod").ZodTransform<unknown, unknown>, import("zod").ZodNullable<import("zod").ZodCoercedNumber<unknown>>>;
-                maxDepth: import("zod").ZodPipe<import("zod").ZodTransform<unknown, unknown>, import("zod").ZodNullable<import("zod").ZodCoercedNumber<unknown>>>;
+                maxResults: import("zod").ZodDefault<import("zod").ZodPreprocess<import("zod").ZodNullable<import("zod").ZodCoercedNumber<unknown>>>>;
+                maxDepth: import("zod").ZodDefault<import("zod").ZodPreprocess<import("zod").ZodNullable<import("zod").ZodCoercedNumber<unknown>>>>;
             }, import("zod/v4/core").$strip>;
         };
         display({ path, maxDepth, maxResults }: {
@@ -284,7 +257,7 @@ export declare function initTools({ workspace, }: {
             description: string;
             inputSchema: import("zod").ZodObject<{
                 path: import("zod").ZodOptional<import("zod").ZodString>;
-                limit: import("zod").ZodPipe<import("zod").ZodTransform<unknown, unknown>, import("zod").ZodNullable<import("zod").ZodCoercedNumber<unknown>>>;
+                limit: import("zod").ZodDefault<import("zod").ZodPreprocess<import("zod").ZodNullable<import("zod").ZodCoercedNumber<unknown>>>>;
             }, import("zod/v4/core").$strip>;
         };
         display({ path: providedPath, limit }: {
@@ -338,8 +311,8 @@ export declare function initTools({ workspace, }: {
             description: string;
             inputSchema: import("zod").ZodObject<{
                 query: import("zod").ZodString;
-                numResults: import("zod").ZodOptional<import("zod").ZodPipe<import("zod").ZodTransform<string | null, unknown>, import("zod").ZodNullable<import("zod").ZodCoercedNumber<unknown>>>>;
-                timeout: import("zod").ZodOptional<import("zod").ZodPipe<import("zod").ZodTransform<string | null, unknown>, import("zod").ZodNullable<import("zod").ZodCoercedNumber<unknown>>>>;
+                numResults: import("zod").ZodOptional<import("zod").ZodPreprocess<import("zod").ZodNullable<import("zod").ZodCoercedNumber<unknown>>>>;
+                timeout: import("zod").ZodOptional<import("zod").ZodPreprocess<import("zod").ZodNullable<import("zod").ZodCoercedNumber<unknown>>>>;
                 provider: import("zod").ZodOptional<import("zod").ZodEnum<{
                     exa: "exa";
                     duckduckgo: "duckduckgo";
@@ -370,9 +343,9 @@ export declare function initTools({ workspace, }: {
                     html: "html";
                     json: "json";
                 }>>;
-                jina: import("zod").ZodOptional<import("zod").ZodPipe<import("zod").ZodTransform<string | null, unknown>, import("zod").ZodNullable<import("zod").ZodCoercedBoolean<unknown>>>>;
-                timeout: import("zod").ZodOptional<import("zod").ZodPipe<import("zod").ZodTransform<string | null, unknown>, import("zod").ZodNullable<import("zod").ZodCoercedNumber<unknown>>>>;
-                headers: import("zod").ZodOptional<import("zod").ZodPipe<import("zod").ZodTransform<string | null, unknown>, import("zod").ZodNullable<import("zod").ZodCoercedBoolean<unknown>>>>;
+                jina: import("zod").ZodOptional<import("zod").ZodPreprocess<import("zod").ZodNullable<import("zod").ZodCoercedBoolean<unknown>>>>;
+                timeout: import("zod").ZodOptional<import("zod").ZodPreprocess<import("zod").ZodNullable<import("zod").ZodCoercedNumber<unknown>>>>;
+                headers: import("zod").ZodOptional<import("zod").ZodPreprocess<import("zod").ZodNullable<import("zod").ZodCoercedBoolean<unknown>>>>;
             }, import("zod/v4/core").$strip>;
         };
         display({ url }: {

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../source/tools/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,2BAA2B,CAAC;AACjE,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,IAAI,CAAC;AAE/B,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,aAAa,CAAC;AAoBpD,MAAM,MAAM,eAAe,GAAG;IAC5B,CAAC,UAAU,CAAC,IAAI,MAAM,eAAe,CAAC,OAAO,SAAS,CAAC,GAAG,eAAe,CACvE,OAAO,SAAS,CACjB,CAAC,CAAC,CAAC;CACL,CAAC;AAEF,MAAM,MAAM,aAAa,GAAG;IAC1B,CAAC,UAAU,CAAC,IAAI,MAAM,eAAe,CAAC,OAAO,SAAS,CAAC,GAAG,IAAI,CAC5D,OAAO,EACP,MAAM,CACP;CACF,CAAC;AAEF,MAAM,MAAM,iBAAiB,GAAG,MAAM,eAAe,CAAC;AAEtD,wBAAsB,SAAS,CAAC,EAC9B,SAAS,GACV,EAAE;IACD,SAAS,EAAE,gBAAgB,CAAC;CAC7B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA0EA"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../source/tools/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,2BAA2B,CAAC;AACjE,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,IAAI,CAAC;AAE/B,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,aAAa,CAAC;AACpD,OAAO,EAAE,sBAAsB,EAAE,MAAM,gCAAgC,CAAC;AAoBxE,MAAM,MAAM,eAAe,GAAG;IAC5B,CAAC,UAAU,CAAC,IAAI,MAAM,eAAe,CAAC,OAAO,SAAS,CAAC,GAAG,eAAe,CACvE,OAAO,SAAS,CACjB,CAAC,CAAC,CAAC;CACL,CAAC;AAEF,MAAM,MAAM,aAAa,GAAG;IAC1B,CAAC,UAAU,CAAC,IAAI,MAAM,eAAe,CAAC,OAAO,SAAS,CAAC,GAAG,IAAI,CAC5D,OAAO,EACP,MAAM,CACP;CACF,CAAC;AAEF,MAAM,MAAM,iBAAiB,GAAG,MAAM,eAAe,CAAC;AAKtD;;;GAGG;AACH,wBAAgB,yBAAyB,IAAI,sBAAsB,CAElE;AAED,wBAAsB,SAAS,CAAC,EAC9B,SAAS,GACV,EAAE;IACD,SAAS,EAAE,gBAAgB,CAAC;CAC7B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+EA"}

package/dist/tools/index.js

@@ -1,7 +1,8 @@
 import { config } from "../config/index.js";
+import { ActivatedSkillsTracker } from "../skills/activated-tracker.js";
 import { AgentTool, createAgentTools } from "./agent.js";
+import { ApplyPatchTool, createApplyPatchTool } from "./apply-patch.js";
 import { BashTool, createBashTool } from "./bash.js";
-import { CodeSearchTool, createCodeSearchTool } from "./code-search.js";
 import { createDirectoryTreeTool, DirectoryTreeTool, } from "./directory-tree.js";
 import { loadDynamicTools } from "./dynamic-tool-loader.js";
 import { createEditFileTool, EditFileTool } from "./edit-file.js";
@@ -14,6 +15,15 @@ import { createSkillTool, SkillTool } from "./skill.js";
 import { createThinkTool, ThinkTool } from "./think.js";
 import { createWebFetchTool, WebFetchTool } from "./web-fetch.js";
 import { createWebSearchTool, WebSearchTool } from "./web-search.js";
+// Singleton tracker for activated skills, reset when a new session starts
+const activatedSkillsTracker = new ActivatedSkillsTracker();
+/**
+ * Returns the activated skills tracker instance.
+ * Used to reset the tracker when a new session starts.
+ */
+export function getActivatedSkillsTracker() {
+    return activatedSkillsTracker;
+}
 export async function initTools({ workspace, }) {
     const readFileTool = await createReadFileTool({ workspace });
     const editFileTool = await createEditFileTool({ workspace });
@@ -21,25 +31,25 @@ export async function initTools({ workspace, }) {
     const directoryTreeTool = await createDirectoryTreeTool({ workspace });
     const globTool = createGlobTool();
     const grepTool = createGrepTool();
-    const codeSearchTool = createCodeSearchTool();
     const thinkTool = createThinkTool();
     const lsTool = await createLsTool({ workspace });
     const projectConfig = await config.getConfig();
     const bashTool = await createBashTool({ workspace, env: projectConfig.env });
-    const skillTool = await createSkillTool();
+    const skillTool = await createSkillTool(activatedSkillsTracker);
     const agentTool = await createAgentTools({ workspace });
     const webSearchTool = await createWebSearchTool();
     const webFetchTool = await createWebFetchTool();
+    const applyPatchTool = await createApplyPatchTool({ workspace });
     const dynamicTools = await loadDynamicTools({
         baseDir: workspace.primaryDir,
         existingToolNames: [
+            ApplyPatchTool.name,
             EditFileTool.name,
             BashTool.name,
             SaveFileTool.name,
             ReadFileTool.name,
             GlobTool.name,
             GrepTool.name,
-            CodeSearchTool.name,
             DirectoryTreeTool.name,
             ThinkTool.name,
             LsTool.name,
@@ -48,16 +58,21 @@ export async function initTools({ workspace, }) {
             WebSearchTool.name,
             WebFetchTool.name,
         ],
+        sessionContext: {
+            sessionId: "",
+            projectDir: workspace.primaryDir,
+            agentName: "repl",
+        },
     });
     // Build tools object for AI SDK
     const tools = {
+        [ApplyPatchTool.name]: applyPatchTool,
         [EditFileTool.name]: editFileTool,
         [BashTool.name]: bashTool,
         [SaveFileTool.name]: saveFileTool,
         [ReadFileTool.name]: readFileTool,
         [GlobTool.name]: globTool,
         [GrepTool.name]: grepTool,
-        [CodeSearchTool.name]: codeSearchTool,
         [DirectoryTreeTool.name]: directoryTreeTool,
         [ThinkTool.name]: thinkTool,
         [LsTool.name]: lsTool,

package/dist/tools/ls.d.ts

@@ -6,7 +6,7 @@ export declare const LsTool: {
 };
 declare const inputSchema: z.ZodObject<{
     path: z.ZodOptional<z.ZodString>;
-    limit: z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodNullable<z.ZodCoercedNumber<unknown>>>;
+    limit: z.ZodDefault<z.ZodPreprocess<z.ZodNullable<z.ZodCoercedNumber<unknown>>>>;
 }, z.core.$strip>;
 type LsInputSchema = z.infer<typeof inputSchema>;
 export declare const createLsTool: (options: {
@@ -16,7 +16,7 @@ export declare const createLsTool: (options: {
         description: string;
         inputSchema: z.ZodObject<{
             path: z.ZodOptional<z.ZodString>;
-            limit: z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodNullable<z.ZodCoercedNumber<unknown>>>;
+            limit: z.ZodDefault<z.ZodPreprocess<z.ZodNullable<z.ZodCoercedNumber<unknown>>>>;
         }, z.core.$strip>;
     };
     display({ path: providedPath, limit }: LsInputSchema): string;

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

@@ -1 +1 @@
-{"version":3,"file":"ls.d.ts","sourceRoot":"","sources":["../../source/tools/ls.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AACxB,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,aAAa,CAAC;AAMpD,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,YAAY,CAAC;AAEvD,eAAO,MAAM,MAAM;;CAElB,CAAC;AAEF,QAAA,MAAM,WAAW;;;iBAQf,CAAC;AAEH,KAAK,aAAa,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,WAAW,CAAC,CAAC;AAIjD,eAAO,MAAM,YAAY,GAAU,SAAS;IAC1C,SAAS,EAAE,gBAAgB,CAAC;CAC7B;;;;;;;;2CAS0C,aAAa;2CAOnB,aAAa,mBAC3B,oBAAoB,GACpC,OAAO,CAAC,MAAM,CAAC;EA6DrB,CAAC"}
+{"version":3,"file":"ls.d.ts","sourceRoot":"","sources":["../../source/tools/ls.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AACxB,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,aAAa,CAAC;AAMpD,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,YAAY,CAAC;AAEvD,eAAO,MAAM,MAAM;;CAElB,CAAC;AAEF,QAAA,MAAM,WAAW;;;iBASf,CAAC;AAEH,KAAK,aAAa,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,WAAW,CAAC,CAAC;AAIjD,eAAO,MAAM,YAAY,GAAU,SAAS;IAC1C,SAAS,EAAE,gBAAgB,CAAC;CAC7B;;;;;;;;2CAU0C,aAAa;2CAOnB,aAAa,mBAC3B,oBAAoB,GACpC,OAAO,CAAC,MAAM,CAAC;EA6DrB,CAAC"}

package/dist/tools/ls.js

@@ -16,6 +16,7 @@ const inputSchema = z.object({
         .describe("Directory to list (default: current directory)"),
     limit: z
         .preprocess((val) => convertNullString(val), z.coerce.number().nullable())
+        .default(null)
         .describe("Maximum number of entries to return (default: 500)"),
 });
 const DEFAULT_ENTRY_LIMIT = 500;
@@ -24,7 +25,7 @@ export const createLsTool = async (options) => {
     const allowedDirectory = allowedDirs ?? [primaryDir];
     return {
         toolDef: {
-            description: "List files in a directory.",
+            description: "List files in a single directory. Fast and simple - use this when you need a quick flat list of files in one directory. For recursive tree views, use DirectoryTree instead.",
             inputSchema,
         },
         display({ path: providedPath, limit }) {

package/dist/tools/read-file.d.ts

@@ -7,21 +7,20 @@ export declare const ReadFileTool: {
 declare const inputSchema: z.ZodObject<{
     path: z.ZodString;
     encoding: z.ZodDefault<z.ZodNullable<z.ZodEnum<{
+        base64: "base64";
+        base64url: "base64url";
         utf8: "utf8";
         ascii: "ascii";
         "utf-8": "utf-8";
         utf16le: "utf16le";
         ucs2: "ucs2";
         "ucs-2": "ucs-2";
-        base64: "base64";
-        base64url: "base64url";
         latin1: "latin1";
         binary: "binary";
         hex: "hex";
     }>>>;
-    startLine: z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodNullable<z.ZodCoercedNumber<unknown>>>;
-    lineCount: z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodNullable<z.ZodCoercedNumber<unknown>>>;
-    maxBytes: z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodNullable<z.ZodCoercedNumber<unknown>>>;
+    startLine: z.ZodPreprocess<z.ZodNullable<z.ZodCoercedNumber<unknown>>>;
+    lineCount: z.ZodPreprocess<z.ZodNullable<z.ZodCoercedNumber<unknown>>>;
 }, z.core.$strip>;
 type ReadFileInputSchema = z.infer<typeof inputSchema>;
 export declare const createReadFileTool: (options: {
@@ -32,25 +31,24 @@ export declare const createReadFileTool: (options: {
         inputSchema: z.ZodObject<{
             path: z.ZodString;
             encoding: z.ZodDefault<z.ZodNullable<z.ZodEnum<{
+                base64: "base64";
+                base64url: "base64url";
                 utf8: "utf8";
                 ascii: "ascii";
                 "utf-8": "utf-8";
                 utf16le: "utf16le";
                 ucs2: "ucs2";
                 "ucs-2": "ucs-2";
-                base64: "base64";
-                base64url: "base64url";
                 latin1: "latin1";
                 binary: "binary";
                 hex: "hex";
             }>>>;
-            startLine: z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodNullable<z.ZodCoercedNumber<unknown>>>;
-            lineCount: z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodNullable<z.ZodCoercedNumber<unknown>>>;
-            maxBytes: z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodNullable<z.ZodCoercedNumber<unknown>>>;
+            startLine: z.ZodPreprocess<z.ZodNullable<z.ZodCoercedNumber<unknown>>>;
+            lineCount: z.ZodPreprocess<z.ZodNullable<z.ZodCoercedNumber<unknown>>>;
         }, z.core.$strip>;
     };
     display({ path: providedPath, startLine, lineCount }: ReadFileInputSchema): string;
-    execute({ path: providedPath, encoding, startLine, lineCount, maxBytes, }: ReadFileInputSchema, { abortSignal }: ToolExecutionOptions): Promise<string>;
+    execute({ path: providedPath, encoding, startLine, lineCount, }: ReadFileInputSchema, { abortSignal }: ToolExecutionOptions): Promise<string>;
 }>;
 export {};
 //# sourceMappingURL=read-file.d.ts.map

package/dist/tools/read-file.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"read-file.d.ts","sourceRoot":"","sources":["../../source/tools/read-file.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AACxB,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,aAAa,CAAC;AAKpD,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,YAAY,CAAC;AAMvD,eAAO,MAAM,YAAY;;CAExB,CAAC;AAEF,QAAA,MAAM,WAAW;;;;;;;;;;;;;;;;;;iBAuBf,CAAC;AAEH,KAAK,mBAAmB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,WAAW,CAAC,CAAC;AAEvD,eAAO,MAAM,kBAAkB,GAAU,SAAS;IAChD,SAAS,EAAE,gBAAgB,CAAC;CAC7B;;;;;;;;;;;;;;;;;;;;;;;0DAQyD,mBAAmB;+EAWpE,mBAAmB,mBACL,oBAAoB,GACpC,OAAO,CAAC,MAAM,CAAC;EA2BrB,CAAC"}
+{"version":3,"file":"read-file.d.ts","sourceRoot":"","sources":["../../source/tools/read-file.ts"],"names":[],"mappings":"AAKA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AACxB,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,aAAa,CAAC;AAIpD,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,YAAY,CAAC;AAsBvD,eAAO,MAAM,YAAY;;CAExB,CAAC;AAEF,QAAA,MAAM,WAAW;;;;;;;;;;;;;;;;;iBAkBf,CAAC;AAEH,KAAK,mBAAmB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,WAAW,CAAC,CAAC;AAEvD,eAAO,MAAM,kBAAkB,GAAU,SAAS;IAChD,SAAS,EAAE,gBAAgB,CAAC;CAC7B;;;;;;;;;;;;;;;;;;;;;;0DAOyD,mBAAmB;qEAUpE,mBAAmB,mBACL,oBAAoB,GACpC,OAAO,CAAC,MAAM,CAAC;EAsBrB,CAAC"}

package/dist/tools/read-file.js

@@ -1,14 +1,28 @@
 import fs from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
 import { createInterface } from "node:readline/promises";
 import { isNumber } from "@travisennis/stdlib/typeguards";
 import { z } from "zod";
 import style from "../terminal/style.js";
 import { toDisplayPath } from "../utils/filesystem/path-display.js";
-import { joinWorkingDir, validatePath } from "../utils/filesystem/security.js";
 import { convertNullString } from "../utils/zod.js";
 import { fileEncodingSchema } from "./types.js";
-// default limit in bytes (20KB)
-const DEFAULT_BYTE_LIMIT = 20 * 1024;
+// hardcoded limit in bytes (50KB) - not configurable by the agent
+const BYTE_LIMIT = 50 * 1024;
+// Resolve a path for reading, expanding ~ and handling relative paths
+function resolveReadPath(providedPath, workingDir) {
+    // Expand ~ to home directory
+    let resolved = providedPath;
+    if (resolved.startsWith("~/") || resolved === "~") {
+        resolved = path.join(os.homedir(), resolved.slice(1));
+    }
+    // If not absolute, join with working directory
+    if (!path.isAbsolute(resolved)) {
+        resolved = path.join(workingDir, resolved);
+    }
+    return path.normalize(resolved);
+}
 export const ReadFileTool = {
     name: "Read",
 };
@@ -24,13 +38,9 @@ const inputSchema = z.object({
     lineCount: z
         .preprocess((val) => convertNullString(val), z.coerce.number().nullable())
         .describe("Maximum number of lines to read. Required but nullable. Pass null to get all lines."),
-    maxBytes: z
-        .preprocess((val) => convertNullString(val), z.coerce.number().nullable())
-        .describe("Maximum number of bytes to read. Set to 0 for no limit. (Default: 20KB)"),
 });
 export const createReadFileTool = async (options) => {
-    const { primaryDir, allowedDirs } = options.workspace;
-    const allowedDirectory = allowedDirs ?? [primaryDir];
+    const { primaryDir } = options.workspace;
     return {
         toolDef: {
             description: "Read the contents of a file.",
@@ -40,15 +50,14 @@ export const createReadFileTool = async (options) => {
             const displayPath = toDisplayPath(providedPath);
             return `${style.cyan(displayPath)}${startLine ? style.cyan(`:${startLine}`) : ""}${lineCount ? style.cyan(`:${lineCount}`) : ""}`;
         },
-        async execute({ path: providedPath, encoding, startLine, lineCount, maxBytes, }, { abortSignal }) {
+        async execute({ path: providedPath, encoding, startLine, lineCount, }, { abortSignal }) {
             if (abortSignal?.aborted) {
                 throw new Error("File reading aborted");
             }
-            const filePath = await validatePath(joinWorkingDir(providedPath, primaryDir), allowedDirectory, { abortSignal });
+            const filePath = resolveReadPath(providedPath, primaryDir);
             const effectiveEncoding = encoding ?? "utf-8";
-            const effectiveMaxBytes = maxBytes ?? DEFAULT_BYTE_LIMIT;
             const file = await readFileContent(filePath, effectiveEncoding, startLine, lineCount, abortSignal);
-            validateByteLimit(file, effectiveEncoding, effectiveMaxBytes);
+            validateByteLimit(file, effectiveEncoding, BYTE_LIMIT);
             return file;
         },
     };
@@ -98,15 +107,11 @@ async function readFileLines(filePath, startLine, lineCount, abortSignal) {
 }
 // Validate that file content doesn't exceed byte limit
 function validateByteLimit(file, encoding, maxBytes) {
-    if (maxBytes <= 0) {
-        return;
-    }
     const byteLength = Buffer.byteLength(file, encoding);
     if (byteLength > maxBytes) {
         const fileSizeKb = (byteLength / 1024).toFixed(1);
         const limitKb = (maxBytes / 1024).toFixed(0);
         throw new Error(`File (${fileSizeKb}KB) exceeds the ${limitKb}KB read limit. To read this file, use one of these options:\n` +
-            "• Set maxBytes: 0 to read the entire file\n" +
             "• Use startLine and lineCount to read specific portions (e.g., startLine: 1, lineCount: 100)\n" +
             "• Use the Grep tool to search for specific content\n" +
             `• Use the Bash tool with 'tail' or 'head' commands`);

package/dist/tools/save-file.d.ts

@@ -8,14 +8,14 @@ declare const inputSchema: z.ZodObject<{
     path: z.ZodString;
     content: z.ZodString;
     encoding: z.ZodDefault<z.ZodEnum<{
+        base64: "base64";
+        base64url: "base64url";
         utf8: "utf8";
         ascii: "ascii";
         "utf-8": "utf-8";
         utf16le: "utf16le";
         ucs2: "ucs2";
         "ucs-2": "ucs-2";
-        base64: "base64";
-        base64url: "base64url";
         latin1: "latin1";
         binary: "binary";
         hex: "hex";
@@ -31,14 +31,14 @@ export declare const createSaveFileTool: (options: {
             path: z.ZodString;
             content: z.ZodString;
             encoding: z.ZodDefault<z.ZodEnum<{
+                base64: "base64";
+                base64url: "base64url";
                 utf8: "utf8";
                 ascii: "ascii";
                 "utf-8": "utf-8";
                 utf16le: "utf16le";
                 ucs2: "ucs2";
                 "ucs-2": "ucs-2";
-                base64: "base64";
-                base64url: "base64url";
                 latin1: "latin1";
                 binary: "binary";
                 hex: "hex";

package/dist/tools/save-file.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"save-file.d.ts","sourceRoot":"","sources":["../../source/tools/save-file.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,aAAa,CAAC;AASpD,OAAO,EAAsB,KAAK,oBAAoB,EAAE,MAAM,YAAY,CAAC;AAE3E,eAAO,MAAM,YAAY;;CAExB,CAAC;AAEF,QAAA,MAAM,WAAW;;;;;;;;;;;;;;;;iBAQf,CAAC;AAEH,KAAK,mBAAmB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,WAAW,CAAC,CAAC;AAEvD,eAAO,MAAM,kBAAkB,GAAU,SAAS;IAChD,SAAS,EAAE,gBAAgB,CAAC;CAC7B;;;;;;;;;;;;;;;;;;;;;sBAUqB,mBAAmB;mDAKI,mBAAmB,mBACzC,oBAAoB,GACpC,OAAO,CAAC,MAAM,CAAC;EAoDrB,CAAC"}
+{"version":3,"file":"save-file.d.ts","sourceRoot":"","sources":["../../source/tools/save-file.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,aAAa,CAAC;AASpD,OAAO,EAAsB,KAAK,oBAAoB,EAAE,MAAM,YAAY,CAAC;AAE3E,eAAO,MAAM,YAAY;;CAExB,CAAC;AAEF,QAAA,MAAM,WAAW;;;;;;;;;;;;;;;;iBAQf,CAAC;AAEH,KAAK,mBAAmB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,WAAW,CAAC,CAAC;AA8BvD,eAAO,MAAM,kBAAkB,GAAU,SAAS;IAChD,SAAS,EAAE,gBAAgB,CAAC;CAC7B;;;;;;;;;;;;;;;;;;;;;sBAUqB,mBAAmB;mDAKI,mBAAmB,mBACzC,oBAAoB,GACpC,OAAO,CAAC,MAAM,CAAC;EA8BrB,CAAC"}