kat babe love :)

packages/ai-tools/dist/index.d.ts

@@ -26,3 +26,5 @@ export declare const winstonLogger: (name: string, file: string, targets?: ELogT
 export declare const createFileLogger: (logger: Logger<unknown>, level: number, file: string) => Logger<unknown>;
 export declare const toolLoggerTS: (name: any, options: IKBotTask) => Logger<unknown>;
 export declare const toolLogger: (name: any, options?: IKBotTask) => winston.Logger;
+export * from './types.js';
+export * from './types_kbot.js';

packages/ai-tools/dist/zod_schemas.d.ts

@@ -114,15 +114,15 @@ export declare const InvokeToolSchema: z.ZodObject<{
     env_key: z.ZodOptional<z.ZodString>;
 }, "strip", z.ZodTypeAny, {
     function?: string;
-    params?: string;
     tools?: string;
+    params?: string;
     target?: string;
     output?: string;
     env_key?: string;
 }, {
     function?: string;
-    params?: string;
     tools?: string;
+    params?: string;
     target?: string;
     output?: string;
     env_key?: string;

packages/ai-tools/package-lock.json

@@ -23,7 +23,7 @@
         "marked": "^15.0.4",
         "mime-types": "^2.1.35",
         "nodemailer": "^6.9.16",
-        "openai": "^4.84.0",
+        "openai": "^4.85.3",
         "p-map": "^7.0.3",
         "rotating-file-stream": "^3.2.6",
         "screenshot-desktop": "^1.15.0",
@@ -66,13 +66,14 @@
         "env-var": "^7.5.0",
         "glob": "^10.4.5",
         "js-yaml": "^4.1.0",
-        "jsonpath-plus": "^8.1.0",
+        "jsonpath-plus": "^10.3.0",
         "normalize-url": "^8.0.1",
         "p-map": "^7.0.3",
         "p-throttle": "^4.1.1",
         "tslog": "^3.3.3",
-        "tsup": "^8.3.5",
+        "tsup": "^2.0.3",
         "yargs": "^17.7.2",
+        "zod": "^3.24.2",
         "zod-to-json-schema": "^3.24.1",
         "zod-to-ts": "^1.2.0"
       },
@@ -2805,9 +2806,9 @@
       }
     },
     "node_modules/openai": {
-      "version": "4.85.2",
-      "resolved": "https://registry.npmjs.org/openai/-/openai-4.85.2.tgz",
-      "integrity": "sha512-ZQg3Q+K4A6M9dLFh5W36paZkZBQO+VbxMNJ1gUSyHsGiEWuXahdn02ermqNV68LhWQxdJQaWUFRAYpW/suTPWQ==",
+      "version": "4.85.3",
+      "resolved": "https://registry.npmjs.org/openai/-/openai-4.85.3.tgz",
+      "integrity": "sha512-KTMXAK6FPd2IvsPtglMt0J1GyVrjMxCYzu/mVbCPabzzquSJoZlYpHtE0p0ScZPyt11XTc757xSO4j39j5g+Xw==",
       "license": "Apache-2.0",
       "dependencies": {
         "@types/node": "^18.11.18",

packages/ai-tools/package.json

@@ -10,6 +10,16 @@
   "bin": {
     "ai-tools": "./main.js"
   },
+  "exports": {
+    ".": {
+      "import": "./dist/index.js",
+      "require": "./dist/index.cjs"
+    },
+    "./tools": {
+      "import": "./dist/lib/tools/tools.js",
+      "require": "./dist/lib/tools/tools.cjs"
+    }
+  },
   "scripts": {
     "build": "tsc -p . --declaration",
     "start": "node ./main.js",
@@ -33,7 +43,7 @@
     "marked": "^15.0.4",
     "mime-types": "^2.1.35",
     "nodemailer": "^6.9.16",
-    "openai": "^4.84.0",
+    "openai": "^4.85.3",
     "p-map": "^7.0.3",
     "rotating-file-stream": "^3.2.6",
     "screenshot-desktop": "^1.15.0",

packages/ai-tools/src/index.ts

@@ -180,4 +180,7 @@ export const toolLogger = (name, options: IKBotTask = { logs: process.cwd() } as
     const logPath = path.resolve(path.join(options.logs || './',`tools-${name}.json`))
     const log = winstonLogger(name, logPath, ELogTargets.Console)
     return log
-}
+}
+
+export * from './types.js'
+export * from './types_kbot.js'

packages/commons/package.json

@@ -68,13 +68,14 @@
     "env-var": "^7.5.0",
     "glob": "^10.4.5",
     "js-yaml": "^4.1.0",
-    "jsonpath-plus": "^8.1.0",
+    "jsonpath-plus": "^10.3.0",
     "normalize-url": "^8.0.1",
     "p-map": "^7.0.3",
     "p-throttle": "^4.1.1",
     "tslog": "^3.3.3",
-    "tsup": "^8.3.5",
+    "tsup": "^2.0.3",
     "yargs": "^17.7.2",
+    "zod": "^3.24.2",
     "zod-to-json-schema": "^3.24.1",
     "zod-to-ts": "^1.2.0"
   },

packages/core/package.json

@@ -40,6 +40,10 @@
     "./objects": {
       "import": "./dist/objects.js",
       "require": "./dist/objects.js"
+    },
+    "./aspects_simple": {
+      "import": "./dist/aspects_simple.js",
+      "require": "./dist/aspects_simple.js"
     }
   },
   "main": "dist/index.js",

packages/kbot/dist-in/client.d.ts

@@ -1,3 +1,3 @@
-import { OpenAI } from 'openai';
+import OpenAI from 'openai';
 import { IKBotOptions } from './zod_types.js';
 export declare const createClient: (options: IKBotOptions) => OpenAI;

packages/kbot/dist-in/client.js

