@travisennis/acai 0.0.11 → 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,6 +9,11 @@ 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<{
@@ -30,7 +36,7 @@ export declare function initTools({ workspace, }: {
             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>>>;
@@ -56,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>;
         };
@@ -81,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";
@@ -98,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: {
@@ -112,31 +118,31 @@ 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>>>;
+                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;
         }): string;
         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;
         }, { abortSignal }: import("./types.ts").ToolExecutionOptions): Promise<string>;
@@ -145,14 +151,14 @@ export declare function initTools({ workspace, }: {
         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 }: {
@@ -182,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, }: {
@@ -219,8 +225,8 @@ export declare function initTools({ workspace, }: {
             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 }: {
@@ -251,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 }: {
@@ -305,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";
@@ -337,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,4 +1,5 @@
 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";
@@ -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 });
@@ -25,7 +35,7 @@ export async function initTools({ workspace, }) {
     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();
@@ -48,6 +58,11 @@ export async function initTools({ workspace, }) {
             WebSearchTool.name,
             WebFetchTool.name,
         ],
+        sessionContext: {
+            sessionId: "",
+            projectDir: workspace.primaryDir,
+            agentName: "repl",
+        },
     });
     // Build tools object for AI SDK
     const tools = {

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;;;;;;;;2CAU0C,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;

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

@@ -7,20 +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>>>;
+    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: {
@@ -31,20 +31,20 @@ 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>>>;
+            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;

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/skill.d.ts

@@ -1,4 +1,5 @@
 import { z } from "zod";
+import type { ActivatedSkillsTracker } from "../skills/activated-tracker.ts";
 import type { ToolExecutionOptions } from "./types.ts";
 export declare const SkillTool: {
     name: "Skill";
@@ -8,7 +9,7 @@ declare const inputSchema: z.ZodObject<{
     args: z.ZodOptional<z.ZodString>;
 }, z.core.$strip>;
 type SkillInputSchema = z.infer<typeof inputSchema>;
-export declare function createSkillTool(): Promise<{
+export declare function createSkillTool(activatedSkillsTracker: ActivatedSkillsTracker): Promise<{
     toolDef: {
         description: string;
         inputSchema: z.ZodObject<{

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

@@ -1 +1 @@
-{"version":3,"file":"skill.d.ts","sourceRoot":"","sources":["../../source/tools/skill.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAIxB,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,YAAY,CAAC;AAEvD,eAAO,MAAM,SAAS;;CAErB,CAAC;AAEF,QAAA,MAAM,WAAW;;;iBAKf,CAAC;AAEH,KAAK,gBAAgB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,WAAW,CAAC,CAAC;AAEpD,wBAAsB,eAAe;;;;;;;;kCAWH,gBAAgB,GAAG,MAAM;wCAIzB,gBAAgB,mBAC3B,oBAAoB,GACpC,OAAO,CAAC,MAAM,CAAC;GA4CrB"}
+{"version":3,"file":"skill.d.ts","sourceRoot":"","sources":["../../source/tools/skill.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,gCAAgC,CAAC;AAI7E,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,YAAY,CAAC;AAEvD,eAAO,MAAM,SAAS;;CAErB,CAAC;AAEF,QAAA,MAAM,WAAW;;;iBAKf,CAAC;AAEH,KAAK,gBAAgB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,WAAW,CAAC,CAAC;AA+BpD,wBAAsB,eAAe,CACnC,sBAAsB,EAAE,sBAAsB;;;;;;;;kCAcd,gBAAgB,GAAG,MAAM;wCAIzB,gBAAgB,mBAC3B,oBAAoB,GACpC,OAAO,CAAC,MAAM,CAAC;GA8DrB"}

package/dist/tools/skill.js

@@ -1,6 +1,6 @@
-import { readFile } from "node:fs/promises";
-import { dirname } from "node:path";
+import { readdir, readFile } from "node:fs/promises";
 import { z } from "zod";
+import { config, parseSkillsPath } from "../config/index.js";
 import { loadSkills } from "../skills/index.js";
 import style from "../terminal/style.js";
 import { replaceArgumentPlaceholders } from "../utils/templates.js";
@@ -13,8 +13,37 @@ const inputSchema = z.object({
         .describe('The skill name. E.g., "commit", "review-pr", or "pdf"'),
     args: z.string().optional().describe("Optional arguments for the skill"),
 });
-export async function createSkillTool() {
-    const skills = await loadSkills();
+/**
+ * List resources (files and directories) in a skill directory.
+ * Returns relative paths, excluding SKILL.md and hidden files.
+ */
+async function listSkillResources(baseDir) {
+    try {
+        const entries = await readdir(baseDir, { withFileTypes: true });
+        const resources = [];
+        for (const entry of entries) {
+            // Skip SKILL.md (already included in body)
+            if (entry.name === "SKILL.md")
+                continue;
+            // Skip hidden files
+            if (entry.name.startsWith("."))
+                continue;
+            resources.push(entry.name);
+        }
+        // Sort for consistent output
+        resources.sort();
+        // Cap at 50 files to avoid overwhelming output
+        return resources.slice(0, 50);
+    }
+    catch {
+        // Directory read failed, return empty
+        return [];
+    }
+}
+export async function createSkillTool(activatedSkillsTracker) {
+    const appConfig = await config.getConfig();
+    const skillPaths = parseSkillsPath(appConfig.skills.path);
+    const skills = await loadSkills(skillPaths);
     const modelInvocableSkills = skills.getModelInvocable();
     const description = "Run a skill (e.g., commit, review-pr).";
     return {
@@ -30,35 +59,49 @@ export async function createSkillTool() {
                 if (abortSignal?.aborted) {
                     throw new Error("Skill execution aborted");
                 }
+                // Check for deduplication
+                if (activatedSkillsTracker.has(skillName)) {
+                    return `Skill "${skillName}" is already loaded in this session. Its instructions are available in the conversation context.`;
+                }
                 // Find the skill
                 const skill = modelInvocableSkills.find((s) => s.name === skillName);
                 if (!skill) {
                     const availableSkillNames = modelInvocableSkills
                         .map((s) => s.name)
                         .join(", ");
-                    const errorMsg = `Skill "${skillName}" not found. Available skills: ${availableSkillNames}`;
-                    return errorMsg;
+                    return `Skill "${skillName}" not found. Available skills: ${availableSkillNames}`;
                 }
                 if (skill.disableModelInvocation) {
                     return `Skill "${skillName}" is not available for model invocation.`;
                 }
                 // Read the skill file
                 const content = await readFile(skill.filePath, "utf8");
-                let result = `# Skill Name: ${skill.name}`;
-                result += `\n**Base directory**: ${dirname(skill.filePath)}\n\n`;
-                result +=
-                    "Relative paths in this skill (e.g., scripts/, reference/) are relative to this base directory.\n";
                 // Parse frontmatter and body
                 const yamlStart = content.indexOf("---");
                 const yamlEnd = content.indexOf("---", yamlStart + 3);
                 const body = yamlEnd !== -1 ? content.slice(yamlEnd + 3).trim() : content;
+                // List resources in skill directory
+                const resources = await listSkillResources(skill.baseDir);
+                // Build result
+                let result = `# Skill: ${skill.name}\n\n`;
+                result += `**Base directory**: ${skill.baseDir}\n\n`;
+                if (resources.length > 0) {
+                    result += "<skill_resources>\n";
+                    for (const resource of resources) {
+                        result += `${resource}\n`;
+                    }
+                    result += "</skill_resources>\n\n";
+                    result +=
+                        "Relative paths in this skill are relative to the base directory.\n\n";
+                }
                 const argsArray = args ? args.split(/\s+/).filter(Boolean) : [];
                 result += replaceArgumentPlaceholders(body, argsArray);
+                // Mark as activated
+                activatedSkillsTracker.add(skillName);
                 return result;
             }
             catch (error) {
-                const errorMsg = `${error.message}`;
-                return errorMsg;
+                return error.message;
             }
         },
     };

package/dist/tools/types.d.ts

@@ -1,20 +1,26 @@
 import { z } from "zod";
 export declare const fileEncodingSchema: 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";
 }>;
+export type SessionContext = {
+    sessionId: string;
+    projectDir: string;
+    agentName: string;
+};
 export type ToolExecutionOptions = {
     toolCallId: string;
     messages?: any[];
     abortSignal?: AbortSignal;
+    sessionContext?: SessionContext;
 };
 //# sourceMappingURL=types.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../source/tools/types.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,eAAO,MAAM,kBAAkB;;;;;;;;;;;;EAY7B,CAAC;AAEH,MAAM,MAAM,oBAAoB,GAAG;IACjC,UAAU,EAAE,MAAM,CAAC;IAEnB,QAAQ,CAAC,EAAE,GAAG,EAAE,CAAC;IACjB,WAAW,CAAC,EAAE,WAAW,CAAC;CAC3B,CAAC"}
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../source/tools/types.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,eAAO,MAAM,kBAAkB;;;;;;;;;;;;EAY7B,CAAC;AAEH,MAAM,MAAM,cAAc,GAAG;IAC3B,SAAS,EAAE,MAAM,CAAC;IAClB,UAAU,EAAE,MAAM,CAAC;IACnB,SAAS,EAAE,MAAM,CAAC;CACnB,CAAC;AAEF,MAAM,MAAM,oBAAoB,GAAG;IACjC,UAAU,EAAE,MAAM,CAAC;IAEnB,QAAQ,CAAC,EAAE,GAAG,EAAE,CAAC;IACjB,WAAW,CAAC,EAAE,WAAW,CAAC;IAC1B,cAAc,CAAC,EAAE,cAAc,CAAC;CACjC,CAAC"}

package/dist/tools/web-fetch.d.ts

@@ -14,9 +14,9 @@ declare const inputSchema: z.ZodObject<{
         html: "html";
         json: "json";
     }>>;
-    jina: z.ZodOptional<z.ZodPipe<z.ZodTransform<string | null, unknown>, z.ZodNullable<z.ZodCoercedBoolean<unknown>>>>;
-    timeout: z.ZodOptional<z.ZodPipe<z.ZodTransform<string | null, unknown>, z.ZodNullable<z.ZodCoercedNumber<unknown>>>>;
-    headers: z.ZodOptional<z.ZodPipe<z.ZodTransform<string | null, unknown>, z.ZodNullable<z.ZodCoercedBoolean<unknown>>>>;
+    jina: z.ZodOptional<z.ZodPreprocess<z.ZodNullable<z.ZodCoercedBoolean<unknown>>>>;
+    timeout: z.ZodOptional<z.ZodPreprocess<z.ZodNullable<z.ZodCoercedNumber<unknown>>>>;
+    headers: z.ZodOptional<z.ZodPreprocess<z.ZodNullable<z.ZodCoercedBoolean<unknown>>>>;
 }, z.core.$strip>;
 type WebFetchInputSchema = z.infer<typeof inputSchema>;
 /**
@@ -37,9 +37,9 @@ export declare const createWebFetchTool: () => Promise<{
                 html: "html";
                 json: "json";
             }>>;
-            jina: z.ZodOptional<z.ZodPipe<z.ZodTransform<string | null, unknown>, z.ZodNullable<z.ZodCoercedBoolean<unknown>>>>;
-            timeout: z.ZodOptional<z.ZodPipe<z.ZodTransform<string | null, unknown>, z.ZodNullable<z.ZodCoercedNumber<unknown>>>>;
-            headers: z.ZodOptional<z.ZodPipe<z.ZodTransform<string | null, unknown>, z.ZodNullable<z.ZodCoercedBoolean<unknown>>>>;
+            jina: z.ZodOptional<z.ZodPreprocess<z.ZodNullable<z.ZodCoercedBoolean<unknown>>>>;
+            timeout: z.ZodOptional<z.ZodPreprocess<z.ZodNullable<z.ZodCoercedNumber<unknown>>>>;
+            headers: z.ZodOptional<z.ZodPreprocess<z.ZodNullable<z.ZodCoercedBoolean<unknown>>>>;
         }, z.core.$strip>;
     };
     display({ url }: WebFetchInputSchema): string;

package/dist/tools/web-fetch.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"web-fetch.d.ts","sourceRoot":"","sources":["../../source/tools/web-fetch.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,YAAY,CAAC;AAEvD,eAAO,MAAM,YAAY;;CAExB,CAAC;AAQF;;GAEG;AACH,QAAA,MAAM,WAAW;;;;;;;;;;;iBAkBf,CAAC;AAEH,KAAK,mBAAmB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,WAAW,CAAC,CAAC;AA6bvD;;GAEG;AACH,wBAAsB,eAAe,CACnC,OAAO,EAAE,mBAAmB,EAC5B,gBAAgB,EAAE,oBAAoB,GACrC,OAAO,CAAC,MAAM,CAAC,CAiEjB;AAED;;GAEG;AACH,eAAO,MAAM,kBAAkB;;;;;;;;;;;;;;;;qBAQV,mBAAmB;qBAIzB,mBAAmB,oBACV,oBAAoB,GACrC,OAAO,CAAC,MAAM,CAAC;EAIrB,CAAC;AAEF,MAAM,MAAM,YAAY,GAAG,OAAO,CAAC,UAAU,CAAC,OAAO,kBAAkB,CAAC,CAAC,CAAC"}
+{"version":3,"file":"web-fetch.d.ts","sourceRoot":"","sources":["../../source/tools/web-fetch.ts"],"names":[],"mappings":"AAIA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,YAAY,CAAC;AAEvD,eAAO,MAAM,YAAY;;CAExB,CAAC;AASF;;GAEG;AACH,QAAA,MAAM,WAAW;;;;;;;;;;;iBAkBf,CAAC;AAEH,KAAK,mBAAmB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,WAAW,CAAC,CAAC;AA6bvD;;GAEG;AACH,wBAAsB,eAAe,CACnC,OAAO,EAAE,mBAAmB,EAC5B,gBAAgB,EAAE,oBAAoB,GACrC,OAAO,CAAC,MAAM,CAAC,CAwFjB;AAED;;GAEG;AACH,eAAO,MAAM,kBAAkB;;;;;;;;;;;;;;;;qBAQV,mBAAmB;qBAIzB,mBAAmB,oBACV,oBAAoB,GACrC,OAAO,CAAC,MAAM,CAAC;EAIrB,CAAC;AAEF,MAAM,MAAM,YAAY,GAAG,OAAO,CAAC,UAAU,CAAC,OAAO,kBAAkB,CAAC,CAAC,CAAC"}