@@ -1,4 +1,4 @@
-import { OpenAI } from 'openai';
+import OpenAI from 'openai';
 import { logger } from './index.js';
 import { loadConfig } from './config.js';
 /**
@@ -92,4 +92,4 @@ export const createClient = (options) => {
         baseURL,
     });
 };
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY2xpZW50LmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vc3JjL2NsaWVudC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFRLE1BQU0sTUFBTyxRQUFRLENBQUE7QUFDN0IsT0FBTyxFQUFFLE1BQU0sRUFBRSxNQUFNLFlBQVksQ0FBQTtBQUNuQyxPQUFPLEVBQUUsVUFBVSxFQUFFLE1BQU0sYUFBYSxDQUFBO0FBT3hDOztHQUVHO0FBQ0gsTUFBTSxnQkFBZ0IsR0FBK0I7SUFDakQsVUFBVSxFQUFFLDhCQUE4QjtJQUMxQyxNQUFNLEVBQUUsRUFBRSxFQUFFLDBCQUEwQjtJQUN0QyxRQUFRLEVBQUUsMEJBQTBCO0lBQ3BDLFdBQVcsRUFBRSxzQ0FBc0M7SUFDbkQsTUFBTSxFQUFFLHdCQUF3QixFQUFFLHNDQUFzQztJQUN4RSxTQUFTLEVBQUUsNkJBQTZCLEVBQUUseUJBQXlCO0lBQ25FLE1BQU0sRUFBRSxrREFBa0QsRUFBRSxzQkFBc0I7SUFDbEYsR0FBRyxFQUFFLHFCQUFxQixFQUFFLDBCQUEwQjtDQUN6RCxDQUFBO0FBRUQ7O0dBRUc7QUFDSCxNQUFNLGNBQWMsR0FBK0I7SUFDL0MsVUFBVSxFQUFFLDZCQUE2QjtJQUN6QyxNQUFNLEVBQUUsUUFBUTtJQUNoQixRQUFRLEVBQUUsZUFBZTtJQUN6QixXQUFXLEVBQUUsY0FBYztJQUMzQixNQUFNLEVBQUUsU0FBUyxFQUFFLHVCQUF1QjtJQUMxQyxTQUFTLEVBQUUsbUJBQW1CLEVBQUUsMEJBQTBCO0lBQzFELE1BQU0sRUFBRSxnQkFBZ0IsRUFBRSx1QkFBdUI7SUFDakQsR0FBRyxFQUFFLFFBQVEsQ0FBQywyQkFBMkI7Q0FDNUMsQ0FBQTtBQUNEOzs7O0dBSUc7QUFDSCxNQUFNLENBQUMsTUFBTSxZQUFZLEdBQUcsQ0FBQyxPQUFxQixFQUFFLEVBQUU7SUFDbEQsK0JBQStCO0lBQy9CLE1BQU0sTUFBTSxHQUFHLFVBQVUsQ0FBQyxPQUFPLENBQUMsQ0FBQztJQUNuQyxJQUFJLENBQUMsTUFBTSxFQUFFLENBQUM7UUFDVixNQUFNLENBQUMsS0FBSyxDQUNSLDhDQUE4QztZQUM5Qyx3RUFBd0UsQ0FDM0UsQ0FBQztRQUNGLE9BQU8sU0FBUyxDQUFDO0lBQ3JCLENBQUM7SUFDRCxxREFBcUQ7SUFDckQsTUFBTSxNQUFNLEdBQWUsQ0FBQyxPQUFPLENBQUMsTUFBTSxJQUFJLFlBQVksQ0FBZSxDQUFDO0lBRTFFLHFCQUFxQjtJQUNyQixJQUFJLE1BQU0sR0FBRyxPQUFPLENBQUMsT0FBTyxDQUFDO0lBRTdCLHlEQUF5RDtJQUN6RCxJQUFJLENBQUMsTUFBTSxFQUFFLENBQUM7UUFDVixRQUFRLE1BQU0sRUFBRSxDQUFDO1lBQ2IsS0FBSyxZQUFZO2dCQUNiLE1BQU0sR0FBRyxNQUFNLEVBQUUsVUFBVSxFQUFFLEdBQUcsQ0FBQztnQkFDakMsTUFBTTtZQUNWLEtBQUssUUFBUTtnQkFDVCxNQUFNLEdBQUcsTUFBTSxFQUFFLE1BQU0sRUFBRSxHQUFHLENBQUM7Z0JBQzdCLE1BQU07WUFDVixLQUFLLFVBQVU7Z0JBQ1gsTUFBTSxHQUFHLE1BQU0sRUFBRSxRQUFRLEVBQUUsR0FBRyxDQUFDO2dCQUMvQixNQUFNO1lBQ1YsS0FBSyxhQUFhO2dCQUNkLE1BQU0sR0FBRyxNQUFNLEVBQUUsV0FBVyxFQUFFLEdBQUcsQ0FBQztnQkFDbEMsTUFBTTtZQUNWLEtBQUssUUFBUTtnQkFDVCx5REFBeUQ7Z0JBQ3pELE1BQU0sR0FBRyxRQUFRLENBQUMsQ0FBQyx1QkFBdUI7Z0JBQzFDLE1BQU07WUFDVixLQUFLLFdBQVc7Z0JBQ1osTUFBTSxHQUFHLE1BQU0sRUFBRSxTQUFTLEVBQUUsR0FBRyxDQUFDO2dCQUNoQyxNQUFNO1lBQ1YsS0FBSyxRQUFRO2dCQUNULE1BQU0sR0FBRyxNQUFNLEVBQUUsTUFBTSxFQUFFLEdBQUcsQ0FBQztnQkFDN0IsTUFBTTtZQUNWLEtBQUssS0FBSztnQkFDTixNQUFNLEdBQUcsTUFBTSxFQUFFLEdBQUcsRUFBRSxHQUFHLENBQUM7Z0JBQzFCLE1BQU07UUFDZCxDQUFDO0lBQ0wsQ0FBQztJQUVELG1CQUFtQjtJQUNuQixJQUFJLENBQUMsTUFBTSxFQUFHLENBQUM7UUFDWCxNQUFNLENBQUMsS0FBSyxDQUFDLE1BQU0sTUFBTSw0RkFBNEYsQ0FBQyxDQUFDO1FBQ3ZILE9BQU8sU0FBUyxDQUFDO0lBQ3JCLENBQUM7SUFFRCxzQ0FBc0M7SUFDdEMsTUFBTSxPQUFPLEdBQUcsT0FBTyxDQUFDLE9BQU8sSUFBSSxnQkFBZ0IsQ0FBQyxNQUFNLENBQUMsQ0FBQTtJQUUzRCxvQ0FBb0M7SUFDcEMsSUFBSSxDQUFDLE9BQU8sQ0FBQyxLQUFLLEVBQUUsQ0FBQztRQUNqQixPQUFPLENBQUMsS0FBSyxHQUFHLGNBQWMsQ0FBQyxNQUFNLENBQUMsQ0FBQTtJQUMxQyxDQUFDO0lBRUQsTUFBTSxDQUFDLElBQUksQ0FBQyx3QkFBd0IsTUFBTSxrQkFBa0IsT0FBTyxDQUFDLEtBQUssaUJBQWlCLE1BQU0sT0FBTyxPQUFPLEVBQUUsQ0FBQyxDQUFBO0lBRWpILCtDQUErQztJQUMvQyxPQUFPLElBQUksTUFBTSxDQUFDO1FBQ2QsTUFBTTtRQUNOLE9BQU87S0FDVixDQUFDLENBQUE7QUFDTixDQUFDLENBQUEifQ==

packages/kbot/dist-in/collector.d.ts

@@ -0,0 +1,4 @@
+import OpenAI from 'openai';
+import { ICollector } from '@polymech/ai-tools';
+import { IKBotOptions } from './zod_types.js';
+export declare const collector: (options: IKBotOptions, client: OpenAI) => ICollector;

packages/kbot/dist-in/collector.js

@@ -0,0 +1,70 @@
+import path from 'path';
+import { resolve } from '@polymech/commons';
+import { winstonLogger, } from '@polymech/ai-tools';
+import { logger as loggerIntern } from './index.js';
+export const collector = (options, client) => {
+    return {
+        //OpenAI
+        onMessage: (message) => {
+            const logFile = path.resolve(path.join(resolve(options.logs), 'openai-message.json'));
+            const logger = winstonLogger('collector:onMessage', logFile);
+            logger.info(message);
+        },
+        onToolCall: async (message) => {
+            const logFile = path.resolve(path.join(resolve(options.logs), 'tool-call.json'));
+            const logger = winstonLogger('collector:onToolCall', logFile);
+            try {
+                const msg = { ...message, arguments: JSON.parse(message.arguments) };
+                logger.debug(msg);
+            }
+            catch (e) {
+                logger.debug(message);
+            }
+        },
+        onFunctionCallResult: (message) => {
+            const logFile = path.resolve(path.join(resolve(options.logs), 'tool-call-result.json'));
+            const logger = winstonLogger('collector:onFunctionCallResult', logFile);
+            try {
+                const msg = { message: JSON.parse(message) };
+                logger.debug(msg);
+            }
+            catch (e) {
+                logger.debug(message);
+            }
+        },
+        onChatCompletion: (message) => {
+            const logFile = path.resolve(path.join(resolve(options.logs), 'completion.json'));
+            const logger = winstonLogger('collector:onChatCompletion', logFile);
+            logger.debug(message);
+        },
+        onContent: (content) => {
+            const logFile = path.resolve(path.join(resolve(options.logs), 'content.json'));
+            const logger = winstonLogger('collector:onContent', logFile);
+            logger.debug(content);
+        },
+        onTool(category, name, args, result) {
+            const logFile = path.resolve(path.join(resolve(options.logs), 'tool.json'));
+            const logger = winstonLogger('collector:onTool', logFile);
+            logger.debug({ category, name, args, result });
+        },
+        onToolBefore: async (ctx, args) => {
+            try {
+                loggerIntern.debug(`onToolBefore :${ctx.name}`);
+            }
+            catch (e) {
+                loggerIntern.error(e);
+            }
+            return args;
+        },
+        onToolAfter: async (ctx, args, result) => {
+            try {
+                loggerIntern.debug(`onToolAfter : ${ctx.name}`);
+            }
+            catch (e) {
+                loggerIntern.error(e);
+            }
+            return result[0];
+        }
+    };
+};
+//# sourceMappingURL=data:application/json;base64,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

packages/kbot/dist-in/commands/build.d.ts

@@ -0,0 +1 @@
+export declare const build: () => Promise<void>;

packages/kbot/dist-in/commands/build.js

@@ -0,0 +1,36 @@
+import path from 'path';
+import { CONFIG_DEFAULT } from '@polymech/commons';
+import { sync as read } from '@polymech/fs/read';
+import { sync as write } from '@polymech/fs/write';
+import { sync as exists } from '@polymech/fs/exists';
+import { logger } from '../index.js';
+import { fetchOpenAIModels } from '../models/openai.js';
+import { fetchOpenRouterModels } from '../models/openrouter.js';
+export const build = async () => {
+    const examplesSrc = path.resolve(__dirname, '../docs_/examples.md');
+    if (exists(examplesSrc)) {
+        const examples = read(examplesSrc, 'string') || '';
+        const examplesPath = path.resolve(__dirname, '../src/docs-internal/examples.ts');
+        write(examplesPath, `export const examples = ${JSON.stringify(examples)}`);
+        logger.info(`Examples file generated " ${examplesPath}`);
+    }
+    else {
+        logger.error(`Examples file not found ${examplesSrc}`);
+    }
+    const config = CONFIG_DEFAULT();
+    const modelsOpenAI = await fetchOpenAIModels(config.openai.key);
+    const modelsOpenRouter = (await fetchOpenRouterModels()).map((model) => {
+        return {
+            id: model.id,
+            name: model.name,
+            pricing: model.pricing,
+            context: model.context,
+            created: model.created
+        };
+    });
+    const modelsOpenAIPath = path.resolve(__dirname, '../src/models/cache/openai.ts');
+    write(modelsOpenAIPath, `export const models = ${JSON.stringify(modelsOpenAI)}`);
+    const modelsOpenRouterPath = path.resolve(__dirname, '../src/models/cache/openrouter.ts');
+    write(modelsOpenRouterPath, `export const models = ${JSON.stringify(modelsOpenRouter)}`);
+};
+//# sourceMappingURL=data:application/json;base64,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

packages/kbot/dist-in/commands/examples.d.ts

@@ -0,0 +1 @@
+export declare const examples: () => void;

packages/kbot/dist-in/commands/examples.js

@@ -0,0 +1,10 @@
+import { marked } from 'marked';
+import { markedTerminal } from 'marked-terminal';
+import { examples as content } from '../docs-internal/examples.js';
+export const examples = () => {
+    marked.use(markedTerminal({
+        emoji: false,
+    }));
+    process.stdout.write(marked(content));
+};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZXhhbXBsZXMuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvY29tbWFuZHMvZXhhbXBsZXMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLE1BQU0sRUFBRSxNQUFNLFFBQVEsQ0FBQTtBQUMvQixPQUFPLEVBQUUsY0FBYyxFQUFFLE1BQU0saUJBQWlCLENBQUE7QUFDaEQsT0FBTyxFQUFFLFFBQVEsSUFBSSxPQUFPLEVBQUUsTUFBTSw4QkFBOEIsQ0FBQTtBQUVsRSxNQUFNLENBQUMsTUFBTSxRQUFRLEdBQUcsR0FBRyxFQUFFO0lBQzNCLE1BQU0sQ0FBQyxHQUFHLENBQUMsY0FBYyxDQUN2QjtRQUNFLEtBQUssRUFBRSxLQUFLO0tBQ2IsQ0FDRixDQUFDLENBQUE7SUFDRixPQUFPLENBQUMsTUFBTSxDQUFDLEtBQUssQ0FBQyxNQUFNLENBQUMsT0FBTyxDQUFXLENBQUMsQ0FBQTtBQUNqRCxDQUFDLENBQUEifQ==

packages/kbot/dist-in/commands/fetch.d.ts

@@ -0,0 +1 @@
+export declare const fetch: () => Promise<void>;

packages/kbot/dist-in/commands/fetch.js

@@ -0,0 +1,33 @@
+import path from 'path';
+import { sync as write } from '@polymech/fs/write';
+import { logger, module_root } from '../index.js';
+import { fetchOpenAIModels } from '../models/openai.js';
+import { fetchOpenRouterModels } from '../models/openrouter.js';
+import { CONFIG_DEFAULT } from '@polymech/commons';
+export const fetch = async () => {
+    const config = CONFIG_DEFAULT();
+    if (config.openai && config.openai.key) {
+        const modelsOpenAI = await fetchOpenAIModels(config.openai.key);
+        if (modelsOpenAI) {
+            const modelsOpenAIPath = path.resolve(module_root(), 'openai.json');
+            write(modelsOpenAIPath, modelsOpenAI);
+            logger.info(`Fetched ${modelsOpenAI.length} OpenAI models, to ${modelsOpenAIPath}`);
+        }
+        else {
+            logger.error(`Failed to fetch OpenAI models`);
+        }
+    }
+    const modelsOpenRouter = (await fetchOpenRouterModels()).map((model) => {
+        return {
+            id: model.id,
+            name: model.name,
+            pricing: model.pricing,
+            context: model.context,
+            created: model.created
+        };
+    });
+    const modelsOpenRouterPath = path.resolve(module_root(), 'openrouter.json');
+    write(modelsOpenRouterPath, modelsOpenRouter);
+    logger.info(`Fetched ${modelsOpenRouter.length} OpenRouter models, to ${modelsOpenRouterPath}`);
+};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZmV0Y2guanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvY29tbWFuZHMvZmV0Y2gudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxJQUFJLE1BQU0sTUFBTSxDQUFBO0FBQ3ZCLE9BQU8sRUFBRSxJQUFJLElBQUksS0FBSyxFQUFFLE1BQU0sb0JBQW9CLENBQUE7QUFDbEQsT0FBTyxFQUFFLE1BQU0sRUFBRSxXQUFXLEVBQUUsTUFBTSxhQUFhLENBQUE7QUFDakQsT0FBTyxFQUFFLGlCQUFpQixFQUFFLE1BQU0scUJBQXFCLENBQUE7QUFDdkQsT0FBTyxFQUFFLHFCQUFxQixFQUFFLE1BQU0seUJBQXlCLENBQUE7QUFDL0QsT0FBTyxFQUFFLGNBQWMsRUFBRSxNQUFNLG1CQUFtQixDQUFBO0FBRWxELE1BQU0sQ0FBQyxNQUFNLEtBQUssR0FBRyxLQUFLLElBQUksRUFBRTtJQUU5QixNQUFNLE1BQU0sR0FBRyxjQUFjLEVBQVMsQ0FBQTtJQUN0QyxJQUFJLE1BQU0sQ0FBQyxNQUFNLElBQUksTUFBTSxDQUFDLE1BQU0sQ0FBQyxHQUFHLEVBQUUsQ0FBQztRQUN2QyxNQUFNLFlBQVksR0FBRyxNQUFNLGlCQUFpQixDQUFDLE1BQU0sQ0FBQyxNQUFNLENBQUMsR0FBRyxDQUFDLENBQUE7UUFDL0QsSUFBSSxZQUFZLEVBQUUsQ0FBQztZQUNqQixNQUFNLGdCQUFnQixHQUFHLElBQUksQ0FBQyxPQUFPLENBQUMsV0FBVyxFQUFFLEVBQUUsYUFBYSxDQUFDLENBQUE7WUFDbkUsS0FBSyxDQUFDLGdCQUFnQixFQUFFLFlBQVksQ0FBQyxDQUFBO1lBQ3JDLE1BQU0sQ0FBQyxJQUFJLENBQUMsV0FBVyxZQUFZLENBQUMsTUFBTSxzQkFBc0IsZ0JBQWdCLEVBQUUsQ0FBQyxDQUFBO1FBQ3JGLENBQUM7YUFBTSxDQUFDO1lBQ04sTUFBTSxDQUFDLEtBQUssQ0FBQywrQkFBK0IsQ0FBQyxDQUFBO1FBQy9DLENBQUM7SUFDSCxDQUFDO0lBRUQsTUFBTSxnQkFBZ0IsR0FBRyxDQUFDLE1BQU0scUJBQXFCLEVBQUUsQ0FBQyxDQUFDLEdBQUcsQ0FBQyxDQUFDLEtBQUssRUFBRSxFQUFFO1FBQ3JFLE9BQU87WUFDTCxFQUFFLEVBQUUsS0FBSyxDQUFDLEVBQUU7WUFDWixJQUFJLEVBQUUsS0FBSyxDQUFDLElBQUk7WUFDaEIsT0FBTyxFQUFFLEtBQUssQ0FBQyxPQUFPO1lBQ3RCLE9BQU8sRUFBRSxLQUFLLENBQUMsT0FBTztZQUN0QixPQUFPLEVBQUUsS0FBSyxDQUFDLE9BQU87U0FDdkIsQ0FBQTtJQUNILENBQUMsQ0FBQyxDQUFBO0lBQ0YsTUFBTSxvQkFBb0IsR0FBRyxJQUFJLENBQUMsT0FBTyxDQUFDLFdBQVcsRUFBRSxFQUFFLGlCQUFpQixDQUFDLENBQUE7SUFDM0UsS0FBSyxDQUFDLG9CQUFvQixFQUFFLGdCQUFnQixDQUFDLENBQUE7SUFDN0MsTUFBTSxDQUFDLElBQUksQ0FBQyxXQUFXLGdCQUFnQixDQUFDLE1BQU0sMEJBQTBCLG9CQUFvQixFQUFFLENBQUMsQ0FBQTtBQUNqRyxDQUFDLENBQUEifQ==

packages/kbot/dist-in/commands/help.d.ts

@@ -0,0 +1,3 @@
+export declare const help: () => string;
+declare const _default: (argv: any) => Promise<string>;
+export default _default;

packages/kbot/dist-in/commands/help.js

@@ -0,0 +1,48 @@
+import { z } from 'zod';
+import { marked } from 'marked';
+import { markedTerminal } from 'marked-terminal';
+import { getDefaultValue, getDescription } from '@polymech/commons';
+import { OptionsSchema } from '../zod_schema.js';
+export const help = () => {
+    const schema = OptionsSchema();
+    const desc = schema._def.description;
+    const shape = schema.shape;
+    const md = [
+        '# KBot Command Line Interface',
+        '',
+        '```bash',
+        'kplus modify [prompt] [options]',
+        '```',
+        '',
+        '## Description',
+        '',
+        desc || 'KBot CLI Tool',
+        '',
+        '## Options',
+        ''
+    ];
+    // Process each parameter
+    for (const [key, def] of Object.entries(shape)) {
+        const isOptional = def instanceof z.ZodOptional;
+        const defaultValue = getDefaultValue(def);
+        const description = getDescription(def);
+        md.push(`--${key}`);
+        md.push('');
+        md.push(`Description: ${description}`);
+        if (defaultValue !== undefined) {
+            md.push(`Default: \`${JSON.stringify(defaultValue)}\``);
+        }
+        md.push(`Required: ${(!isOptional).toString()}`);
+        md.push('');
+    }
+    marked.use(markedTerminal({
+        emoji: false
+    }));
+    const content = marked(md.join('\n'));
+    process.stdout.write(content);
+    return content;
+};
+export default async (argv) => {
+    return help();
+};
+//# sourceMappingURL=data:application/json;base64,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

packages/kbot/dist-in/commands/init.d.ts

@@ -0,0 +1,2 @@
+import { IKBotTask } from '../types.js';
+export declare const init: (argv: IKBotTask) => Promise<number>;

packages/kbot/dist-in/commands/init.js

@@ -0,0 +1,105 @@
+import * as path from 'node:path';
+import { Logger } from 'tslog';
+import { sync as dir } from '@polymech/fs/dir';
+import { sync as exists } from '@polymech/fs/exists';
+import { sync as write } from '@polymech/fs/write';
+import { MODULE_NAME } from '../constants.js';
+const PREFERENCES_TEMPLATE = `# Personal Preferences
+
+This file stores personal information and preferences to help the AI assistant provide more personalized and contextual responses.
+
+## My Preferences
+
+Gender : 
+Location : 
+Language : 
+Occupation : 
+Age : 
+
+## Contacts
+
+My email address : 
+My wife's email address : 
+My second wife's email address : 
+
+## Content
+
+When creating content
+
+- always Markdown
+- always add links to sources
+- when searching for news, always add links to videos
+`;
+const CONFIG_TEMPLATE = {
+    "deepl": {
+        "auth_key": "YOUR_DEEPL_AUTH_KEY",
+        "free_api": false
+    },
+    "scaleserp": {
+        "key": "YOUR_SCALE_SERP_KEY"
+    },
+    "geocoder": {
+        "key": "YOUR_GEOCODER_KEY"
+    },
+    "serpapi": {
+        "key": "YOUR_SERPAPI_KEY"
+    },
+    "openai": {
+        "key": "YOUR_OPENAI_KEY"
+    },
+    "bigdata": {
+        "key": "YOUR_BIGDATA_KEY"
+    },
+    "novita": {
+        "key": "YOUR_NOVITA_KEY"
+    },
+    "perplexity": {
+        "key": "YOUR_PERPLEXITY_KEY"
+    },
+    "gemini": {
+        "key": "YOUR_GEMINI_KEY"
+    },
+    "openrouter": {
+        "key": "YOUR_OPENROUTER_KEY"
+    },
+    "deepseek": {
+        "key": "YOUR_DEEPSEEK_KEY"
+    },
+    "google": {
+        "cse": "YOUR_GOOGLE_CSE",
+        "api_key": "YOUR_GOOGLE_API_KEY"
+    }
+};
+export const init = async (argv) => {
+    const logger = new Logger({
+        hideLogPositionForProduction: true,
+        maskPlaceholder: '***',
+        name: MODULE_NAME,
+        prettyLogTemplate: "{{logLevelName}}\t[{{filePathWithLine}}{{name}}]\t",
+    });
+    const kbotDir = path.resolve(path.join(process.cwd(), `.${MODULE_NAME}`));
+    if (!exists(kbotDir)) {
+        dir(kbotDir);
+    }
+    // Create preferences file if it doesn't exist
+    const preferencesPath = path.resolve(kbotDir, 'preferences.md');
+    if (!exists(preferencesPath)) {
+        write(preferencesPath, PREFERENCES_TEMPLATE);
+        logger.info(`📋 Created preferences file: ${preferencesPath}`);
+    }
+    else {
+        logger.info(`📋 Preferences file already exists: ${preferencesPath}`);
+    }
+    // Create config file if it doesn't exist
+    const configPath = path.resolve(kbotDir, 'config.json');
+    if (!exists(configPath)) {
+        write(configPath, CONFIG_TEMPLATE);
+        logger.info(`📋 Created configuration file: ${configPath}`);
+    }
+    else {
+        logger.info(`📋 Configuration file already exists: ${configPath}`);
+    }
+    logger.info('📋 Initialization complete!');
+    return 0;
+};
+//# sourceMappingURL=data:application/json;base64,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

packages/kbot/dist-in/commands/run-assistant.d.ts

@@ -0,0 +1,6 @@
+import OpenAI from 'openai';
+import { IKBotTask } from '../types.js';
+export declare const createOpenAIFile: (client: OpenAI, filePath: string, purpose?: string) => Promise<OpenAI.Files.FileObject & {
+    _request_id?: string | null;
+}>;
+export declare const runAssistant: (client: OpenAI, params: any, options: IKBotTask) => Promise<any>;

packages/kbot/dist-in/commands/run-assistant.js

@@ -0,0 +1,173 @@
+import * as path from 'node:path';
+import * as fs from 'node:fs';
+import { logger } from '../index.js';
+import { onCompletion } from './run-completion.js';
+import { glob } from '../source.js';
+import { prompt } from '../prompt.js';
+const supported = {
+    ".c": "text/x-c",
+    ".cpp": "text/x-c++",
+    ".cs": "text/x-csharp",
+    ".css": "text/css",
+    ".doc": "application/msword",
+    ".docx": "application/vnd.openxmlformats-officedocument.wordprocessingml.document",
+    ".go": "text/x-golang",
+    ".html": "text/html",
+    ".java": "text/x-java",
+    ".js": "text/javascript",
+    ".json": "application/json",
+    ".md": "text/markdown",
+    ".pdf": "application/pdf",
+    ".php": "text/x-php",
+    ".pptx": "application/vnd.openxmlformats-officedocument.presentationml.presentation",
+    ".py": "text/x-python", // sometimes text/x-script.python
+    ".rb": "text/x-ruby",
+    ".sh": "application/x-sh",
+    ".tex": "text/x-tex",
+    ".ts": "application/typescript",
+    ".txt": "text/plain"
+};
+export const createOpenAIFile = async (client, filePath, purpose = 'assistants') => {
+    return client.files.create({
+        file: fs.createReadStream(filePath),
+        purpose: purpose
+    });
+};
+/*
+class EventHandler extends EventEmitter {
+  constructor(client) {
+    super();
+    // this.client = client;
+  }
+
+  async onEvent(event) {
+    try {
+      console.log(event);
+      // Retrieve events that are denoted with 'requires_action'
+      // since these will have our tool_calls
+      if (event.event === "thread.run.requires_action") {
+        await this.handleRequiresAction(
+          event.data,
+          event.data.id,
+          event.data.thread_id,
+        );
+      }
+    } catch (error) {
+      console.error("Error handling event:", error);
+    }
+  }
+
+  async handleRequiresAction(data, runId, threadId) {
+    try {
+      const toolOutputs =
+        data.required_action.submit_tool_outputs.tool_calls.map((toolCall) => {
+          if (toolCall.function.name === "getCurrentTemperature") {
+            return {
+              tool_call_id: toolCall.id,
+              output: "57",
+            };
+          } else if (toolCall.function.name === "getRainProbability") {
+            return {
+              tool_call_id: toolCall.id,
+              output: "0.06",
+            };
+          }
+        });
+      // Submit all the tool outputs at the same time
+      await this.submitToolOutputs(toolOutputs, runId, threadId);
+    } catch (error) {
+      console.error("Error processing required action:", error);
+    }
+  }
+
+  async submitToolOutputs(toolOutputs, runId, threadId) {
+    try {
+      // Use the submitToolOutputsStream helper
+      const stream = this.client.beta.threads.runs.submitToolOutputsStream(
+        threadId,
+        runId,
+        { tool_outputs: toolOutputs },
+      );
+      for await (const event of stream) {
+        this.emit("event", event);
+      }
+    } catch (error) {
+      console.error("Error submitting tool outputs:", error);
+    }
+  }
+}
+*/
+export const runAssistant = async (client, params, options) => {
+    const sessionId = Date.now().toString();
+    const sessionMessages = {
+        sessionId,
+        prompt: options.prompt,
+        timestamp: new Date().toISOString(),
+        messages: []
+    };
+    if (options.dry) {
+        logger.info('Dry run - skipping API call');
+        return {
+            result: 'DRY RUN',
+            sessionMessages,
+            result_raw: {},
+            toolCalls: []
+        };
+    }
+    const logMessage = (message, sessionId, prompt) => {
+        return {
+            ...message,
+            timestamp: new Date().toISOString(),
+            sessionId,
+            prompt
+        };
+    };
+    let result = null;
+    const prompt_ = await prompt(options);
+    const assistant = await client.beta.assistants.create({
+        name: "Documents Assistant",
+        model: params.model,
+        tools: [{ type: "file_search" }, ...params.tools],
+    });
+    let files = glob(path.resolve(options.path), options.include) || [];
+    files = files.filter((f) => path.extname(f) in supported);
+    const attachments = await Promise.all(files.map(async (file) => {
+        const file_id = await createOpenAIFile(client, file);
+        return {
+            file_id: file_id.id,
+            tools: [{ type: "file_search" }]
+        };
+    }));
+    const thread = await client.beta.threads.create({
+        messages: [
+            {
+                role: "user",
+                content: prompt_.content,
+                attachments: attachments,
+            }
+        ],
+    });
+    let defer;
+    try {
+        defer = new Promise((resolve, reject) => {
+            const stream = client.beta.threads.runs
+                .stream(thread.id, {
+                assistant_id: assistant.id,
+            })
+                //.on("textCreated", (args) => logger.trace("assistant >",args))
+                .on("toolCallCreated", (event) => logger.debug("Assistant : " + event.type))
+                .on("messageDone", async (event) => {
+                if (event.content[0].type === "text") {
+                    resolve(event.content[0]);
+                }
+            });
+            return stream;
+        });
+    }
+    catch (e) {
+        logger.error(`Failed to run assistant: ${e.message}`, e.message);
+    }
+    const ret = await defer;
+    return await onCompletion(ret.text.value, options);
+};
+//# sourceMappingURL=data:application/json;base64,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

packages/kbot/dist-in/commands/run-completion.d.ts

@@ -0,0 +1,4 @@
+import { IKBotTask } from '../types.js';
+import OpenAI from 'openai';
+export declare const onCompletion: (result: any, options: IKBotTask) => Promise<any>;
+export declare const runCompletion: (client: OpenAI, params: any, options: IKBotTask) => Promise<string | false>;

packages/kbot/dist-in/commands/run-completion.js

@@ -0,0 +1,46 @@
+import { marked } from 'marked';
+import { markedTerminal } from 'marked-terminal';
+import * as path from 'node:path';
+import { sync as write } from '@polymech/fs/write';
+import { resolve } from '@polymech/commons';
+import { logger } from '../index.js';
+import { dumpAsScript } from '../utils/script.js';
+import { applyFilters } from '../filters.js';
+import { variables } from '../variables.js';
+export const onCompletion = async (result = "", options) => {
+    result = applyFilters(result, options.filters || []);
+    const vars = variables(options);
+    if (options.dst) {
+        const dstPath = path.resolve(resolve(options.dst, false, {
+            ...vars,
+            MODEL: path.parse(options.model).name,
+            ROUTER: options.router,
+        }));
+        write(dstPath, result);
+        logger.debug(`Wrote completion result to ${dstPath} : ${options.dst}`);
+    }
+    else {
+        marked.use(markedTerminal({
+            emoji: false,
+        }));
+        const content = marked(result);
+        process.stdout.write(content);
+    }
+    dumpAsScript(options);
+    // process.exit(0)
+    return result;
+};
+export const runCompletion = async (client, params, options) => {
+    if (options.dry) {
+        logger.info('Dry run - skipping API call');
+        return false;
+    }
+    const completion = await client.chat.completions.create({
+        model: options.model,
+        messages: params.messages,
+    });
+    const result = completion.choices[0].message.content;
+    onCompletion(result, options);
+    return result;
+};
+//# sourceMappingURL=data:application/json;base64,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

packages/kbot/dist-in/commands/run-tools.d.ts

@@ -0,0 +1,3 @@
+import { IKBotTask } from '../types.js';
+import OpenAI from 'openai';
+export declare const runTools: (client: OpenAI, params: any, options: IKBotTask) => Promise<any>;

packages/kbot/dist-in/commands/run-tools.js

@@ -0,0 +1,62 @@
+import { content } from '../utils/content.js';
+import { logger } from '../index.js';
+import { onCompletion } from './run-completion.js';
+export const runTools = async (client, params, options) => {
+    const sessionId = Date.now().toString();
+    const sessionMessages = {
+        sessionId,
+        prompt: options.prompt,
+        timestamp: new Date().toISOString(),
+        messages: []
+    };
+    if (options.dry) {
+        logger.info('Dry run - skipping API call');
+        return {
+            result: 'DRY RUN',
+            sessionMessages,
+            result_raw: {},
+            toolCalls: []
+        };
+    }
+    const logMessage = (message, sessionId, prompt) => {
+        return {
+            ...message,
+            timestamp: new Date().toISOString(),
+            sessionId,
+            prompt
+        };
+    };
+    let runner = null;
+    try {
+        runner = await client.beta.chat.completions.runTools(params)
+            .on('message', (message) => {
+            options.collector.onMessage(logMessage(message, sessionId, options.prompt));
+        })
+            .on('functionCall', (tool) => {
+            return options.collector.onToolCall(logMessage(tool, sessionId, options.prompt));
+        })
+            .on('functionCallResult', (a) => {
+            options.collector.onFunctionCallResult(a);
+        })
+            .on('chatCompletion', options.collector.onChatCompletion)
+            .on('content', options.collector.onContent);
+    }
+    catch (e) {
+        logger.trace(e);
+    }
+    let result = content(runner);
+    try {
+        result = await runner.finalChatCompletion();
+    }
+    catch (error) {
+        if (error.message.includes("(reading 'map')")) {
+            logger.error('Failed to complete runner: credits :)', error.message, error.message, error);
+            return;
+        }
+        logger.error('Failed to complete runner:', error.message, error.issues);
+        return;
+    }
+    const ret = content(result);
+    return await onCompletion(ret, options);
+};
+//# sourceMappingURL=data:application/json;base64,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

packages/kbot/dist-in/commands/run.d.ts

@@ -0,0 +1,3 @@
+import { IKBotTask } from '@polymech/ai-tools';
+export declare const processRun: (opts: IKBotTask) => Promise<any>;
+export declare const run: (opts: IKBotTask) => Promise<any[]>;

packages/kbot/dist-in/index.d.ts

@@ -1,3 +1,4 @@
 export declare const logger: any;
+export { run } from './commands/run.js';
 export declare const module_root: () => string;
 export declare const assistant_supported: Record<string, string>;

packages/kbot/dist-in/index.js

@@ -1,10 +1,11 @@
+import { platform } from 'node:process';
 import path from 'path';
+const isWindows = platform === 'win32';
 import { createLogger } from '@polymech/log';
 import { get_var } from '@polymech/commons';
 import { MODULE_NAME } from './constants.js';
 export const logger = createLogger('llm-tools');
-//export { run } from './commands/run.js'
-const isWindows = process.platform === 'win32';
+export { run } from './commands/run.js';
 export const module_root = () => path.resolve(path.join(get_var(isWindows ? 'HOMEPATH' : 'HOME'), `.${MODULE_NAME}`));
 export const assistant_supported = {
     ".c": "text/x-c",
@@ -29,4 +30,4 @@ export const assistant_supported = {
     ".ts": "application/typescript",
     ".txt": "text/plain"
 };
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi9zcmMvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxJQUFJLE1BQU0sTUFBTSxDQUFBO0FBRXZCLE9BQU8sRUFBRSxZQUFZLEVBQUUsTUFBTSxlQUFlLENBQUE7QUFDNUMsT0FBTyxFQUFFLE9BQU8sRUFBRSxNQUFNLG1CQUFtQixDQUFBO0FBQzNDLE9BQU8sRUFBRSxXQUFXLEVBQUUsTUFBTSxnQkFBZ0IsQ0FBQTtBQUM1QyxNQUFNLENBQUMsTUFBTSxNQUFNLEdBQVEsWUFBWSxDQUFDLFdBQVcsQ0FBQyxDQUFBO0FBRXBELHlDQUF5QztBQUN6QyxNQUFNLFNBQVMsR0FBRyxPQUFPLENBQUMsUUFBUSxLQUFLLE9BQU8sQ0FBQTtBQUU5QyxNQUFNLENBQUMsTUFBTSxXQUFXLEdBQUcsR0FBRyxFQUFFLENBQUMsSUFBSSxDQUFDLE9BQU8sQ0FBQyxJQUFJLENBQUMsSUFBSSxDQUFDLE9BQU8sQ0FBQyxTQUFTLENBQUMsQ0FBQyxDQUFDLFVBQVUsQ0FBQyxDQUFDLENBQUMsTUFBTSxDQUFDLEVBQUUsSUFBSSxXQUFXLEVBQUUsQ0FBQyxDQUFDLENBQUE7QUFFckgsTUFBTSxDQUFDLE1BQU0sbUJBQW1CLEdBQTJCO0lBQ3pELElBQUksRUFBRSxVQUFVO0lBQ2hCLE1BQU0sRUFBRSxZQUFZO0lBQ3BCLEtBQUssRUFBRSxlQUFlO0lBQ3RCLE1BQU0sRUFBRSxVQUFVO0lBQ2xCLE1BQU0sRUFBRSxvQkFBb0I7SUFDNUIsT0FBTyxFQUFFLHlFQUF5RTtJQUNsRixLQUFLLEVBQUUsZUFBZTtJQUN0QixPQUFPLEVBQUUsV0FBVztJQUNwQixPQUFPLEVBQUUsYUFBYTtJQUN0QixLQUFLLEVBQUUsaUJBQWlCO0lBQ3hCLE9BQU8sRUFBRSxrQkFBa0I7SUFDM0IsS0FBSyxFQUFFLGVBQWU7SUFDdEIsTUFBTSxFQUFFLGlCQUFpQjtJQUN6QixNQUFNLEVBQUUsWUFBWTtJQUNwQixPQUFPLEVBQUUsMkVBQTJFO0lBQ3BGLEtBQUssRUFBRSxlQUFlO0lBQ3RCLEtBQUssRUFBRSxhQUFhO0lBQ3BCLEtBQUssRUFBRSxrQkFBa0I7SUFDekIsTUFBTSxFQUFFLFlBQVk7SUFDcEIsS0FBSyxFQUFFLHdCQUF3QjtJQUMvQixNQUFNLEVBQUUsWUFBWTtDQUNyQixDQUFDIn0=
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi9zcmMvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLFFBQVEsRUFBRSxNQUFNLGNBQWMsQ0FBQTtBQUN2QyxPQUFPLElBQUksTUFBTSxNQUFNLENBQUE7QUFFdkIsTUFBTSxTQUFTLEdBQUcsUUFBUSxLQUFLLE9BQU8sQ0FBQTtBQUV0QyxPQUFPLEVBQUUsWUFBWSxFQUFFLE1BQU0sZUFBZSxDQUFBO0FBQzVDLE9BQU8sRUFBRSxPQUFPLEVBQUUsTUFBTSxtQkFBbUIsQ0FBQTtBQUMzQyxPQUFPLEVBQUUsV0FBVyxFQUFFLE1BQU0sZ0JBQWdCLENBQUE7QUFFNUMsTUFBTSxDQUFDLE1BQU0sTUFBTSxHQUFRLFlBQVksQ0FBQyxXQUFXLENBQUMsQ0FBQTtBQUNwRCxPQUFPLEVBQUUsR0FBRyxFQUFFLE1BQU0sbUJBQW1CLENBQUE7QUFDdkMsTUFBTSxDQUFDLE1BQU0sV0FBVyxHQUFHLEdBQUcsRUFBRSxDQUFDLElBQUksQ0FBQyxPQUFPLENBQUMsSUFBSSxDQUFDLElBQUksQ0FBQyxPQUFPLENBQUMsU0FBUyxDQUFDLENBQUMsQ0FBQyxVQUFVLENBQUMsQ0FBQyxDQUFDLE1BQU0sQ0FBQyxFQUFFLElBQUksV0FBVyxFQUFFLENBQUMsQ0FBQyxDQUFBO0FBQ3JILE1BQU0sQ0FBQyxNQUFNLG1CQUFtQixHQUEyQjtJQUN6RCxJQUFJLEVBQUUsVUFBVTtJQUNoQixNQUFNLEVBQUUsWUFBWTtJQUNwQixLQUFLLEVBQUUsZUFBZTtJQUN0QixNQUFNLEVBQUUsVUFBVTtJQUNsQixNQUFNLEVBQUUsb0JBQW9CO0lBQzVCLE9BQU8sRUFBRSx5RUFBeUU7SUFDbEYsS0FBSyxFQUFFLGVBQWU7SUFDdEIsT0FBTyxFQUFFLFdBQVc7SUFDcEIsT0FBTyxFQUFFLGFBQWE7SUFDdEIsS0FBSyxFQUFFLGlCQUFpQjtJQUN4QixPQUFPLEVBQUUsa0JBQWtCO0lBQzNCLEtBQUssRUFBRSxlQUFlO0lBQ3RCLE1BQU0sRUFBRSxpQkFBaUI7SUFDekIsTUFBTSxFQUFFLFlBQVk7SUFDcEIsT0FBTyxFQUFFLDJFQUEyRTtJQUNwRixLQUFLLEVBQUUsZUFBZTtJQUN0QixLQUFLLEVBQUUsYUFBYTtJQUNwQixLQUFLLEVBQUUsa0JBQWtCO0lBQ3pCLE1BQU0sRUFBRSxZQUFZO0lBQ3BCLEtBQUssRUFBRSx3QkFBd0I7SUFDL0IsTUFBTSxFQUFFLFlBQVk7Q0FDckIsQ0FBQSJ9

packages/kbot/dist-in/main.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export declare const logger: any;

packages/kbot/dist-in/main.js

@@ -0,0 +1,41 @@
+#!/usr/bin/env node
+import yargs from 'yargs';
+import { hideBin } from 'yargs/helpers';
+import { toYargs } from '@polymech/commons';
+import { createLogger } from '@polymech/log';
+import { OptionsSchema, types } from './zod_schema.js';
+import helpCommand from './commands/help.js';
+import { examples } from './commands/examples.js';
+import { init } from './commands/init.js';
+import { build } from './commands/build.js';
+import { fetch } from './commands/fetch.js';
+import { run } from './commands/run.js';
+export const logger = createLogger('llm-tools');
+const modify = async (argv) => await run(argv);
+const yargOptions = {
+    onKey: ((_yargs, key, options) => {
+        switch (key) {
+            case 'prompt':
+                {
+                    return _yargs.positional(key, options);
+                }
+            case 'include':
+                {
+                    return _yargs.option(key, { ...options, alias: key[0].toLowerCase() });
+                }
+        }
+    })
+};
+yargs(hideBin(process.argv))
+    .command('init', 'Initialize KBot configuration', (yargs) => toYargs(yargs, OptionsSchema(), yargOptions), init)
+    .command('modify [prompt]', 'Modify an existing project', (yargs) => toYargs(yargs, OptionsSchema(), yargOptions), modify)
+    .command('types', 'Generate types', (yargs) => { }, (argv) => types())
+    .command('build', 'Build kbot essentials', (yargs) => { }, (argv) => build())
+    .command('fetch', "Fetch models, to $HOME/.kbot/", (yargs) => { }, (argv) => fetch())
+    .command('help-md', 'Generate markdown help', (yargs) => { }, helpCommand)
+    .command('examples', 'Show examples', (yargs) => { }, examples)
+    .command(['modify [prompt]', '$0'], 'Default command modify', (yargs) => toYargs(yargs, OptionsSchema(), yargOptions), modify)
+    .help()
+    .wrap(yargs.terminalWidth() - 20)
+    .parse();
+//# sourceMappingURL=data:application/json;base64,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

packages/kbot/dist-in/mime-handlers.js

@@ -1,4 +1,4 @@
-import * as path from 'path';
+import * as path from 'node:path';
 import { sync as read } from '@polymech/fs/read';
 import { base64 } from './source.js';
 export class ImageHandler {
@@ -52,4 +52,4 @@ export const defaultMimeRegistry = new MimeHandlerRegistry();
 defaultMimeRegistry.registerHandler('image/*', new ImageHandler());
 defaultMimeRegistry.registerHandler('application/pdf', new PDFHandler());
 defaultMimeRegistry.registerHandler('text/*', new TextHandler());
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

packages/kbot/dist-in/models/openai.js

@@ -1,4 +1,4 @@
-import { OpenAI } from 'openai';
+import OpenAI from 'openai';
 import * as path from 'node:path';
 import { sync as exists } from '@polymech/fs/exists';
 import { sync as read } from '@polymech/fs/read';
@@ -53,4 +53,4 @@ export function listModelsAsStrings(models) {
     models = models.sort((a, b) => a.id.localeCompare(b.id));
     return models.map((model) => `${model.id}`);
 }
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

packages/kbot/dist-in/prompt.js

@@ -23,4 +23,4 @@ export const preferences = async (opts) => {
         content: `USER Preferences : ${preferences}` || ''
     };
 };
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHJvbXB0LmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vc3JjL3Byb21wdC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFHQSxPQUFPLEVBQUUsSUFBSSxJQUFJLElBQUksRUFBRSxNQUFNLG1CQUFtQixDQUFBO0FBQ2hELE9BQU8sRUFBRSxJQUFJLElBQUksTUFBTSxFQUFFLE1BQU0scUJBQXFCLENBQUE7QUFDcEQsT0FBTyxFQUFFLE9BQU8sRUFBRSxNQUFNLG1CQUFtQixDQUFBO0FBQzNDLE9BQU8sS0FBSyxJQUFJLE1BQU0sV0FBVyxDQUFBO0FBRWpDLE9BQU8sRUFBRSxZQUFZLEVBQUUsTUFBTSxrQkFBa0IsQ0FBQTtBQUMvQyxPQUFPLEVBQUUsUUFBUSxFQUFFLE1BQU0sZ0JBQWdCLENBQUE7QUFDekMsT0FBTyxFQUFFLHFCQUFxQixFQUFFLE1BQU0sZ0JBQWdCLENBQUE7QUFFdEQsTUFBTSxDQUFDLE1BQU0sTUFBTSxHQUFHLEtBQUssRUFBRSxJQUFlLEVBQW1ELEVBQUU7SUFDN0YsTUFBTSxLQUFLLEdBQUcsTUFBTSxZQUFZLENBQUMsSUFBSSxDQUFDLENBQUE7SUFDdEMsT0FBTztRQUNILElBQUksRUFBRSxNQUFNO1FBQ1osT0FBTyxFQUFFLEtBQUssSUFBSSxFQUFFO0tBQ3ZCLENBQUE7QUFDTCxDQUFDLENBQUE7QUFFRCxNQUFNLENBQUMsTUFBTSxXQUFXLEdBQUcsS0FBSyxFQUFFLElBQWUsRUFBbUQsRUFBRTtJQUNsRyxJQUFJLGVBQWUsR0FBRyxJQUFJLENBQUMsT0FBTyxDQUFDLE9BQU8sQ0FBQyxJQUFJLENBQUMsV0FBVyxFQUFFLEtBQUssRUFBRSxRQUFRLEVBQUUsQ0FBQyxDQUFDLENBQUE7SUFDaEYsSUFBRyxDQUFDLE1BQU0sQ0FBQyxlQUFlLENBQUMsRUFBRSxDQUFDO1FBQzFCLGVBQWUsR0FBSSxJQUFJLENBQUMsT0FBTyxDQUFDLElBQUksQ0FBQyxJQUFJLENBQUMsT0FBTyxDQUFDLEdBQUcsRUFBRSxFQUFHLHFCQUFxQixDQUFDLENBQUMsQ0FBQTtJQUNyRixDQUFDO0lBQ0QsTUFBTSxXQUFXLEdBQUcsSUFBSSxDQUFDLGVBQWUsRUFBRSxRQUFRLENBQVcsQ0FBQTtJQUM3RCxPQUFPO1FBQ0gsSUFBSSxFQUFFLE1BQU07UUFDWixPQUFPLEVBQUUsc0JBQXNCLFdBQVcsRUFBRSxJQUFJLEVBQUU7S0FDckQsQ0FBQTtBQUNMLENBQUMsQ0FBQSJ9
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHJvbXB0LmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vc3JjL3Byb21wdC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFJQSxPQUFPLEVBQUUsSUFBSSxJQUFJLElBQUksRUFBRSxNQUFNLG1CQUFtQixDQUFBO0FBQ2hELE9BQU8sRUFBRSxJQUFJLElBQUksTUFBTSxFQUFFLE1BQU0scUJBQXFCLENBQUE7QUFDcEQsT0FBTyxFQUFFLE9BQU8sRUFBRSxNQUFNLG1CQUFtQixDQUFBO0FBQzNDLE9BQU8sS0FBSyxJQUFJLE1BQU0sV0FBVyxDQUFBO0FBRWpDLE9BQU8sRUFBRSxZQUFZLEVBQUUsTUFBTSxrQkFBa0IsQ0FBQTtBQUMvQyxPQUFPLEVBQUUsUUFBUSxFQUFFLE1BQU0sZ0JBQWdCLENBQUE7QUFDekMsT0FBTyxFQUFFLHFCQUFxQixFQUFFLE1BQU0sZ0JBQWdCLENBQUE7QUFFdEQsTUFBTSxDQUFDLE1BQU0sTUFBTSxHQUFHLEtBQUssRUFBRSxJQUFlLEVBQW1ELEVBQUU7SUFDN0YsTUFBTSxLQUFLLEdBQUcsTUFBTSxZQUFZLENBQUMsSUFBSSxDQUFDLENBQUE7SUFDdEMsT0FBTztRQUNILElBQUksRUFBRSxNQUFNO1FBQ1osT0FBTyxFQUFFLEtBQUssSUFBSSxFQUFFO0tBQ3ZCLENBQUE7QUFDTCxDQUFDLENBQUE7QUFFRCxNQUFNLENBQUMsTUFBTSxXQUFXLEdBQUcsS0FBSyxFQUFFLElBQWUsRUFBbUQsRUFBRTtJQUNsRyxJQUFJLGVBQWUsR0FBRyxJQUFJLENBQUMsT0FBTyxDQUFDLE9BQU8sQ0FBQyxJQUFJLENBQUMsV0FBVyxFQUFFLEtBQUssRUFBRSxRQUFRLEVBQUUsQ0FBQyxDQUFDLENBQUE7SUFDaEYsSUFBRyxDQUFDLE1BQU0sQ0FBQyxlQUFlLENBQUMsRUFBRSxDQUFDO1FBQzFCLGVBQWUsR0FBSSxJQUFJLENBQUMsT0FBTyxDQUFDLElBQUksQ0FBQyxJQUFJLENBQUMsT0FBTyxDQUFDLEdBQUcsRUFBRSxFQUFHLHFCQUFxQixDQUFDLENBQUMsQ0FBQTtJQUNyRixDQUFDO0lBQ0QsTUFBTSxXQUFXLEdBQUcsSUFBSSxDQUFDLGVBQWUsRUFBRSxRQUFRLENBQVcsQ0FBQTtJQUM3RCxPQUFPO1FBQ0gsSUFBSSxFQUFFLE1BQU07UUFDWixPQUFPLEVBQUUsc0JBQXNCLFdBQVcsRUFBRSxJQUFJLEVBQUU7S0FDckQsQ0FBQTtBQUNMLENBQUMsQ0FBQSJ9

packages/kbot/dist-in/utils/array.d.ts

@@ -0,0 +1 @@
+export declare const flatten: (value: string | string[] | undefined) => string[];

packages/kbot/dist-in/utils/array.js

@@ -0,0 +1,26 @@
+export const flatten = (value) => {
+    let initialArray;
+    if (typeof value === "string") {
+        initialArray = value.split(",");
+    }
+    else if (Array.isArray(value)) {
+        initialArray = value.filter((item) => typeof item === "string");
+    }
+    else {
+        initialArray = [];
+    }
+    // 2. Split on commas within each array element, then trim
+    const expanded = initialArray.reduce((acc, str) => {
+        const parts = str.split(",").map((s) => s.trim());
+        return acc.concat(parts);
+    }, []);
+    const filtered = expanded.filter((item) => {
+        if (item === "true" || item === "false")
+            return false;
+        if (!isNaN(Number(item)))
+            return false;
+        return true;
+    });
+    return Array.from(new Set(filtered));
+};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYXJyYXkuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvdXRpbHMvYXJyYXkudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsTUFBTSxDQUFDLE1BQU0sT0FBTyxHQUFHLENBQUMsS0FBb0MsRUFBWSxFQUFFO0lBQ3hFLElBQUksWUFBc0IsQ0FBQTtJQUMxQixJQUFJLE9BQU8sS0FBSyxLQUFLLFFBQVEsRUFBRSxDQUFDO1FBQzlCLFlBQVksR0FBRyxLQUFLLENBQUMsS0FBSyxDQUFDLEdBQUcsQ0FBQyxDQUFBO0lBQ2pDLENBQUM7U0FBTSxJQUFJLEtBQUssQ0FBQyxPQUFPLENBQUMsS0FBSyxDQUFDLEVBQUUsQ0FBQztRQUNoQyxZQUFZLEdBQUcsS0FBSyxDQUFDLE1BQU0sQ0FBQyxDQUFDLElBQUksRUFBa0IsRUFBRSxDQUFDLE9BQU8sSUFBSSxLQUFLLFFBQVEsQ0FBQyxDQUFBO0lBQ2pGLENBQUM7U0FBTSxDQUFDO1FBQ04sWUFBWSxHQUFHLEVBQUUsQ0FBQTtJQUNuQixDQUFDO0lBRUQsMERBQTBEO0lBQzFELE1BQU0sUUFBUSxHQUFHLFlBQVksQ0FBQyxNQUFNLENBQVcsQ0FBQyxHQUFHLEVBQUUsR0FBRyxFQUFFLEVBQUU7UUFDMUQsTUFBTSxLQUFLLEdBQUcsR0FBRyxDQUFDLEtBQUssQ0FBQyxHQUFHLENBQUMsQ0FBQyxHQUFHLENBQUMsQ0FBQyxDQUFDLEVBQUUsRUFBRSxDQUFDLENBQUMsQ0FBQyxJQUFJLEVBQUUsQ0FBQyxDQUFBO1FBQ2pELE9BQU8sR0FBRyxDQUFDLE1BQU0sQ0FBQyxLQUFLLENBQUMsQ0FBQTtJQUMxQixDQUFDLEVBQUUsRUFBRSxDQUFDLENBQUE7SUFFTixNQUFNLFFBQVEsR0FBRyxRQUFRLENBQUMsTUFBTSxDQUFDLENBQUMsSUFBSSxFQUFFLEVBQUU7UUFDeEMsSUFBSSxJQUFJLEtBQUssTUFBTSxJQUFJLElBQUksS0FBSyxPQUFPO1lBQUUsT0FBTyxLQUFLLENBQUE7UUFDckQsSUFBSSxDQUFDLEtBQUssQ0FBQyxNQUFNLENBQUMsSUFBSSxDQUFDLENBQUM7WUFBRSxPQUFPLEtBQUssQ0FBQTtRQUN0QyxPQUFPLElBQUksQ0FBQTtJQUNiLENBQUMsQ0FBQyxDQUFBO0lBQ0YsT0FBTyxLQUFLLENBQUMsSUFBSSxDQUFDLElBQUksR0FBRyxDQUFDLFFBQVEsQ0FBQyxDQUFDLENBQUM7QUFDdkMsQ0FBQyxDQUFBIn0=

packages/kbot/dist-in/utils/content.d.ts

@@ -0,0 +1 @@
+export declare const content: (result: any) => string;

packages/kbot/dist-in/utils/content.js

@@ -0,0 +1,4 @@
+export const content = (result) => {
+    return result?.choices?.[0]?.message?.content || "";
+};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY29udGVudC5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy91dGlscy9jb250ZW50LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE1BQU0sQ0FBQyxNQUFNLE9BQU8sR0FBRyxDQUFDLE1BQVcsRUFBVSxFQUFFO0lBQzNDLE9BQU8sTUFBTSxFQUFFLE9BQU8sRUFBRSxDQUFDLENBQUMsQ0FBQyxFQUFFLE9BQU8sRUFBRSxPQUFPLElBQUksRUFBRSxDQUFBO0FBQ3ZELENBQUMsQ0FBQSJ9

packages/kbot/dist-in/utils/script.d.ts

@@ -0,0 +1,2 @@
+import { IKBotOptions } from '../zod_types.js';
+export declare const dumpAsScript: (opts: IKBotOptions) => Promise<void>;

packages/kbot/dist-in/utils/script.js

@@ -0,0 +1,22 @@
+import * as path from 'node:path';
+import { sync as write } from '@polymech/fs/write';
+import { resolve } from '@polymech/commons';
+export const dumpAsScript = async (opts) => {
+    if (!opts.dump) {
+        return;
+    }
+    const args = process.argv.slice(2).filter(a => !a.includes('--dump'));
+    const scriptPath = path.resolve(resolve(opts.dump, false, {}));
+    // Quote all parameter values
+    const quotedArgs = args.map(arg => {
+        if (arg.includes('=')) {
+            const [key, ...values] = arg.split('=');
+            const value = values.join('=');
+            return `${key}="${value}"`;
+        }
+        return arg;
+    });
+    const script = `kbot ${quotedArgs.join(' ')}`;
+    write(scriptPath, script);
+};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic2NyaXB0LmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vc3JjL3V0aWxzL3NjcmlwdC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEtBQUssSUFBSSxNQUFNLFdBQVcsQ0FBQTtBQUNqQyxPQUFPLEVBQUUsSUFBSSxJQUFJLEtBQUssRUFBRSxNQUFNLG9CQUFvQixDQUFBO0FBQ2xELE9BQU8sRUFBRSxPQUFPLEVBQUUsTUFBTSxtQkFBbUIsQ0FBQTtBQUczQyxNQUFNLENBQUMsTUFBTSxZQUFZLEdBQUcsS0FBSyxFQUFFLElBQWtCLEVBQUUsRUFBRTtJQUN2RCxJQUFJLENBQUMsSUFBSSxDQUFDLElBQUksRUFBRSxDQUFDO1FBQ2YsT0FBTTtJQUNSLENBQUM7SUFDRCxNQUFNLElBQUksR0FBRyxPQUFPLENBQUMsSUFBSSxDQUFDLEtBQUssQ0FBQyxDQUFDLENBQUMsQ0FBQyxNQUFNLENBQUMsQ0FBQyxDQUFDLEVBQUUsQ0FBQyxDQUFDLENBQUMsQ0FBQyxRQUFRLENBQUMsUUFBUSxDQUFDLENBQUMsQ0FBQTtJQUNyRSxNQUFNLFVBQVUsR0FBRyxJQUFJLENBQUMsT0FBTyxDQUFDLE9BQU8sQ0FBQyxJQUFJLENBQUMsSUFBSSxFQUFFLEtBQUssRUFBRSxFQUFFLENBQUMsQ0FBQyxDQUFBO0lBQzlELDZCQUE2QjtJQUM3QixNQUFNLFVBQVUsR0FBRyxJQUFJLENBQUMsR0FBRyxDQUFDLEdBQUcsQ0FBQyxFQUFFO1FBQ2hDLElBQUksR0FBRyxDQUFDLFFBQVEsQ0FBQyxHQUFHLENBQUMsRUFBRSxDQUFDO1lBQ3RCLE1BQU0sQ0FBQyxHQUFHLEVBQUUsR0FBRyxNQUFNLENBQUMsR0FBRyxHQUFHLENBQUMsS0FBSyxDQUFDLEdBQUcsQ0FBQyxDQUFBO1lBQ3ZDLE1BQU0sS0FBSyxHQUFHLE1BQU0sQ0FBQyxJQUFJLENBQUMsR0FBRyxDQUFDLENBQUE7WUFDOUIsT0FBTyxHQUFHLEdBQUcsS0FBSyxLQUFLLEdBQUcsQ0FBQTtRQUM1QixDQUFDO1FBQ0QsT0FBTyxHQUFHLENBQUE7SUFDWixDQUFDLENBQUMsQ0FBQTtJQUNGLE1BQU0sTUFBTSxHQUFHLFFBQVEsVUFBVSxDQUFDLElBQUksQ0FBQyxHQUFHLENBQUMsRUFBRSxDQUFBO0lBQzdDLEtBQUssQ0FBQyxVQUFVLEVBQUUsTUFBTSxDQUFDLENBQUE7QUFDM0IsQ0FBQyxDQUFBIn0=

packages/kbot/dist-in/variables.d.ts

@@ -1,2 +1,2 @@
-import { IKBotTask } from './types';
+import { IKBotTask } from './types.js';
 export declare const variables: (options: IKBotTask) => any;

packages/kbot/package-lock.json

@@ -27,7 +27,7 @@
         "p-map": "7.0.3",
         "tslog": "^4.9.3",
         "yargs": "17.7.2",
-        "zod": "3.24.1"
+        "zod": "3.24.2"
       },
       "bin": {
         "kbot-d": "main.js"
@@ -112,13 +112,14 @@
         "env-var": "^7.5.0",
         "glob": "^10.4.5",
         "js-yaml": "^4.1.0",
-        "jsonpath-plus": "^8.1.0",
+        "jsonpath-plus": "^10.3.0",
         "normalize-url": "^8.0.1",
         "p-map": "^7.0.3",
         "p-throttle": "^4.1.1",
         "tslog": "^3.3.3",
-        "tsup": "^8.3.5",
+        "tsup": "^2.0.3",
         "yargs": "^17.7.2",
+        "zod": "^3.24.2",
         "zod-to-json-schema": "^3.24.1",
         "zod-to-ts": "^1.2.0"
       },
@@ -7505,9 +7506,9 @@
       }
     },
     "node_modules/zod": {
-      "version": "3.24.1",
-      "resolved": "https://registry.npmjs.org/zod/-/zod-3.24.1.tgz",
-      "integrity": "sha512-muH7gBL9sI1nciMZV67X5fTKKBLtwpZ5VBp1vsOQzj1MhrBZ4wlVCm3gedKZWLp0Oyel8sIGfeiz54Su+OVT+A==",
+      "version": "3.24.2",
+      "resolved": "https://registry.npmjs.org/zod/-/zod-3.24.2.tgz",
+      "integrity": "sha512-lY7CDW43ECgW9u1TcT3IoXHflywfVqDYze4waEz812jR/bZ8FHDsl7pFQoSZTz5N+2NqRXs8GBwnAwo3ZNxqhQ==",
       "license": "MIT",
       "funding": {
         "url": "https://github.com/sponsors/colinhacks"

packages/kbot/package.json

@@ -40,7 +40,7 @@
     "p-map": "7.0.3",
     "tslog": "^4.9.3",
     "yargs": "17.7.2",
-    "zod": "3.24.1"
+    "zod": "3.24.2"
   },
   "keywords": [
     "ai",

packages/kbot/src/client.ts

@@ -1,11 +1,7 @@
-import { OpenAI } from 'openai'
+import  OpenAI  from 'openai'
 import { logger } from './index.js'
 import { loadConfig } from './config.js'
 import { IKBotOptions } from './zod_types.js'
-/**
- * gemini : https://ai.google.dev/gemini-api/docs/openai
- */
-
 /**
  * Router types supported by the client
  */

packages/kbot/src/collector.ts

@@ -6,7 +6,6 @@ import { resolve } from '@polymech/commons'
 import { RunnableFunctionWithParse } from 'openai/lib/RunnableFunction'
 
 import { winstonLogger, } from '@polymech/ai-tools'
-
 import { IKBotOptions } from './zod_types.js'
 import { logger as loggerIntern } from './index.js'
 

packages/kbot/src/commands/help.ts

@@ -27,11 +27,9 @@ export const help = () => {
 
   // Process each parameter
   for (const [key, def] of Object.entries(shape)) {
-    const isOptional = def instanceof z.ZodOptional
-    
-    const defaultValue = getDefaultValue(def)
-    const description = getDescription(def)
-
+    const isOptional = def instanceof z.ZodOptional    
+    const defaultValue = getDefaultValue(def as any)
+    const description = getDescription(def as any)
     md.push(`--${key}`)
     md.push('')
     md.push(`Description: ${description}`)

packages/kbot/src/commands/run-assistant.ts

@@ -159,7 +159,7 @@ export const runAssistant = async (client: OpenAI, params: any, options: IKBotTa
         content: prompt_.content,
         attachments: attachments as any,
       }
-    ],
+    ] as any,
   })
 
   let defer
@@ -179,7 +179,7 @@ export const runAssistant = async (client: OpenAI, params: any, options: IKBotTa
       return stream
     })
   } catch (e) {
-    logger.error(`Failed to run assistant: ${e.message}`, error)
+    logger.error(`Failed to run assistant: ${e.message}`, e.message)
   }
   const ret = await defer
   return await onCompletion(ret.text.value, options)

packages/kbot/src/commands/run-completion.ts

@@ -1,4 +1,4 @@
-import { IKBotTask } from '../types'
+import { IKBotTask } from '../types.js'
 import OpenAI from 'openai'
 import { marked } from 'marked'
 import { markedTerminal } from 'marked-terminal'

packages/kbot/src/commands/run-tools.ts

@@ -1,4 +1,4 @@
-import { IKBotTask } from '../types'
+import { IKBotTask } from '../types.js'
 import OpenAI from 'openai'
 import { ChatCompletionMessage, ChatCompletionMessageParam } from 'openai/resources/index.mjs'
 import { ChatCompletionToolRunnerParams } from 'openai/lib/ChatCompletionRunner'

packages/kbot/src/index.ts

@@ -1,15 +1,15 @@
+import { platform } from 'node:process'
 import path from 'path'
 
+const isWindows = platform === 'win32'
+
 import { createLogger } from '@polymech/log'
 import { get_var } from '@polymech/commons'
 import { MODULE_NAME } from './constants.js'
+
 export const logger: any = createLogger('llm-tools')
-
-//export { run } from './commands/run.js'
-const isWindows = process.platform === 'win32'
-
+export { run } from './commands/run.js'
 export const module_root = () => path.resolve(path.join(get_var(isWindows ? 'HOMEPATH' : 'HOME'), `.${MODULE_NAME}`))
-
 export const assistant_supported: Record<string, string> = {
   ".c": "text/x-c",
   ".cpp": "text/x-c++",
@@ -32,4 +32,4 @@ export const assistant_supported: Record<string, string> = {
   ".tex": "text/x-tex",
   ".ts": "application/typescript",
   ".txt": "text/plain"
-};
+}

packages/kbot/src/main.ts

@@ -1,10 +1,8 @@
 #!/usr/bin/env node
 import yargs from 'yargs'
 import { hideBin } from 'yargs/helpers'
-
 import { toYargs } from '@polymech/commons'
 import { createLogger } from '@polymech/log'
-
 import { OptionsSchema, types } from './zod_schema.js'
 import { IKBotTask } from './types.js'
 

packages/kbot/src/models/openai.ts

@@ -1,4 +1,4 @@
-import { OpenAI } from 'openai'
+import OpenAI from 'openai'
 import * as path from 'node:path'
 import { sync as exists } from '@polymech/fs/exists'
 import { sync as read } from '@polymech/fs/read'

packages/kbot/src/prompt.ts

@@ -1,6 +1,7 @@
 import { IKBotTask } from '@polymech/ai-tools'
 
 import { ChatCompletionMessageParam } from 'openai/resources/index.mjs'
+
 import { sync as read } from '@polymech/fs/read'
 import { sync as exists } from '@polymech/fs/exists'
 import { resolve } from '@polymech/commons'

packages/kbot/src/zod_schema.ts

@@ -65,17 +65,181 @@ export { fetchOpenAIModels, listModelsAsStrings as listOpenAIModelsAsStrings } f
 
 export const OptionsSchema = (opts?: any): any => {
   let schemaMap: ZodMetaMap = ZodMetaMap.create<OptionsSchemaMeta>()
-  schemaMap
-  .add(
-    'dry',
-    z.union([
-      z.boolean(),
-      z.string().transform((val) => val.toLowerCase() === 'true')
-    ])
-      .optional()
-      .default(false)
-      .describe('Dry run - only write out parameters without making API calls')
-  );
+  schemaMap.add(
+    'path',
+    z.string()
+      .min(1)
+      .default('.')
+      .describe('Target directory')
+    , {'ui:widget': 'file'})
+    .add(
+      'prompt',
+      z.string()
+        .describe('The prompt. Supports file paths and environment variables.')
+        .default('./prompt.md')
+    )
+    .add(
+      'output',
+      z.string()
+        .optional()
+        .describe('Optional output path for modified files (Tool mode only)')
+    )
+    .add(
+      'dst',
+      z.string()
+        .optional()
+        .describe('Optional destination path for the result, will substitute ${MODEL_NAME} and ${ROUTER} in the path. Optional, used for "completion" mode')
+    )
+    .add(
+      'each',
+      z.string()
+        .optional()
+        .describe('Iterate over items, supported: GLOB | Path to JSON File | array of strings (comma separated). To test different models, use --each="gpt-3.5-turbo,gpt-4o", the actual string will exposed as variable `ITEM`, eg: --dst="${ITEM}-output.md"')
+    )
+    .add(
+      'disable',
+      z.array(z.string())
+        .default([])
+        .describe(`Disable tools categories, eg: --disable=${defaultTemplate.tools.join(',')}`)
+    )
+    .add(
+      'disableTools',
+      z.array(z.string())
+        .optional()
+        .default([])
+        .describe('List of specific tools to disable')
+    )
+    .add(
+      'tools',
+      z.union(
+        [
+          z.array(z.string()),
+          z.string()
+        ]).optional()
+        .default(defaultTemplate.tools)
+        .describe(`List of tools to use. Can be built-in tool names or paths to custom tool files. Default: ${defaultTemplate.tools.join(',')}`)
+        .transform((val) => Array.isArray(val) ? val : val.split(','))
+    )
+    .add(
+      'include',
+      z.array(z.string())
+        .optional()
+        .describe('Comma separated glob patterns or paths, eg --include=src/*.tsx,src/*.ts --include=package.json')
+    )
+    .add(
+      'api_key',
+      z.string()
+        .optional()
+        .describe('Explicit API key to use')
+    )
+    .add(
+      'model',
+      z.string()
+        .optional()
+        .describe(`AI model to use for processing. Available models:\n${models_dist().join('\n')}`)
+    )
+    .add(
+      'router',
+      z.string()
+        .default('openrouter')
+        .describe('Router to use: openai, openrouter or deepseek')
+    )
+    .add(
+      'mode',
+      EType
+        .default(EMode.TOOLS)
+        .describe(`Chat completion mode:\n\t completion, tools, assistant.
+          ${chalk.green.bold('completion')}: no support for tools, please use --dst parameter to save the output.
+          ${chalk.green.bold('tools')}: allows for tools to be used, eg 'save to ./output.md'. Not all models support this mode.
+          ${chalk.green.bold('assistant')}: : allows documents (PDF, DOCX, ...) to be added but dont support tools. Use --dst to save the output. Supported files :
+          ${chalk.green.bold('custom')}: custom mode
+      `)
+    )
+    .add(
+      'logLevel',
+      z.number()
+        .default(2)
+        .describe('Logging level for the application')
+    )
+    .add(
+      'profile',
+      z.string()
+        .optional()
+        .describe('Path to profile for variables. Supports environment variables.')
+    )
+    .add(
+      'baseURL',
+      z.string()
+        .optional()
+        .describe('Base URL for the API, set via --router or directly')
+    )
+    .add(
+      'config',
+      z.string()
+        .optional()
+        .describe('Path to JSON configuration file (API keys). Supports environment variables.')
+    )
+    .add(
+      'dump',
+      z.string()
+        .optional()
+        .describe('Create a script')
+    )
+    .add(
+      'preferences',
+      z.string()
+        .default(PREFERENCES_DEFAULT())
+        .describe('Path to preferences file, eg: location, your email address, gender, etc. Supports environment variables.')
+    )
+    .add(
+      'logs',
+      z.string()
+        .default(LOGGING_DIRECTORY)
+        .describe('Logging directory')
+    )
+    .add(
+      'env',
+      z.string()
+        .default('default')
+        .describe('Environment (in profile)')
+    )
+    // If "split" was relevant, re-add here:
+    // .add('split', SplitType.default('none').describe('Type of text splitter to use'))
+    .add(
+      'variables',
+      z.record(z.string(), z.string())
+        .optional()
+        .default({})
+    )
+    .add(
+      'filters',
+      z.union([
+        z.string(),
+        z.array(E_Filters),
+        z.array(z.string()),
+        z.array(z.function())
+      ])
+        .optional()
+        .default('')
+        .describe(`List of filters to apply to the output.
+         Used only in completion mode and a given output file specified with --dst. 
+         It unwraps by default any code or data in Markdown. 
+         Choices:\n\t${Object.keys(Filters)}\n`)
+        .transform((val) => {
+          const filters = isString(val) ? val.split(',') : val;
+          return filters.map((f: any) => Filters[f]).filter(Boolean);
+        })
+    )
+    .add(
+      'dry',
+      z.union([
+        z.boolean(),
+        z.string().transform((val) => val.toLowerCase() === 'true')
+      ])
+        .optional()
+        .default(false)
+        .describe('Dry run - only write out parameters without making API calls')
+    );
   return schemaMap.root()
     .passthrough()
     .describe('IKBotOptions')

packages/kbot/tsconfig.json

@@ -10,6 +10,7 @@
     "inlineSourceMap": true
   },
   "files": [
-    "src/zod_schema.ts"
+    "src/index.ts",
+    "src/main.ts"
   ]
 }