cast-code 1.0.0

package/dist/modules/tools/services/shell-tools.service.js

@@ -0,0 +1,194 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "ShellToolsService", {
+    enumerable: true,
+    get: function() {
+        return ShellToolsService;
+    }
+});
+const _common = require("@nestjs/common");
+const _tools = require("@langchain/core/tools");
+const _zod = require("zod");
+const _child_process = require("child_process");
+const _util = require("util");
+const _permissionservice = require("../../permissions/services/permission.service");
+const _promises = /*#__PURE__*/ _interop_require_wildcard(require("node:fs/promises"));
+const _path = /*#__PURE__*/ _interop_require_wildcard(require("path"));
+const _os = /*#__PURE__*/ _interop_require_wildcard(require("os"));
+function _getRequireWildcardCache(nodeInterop) {
+    if (typeof WeakMap !== "function") return null;
+    var cacheBabelInterop = new WeakMap();
+    var cacheNodeInterop = new WeakMap();
+    return (_getRequireWildcardCache = function(nodeInterop) {
+        return nodeInterop ? cacheNodeInterop : cacheBabelInterop;
+    })(nodeInterop);
+}
+function _interop_require_wildcard(obj, nodeInterop) {
+    if (!nodeInterop && obj && obj.__esModule) {
+        return obj;
+    }
+    if (obj === null || typeof obj !== "object" && typeof obj !== "function") {
+        return {
+            default: obj
+        };
+    }
+    var cache = _getRequireWildcardCache(nodeInterop);
+    if (cache && cache.has(obj)) {
+        return cache.get(obj);
+    }
+    var newObj = {
+        __proto__: null
+    };
+    var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor;
+    for(var key in obj){
+        if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) {
+            var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null;
+            if (desc && (desc.get || desc.set)) {
+                Object.defineProperty(newObj, key, desc);
+            } else {
+                newObj[key] = obj[key];
+            }
+        }
+    }
+    newObj.default = obj;
+    if (cache) {
+        cache.set(obj, newObj);
+    }
+    return newObj;
+}
+function _ts_decorate(decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for(var i = decorators.length - 1; i >= 0; i--)if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+function _ts_metadata(k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+}
+const execAsync = (0, _util.promisify)(_child_process.exec);
+let ShellToolsService = class ShellToolsService {
+    getTools() {
+        return [
+            this.createShellTool(),
+            this.createBackgroundShellTool()
+        ];
+    }
+    createShellTool() {
+        return (0, _tools.tool)(async ({ command, cwd, timeout, description })=>{
+            const allowed = await this.permissionService.checkPermission(command);
+            if (!allowed) {
+                return 'Command execution denied by user';
+            }
+            try {
+                const { stdout, stderr } = await execAsync(command, {
+                    cwd: cwd || process.cwd(),
+                    timeout: timeout || 120000,
+                    maxBuffer: 10 * 1024 * 1024
+                });
+                const output = stdout || stderr;
+                if (output.length > 30000) {
+                    return output.slice(0, 30000) + '\n... (truncated)';
+                }
+                return output || 'Command completed with no output';
+            } catch (error) {
+                const execError = error;
+                if (execError.stdout || execError.stderr) {
+                    return `Exit with error:\n${execError.stderr || execError.stdout}`;
+                }
+                return `Error: ${execError.message}`;
+            }
+        }, {
+            name: 'shell',
+            description: 'Execute a shell command with permission checking. Use for git, npm, docker, etc. Dangerous commands will require user approval.',
+            schema: _zod.z.object({
+                command: _zod.z.string().describe('Command to execute'),
+                cwd: _zod.z.string().optional().describe('Working directory'),
+                timeout: _zod.z.number().optional().describe('Timeout in ms (default 120000, max 600000)'),
+                description: _zod.z.string().optional().describe('Brief description of what this command does')
+            })
+        });
+    }
+    createBackgroundShellTool() {
+        return (0, _tools.tool)(async ({ command, cwd })=>{
+            const allowed = await this.permissionService.checkPermission(command);
+            if (!allowed) {
+                return 'Command execution denied by user';
+            }
+            const processId = `bg-${++this.processCounter}`;
+            const outputFile = _path.join(_os.tmpdir(), `cast-bg-${processId}.log`);
+            return new Promise((resolve)=>{
+                const logFd = require('fs').openSync(outputFile, 'w');
+                const child = (0, _child_process.spawn)(command, {
+                    cwd: cwd || process.cwd(),
+                    shell: true,
+                    detached: true,
+                    stdio: [
+                        'ignore',
+                        logFd,
+                        logFd
+                    ]
+                });
+                this.backgroundProcesses.set(processId, {
+                    process: child,
+                    command,
+                    outputFile,
+                    startedAt: Date.now()
+                });
+                child.unref();
+                require('fs').closeSync(logFd);
+                resolve(JSON.stringify({
+                    success: true,
+                    processId,
+                    outputFile,
+                    message: 'Command started in background. Use task_output to check progress.'
+                }));
+            });
+        }, {
+            name: 'shell_background',
+            description: 'Execute a command in background. Use for long-running tasks like dev servers, watch mode, builds.',
+            schema: _zod.z.object({
+                command: _zod.z.string().describe('Command to execute in background'),
+                cwd: _zod.z.string().optional().describe('Working directory')
+            })
+        });
+    }
+    async getBackgroundOutput(processId) {
+        const bgProcess = this.backgroundProcesses.get(processId);
+        if (!bgProcess) {
+            return 'Process not found';
+        }
+        try {
+            const content = await _promises.readFile(bgProcess.outputFile, 'utf-8');
+            return content || 'No output yet';
+        } catch (error) {
+            return 'Error reading output: ' + error.message;
+        }
+    }
+    killBackgroundProcess(processId) {
+        const bgProcess = this.backgroundProcesses.get(processId);
+        if (!bgProcess) return false;
+        try {
+            process.kill(-bgProcess.process.pid);
+            this.backgroundProcesses.delete(processId);
+            return true;
+        } catch  {
+            return false;
+        }
+    }
+    constructor(permissionService){
+        this.permissionService = permissionService;
+        this.backgroundProcesses = new Map();
+        this.processCounter = 0;
+    }
+};
+ShellToolsService = _ts_decorate([
+    (0, _common.Injectable)(),
+    _ts_metadata("design:type", Function),
+    _ts_metadata("design:paramtypes", [
+        typeof _permissionservice.PermissionService === "undefined" ? Object : _permissionservice.PermissionService
+    ])
+], ShellToolsService);
+
+//# sourceMappingURL=shell-tools.service.js.map

package/dist/modules/tools/services/shell-tools.service.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/modules/tools/services/shell-tools.service.ts"],"sourcesContent":["import { Injectable } from '@nestjs/common';\nimport { tool } from '@langchain/core/tools';\nimport { z } from 'zod';\nimport { exec, spawn } from 'child_process';\nimport { promisify } from 'util';\nimport { PermissionService } from '../../permissions/services/permission.service';\nimport * as fs from 'fs/promises';\nimport * as path from 'path';\nimport * as os from 'os';\n\nconst execAsync = promisify(exec);\n\ninterface ExecError extends Error {\n  stdout?: string;\n  stderr?: string;\n}\n\n@Injectable()\nexport class ShellToolsService {\n  private backgroundProcesses: Map<string, any> = new Map();\n  private processCounter = 0;\n\n  constructor(private permissionService: PermissionService) {}\n\n  getTools() {\n    return [this.createShellTool(), this.createBackgroundShellTool()];\n  }\n\n  private createShellTool() {\n    return tool(\n      async ({ command, cwd, timeout, description }) => {\n        const allowed = await this.permissionService.checkPermission(command);\n\n        if (!allowed) {\n          return 'Command execution denied by user';\n        }\n\n        try {\n          const { stdout, stderr } = await execAsync(command, {\n            cwd: cwd || process.cwd(),\n            timeout: timeout || 120000, // Default 2min, max 10min\n            maxBuffer: 10 * 1024 * 1024,\n          });\n\n          const output = stdout || stderr;\n\n          if (output.length > 30000) {\n            return output.slice(0, 30000) + '\\n... (truncated)';\n          }\n\n          return output || 'Command completed with no output';\n        } catch (error) {\n          const execError = error as ExecError;\n\n          if (execError.stdout || execError.stderr) {\n            return `Exit with error:\\n${execError.stderr || execError.stdout}`;\n          }\n\n          return `Error: ${execError.message}`;\n        }\n      },\n      {\n        name: 'shell',\n        description:\n          'Execute a shell command with permission checking. Use for git, npm, docker, etc. Dangerous commands will require user approval.',\n        schema: z.object({\n          command: z.string().describe('Command to execute'),\n          cwd: z.string().optional().describe('Working directory'),\n          timeout: z\n            .number()\n            .optional()\n            .describe('Timeout in ms (default 120000, max 600000)'),\n          description: z\n            .string()\n            .optional()\n            .describe('Brief description of what this command does'),\n        }),\n      },\n    );\n  }\n\n  private createBackgroundShellTool() {\n    return tool(\n      async ({ command, cwd }) => {\n        const allowed = await this.permissionService.checkPermission(command);\n\n        if (!allowed) {\n          return 'Command execution denied by user';\n        }\n\n        const processId = `bg-${++this.processCounter}`;\n        const outputFile = path.join(os.tmpdir(), `cast-bg-${processId}.log`);\n\n        return new Promise((resolve) => {\n          const logFd = require('fs').openSync(outputFile, 'w');\n\n          const child = spawn(command, {\n            cwd: cwd || process.cwd(),\n            shell: true,\n            detached: true,\n            stdio: ['ignore', logFd, logFd],\n          });\n\n          this.backgroundProcesses.set(processId, {\n            process: child,\n            command,\n            outputFile,\n            startedAt: Date.now(),\n          });\n\n          child.unref();\n          require('fs').closeSync(logFd);\n\n          resolve(\n            JSON.stringify({\n              success: true,\n              processId,\n              outputFile,\n              message: 'Command started in background. Use task_output to check progress.',\n            }),\n          );\n        });\n      },\n      {\n        name: 'shell_background',\n        description:\n          'Execute a command in background. Use for long-running tasks like dev servers, watch mode, builds.',\n        schema: z.object({\n          command: z.string().describe('Command to execute in background'),\n          cwd: z.string().optional().describe('Working directory'),\n        }),\n      },\n    );\n  }\n\n  async getBackgroundOutput(processId: string): Promise<string> {\n    const bgProcess = this.backgroundProcesses.get(processId);\n    if (!bgProcess) {\n      return 'Process not found';\n    }\n\n    try {\n      const content = await fs.readFile(bgProcess.outputFile, 'utf-8');\n      return content || 'No output yet';\n    } catch (error) {\n      return 'Error reading output: ' + (error as Error).message;\n    }\n  }\n\n  killBackgroundProcess(processId: string): boolean {\n    const bgProcess = this.backgroundProcesses.get(processId);\n    if (!bgProcess) return false;\n\n    try {\n      process.kill(-bgProcess.process.pid);\n      this.backgroundProcesses.delete(processId);\n      return true;\n    } catch {\n      return false;\n    }\n  }\n}\n"],"names":["ShellToolsService","execAsync","promisify","exec","getTools","createShellTool","createBackgroundShellTool","tool","command","cwd","timeout","description","allowed","permissionService","checkPermission","stdout","stderr","process","maxBuffer","output","length","slice","error","execError","message","name","schema","z","object","string","describe","optional","number","processId","processCounter","outputFile","path","join","os","tmpdir","Promise","resolve","logFd","require","openSync","child","spawn","shell","detached","stdio","backgroundProcesses","set","startedAt","Date","now","unref","closeSync","JSON","stringify","success","getBackgroundOutput","bgProcess","get","content","fs","readFile","killBackgroundProcess","kill","pid","delete","Map"],"mappings":"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"}

package/dist/modules/tools/services/tools-registry.service.js

@@ -0,0 +1,83 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "ToolsRegistryService", {
+    enumerable: true,
+    get: function() {
+        return ToolsRegistryService;
+    }
+});
+const _common = require("@nestjs/common");
+const _filesystemtoolsservice = require("./filesystem-tools.service");
+const _shelltoolsservice = require("./shell-tools.service");
+const _searchtoolsservice = require("./search-tools.service");
+const _tasktoolsservice = require("../../tasks/services/task-tools.service");
+const _memorytoolsservice = require("../../memory/services/memory-tools.service");
+function _ts_decorate(decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for(var i = decorators.length - 1; i >= 0; i--)if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+function _ts_metadata(k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+}
+function _ts_param(paramIndex, decorator) {
+    return function(target, key) {
+        decorator(target, key, paramIndex);
+    };
+}
+let ToolsRegistryService = class ToolsRegistryService {
+    registerBuiltInTools() {
+        const allTools = [
+            ...this.filesystemTools.getTools(),
+            ...this.shellTools.getTools(),
+            ...this.searchTools.getTools(),
+            ...this.taskTools.getTools(),
+            ...this.memoryTools.getTools()
+        ];
+        for (const t of allTools){
+            this.tools.set(t.name, t);
+        }
+    }
+    getTool(name) {
+        return this.tools.get(name);
+    }
+    getTools(names) {
+        return names.map((name)=>this.tools.get(name)).filter((t)=>t !== undefined);
+    }
+    getAllTools() {
+        return Array.from(this.tools.values());
+    }
+    getToolNames() {
+        return Array.from(this.tools.keys());
+    }
+    registerTool(t) {
+        this.tools.set(t.name, t);
+    }
+    constructor(filesystemTools, shellTools, searchTools, taskTools, memoryTools){
+        this.filesystemTools = filesystemTools;
+        this.shellTools = shellTools;
+        this.searchTools = searchTools;
+        this.taskTools = taskTools;
+        this.memoryTools = memoryTools;
+        this.tools = new Map();
+        this.registerBuiltInTools();
+    }
+};
+ToolsRegistryService = _ts_decorate([
+    (0, _common.Injectable)(),
+    _ts_param(3, (0, _common.Inject)((0, _common.forwardRef)(()=>_tasktoolsservice.TaskToolsService))),
+    _ts_param(4, (0, _common.Inject)((0, _common.forwardRef)(()=>_memorytoolsservice.MemoryToolsService))),
+    _ts_metadata("design:type", Function),
+    _ts_metadata("design:paramtypes", [
+        typeof _filesystemtoolsservice.FilesystemToolsService === "undefined" ? Object : _filesystemtoolsservice.FilesystemToolsService,
+        typeof _shelltoolsservice.ShellToolsService === "undefined" ? Object : _shelltoolsservice.ShellToolsService,
+        typeof _searchtoolsservice.SearchToolsService === "undefined" ? Object : _searchtoolsservice.SearchToolsService,
+        typeof _tasktoolsservice.TaskToolsService === "undefined" ? Object : _tasktoolsservice.TaskToolsService,
+        typeof _memorytoolsservice.MemoryToolsService === "undefined" ? Object : _memorytoolsservice.MemoryToolsService
+    ])
+], ToolsRegistryService);
+
+//# sourceMappingURL=tools-registry.service.js.map

package/dist/modules/tools/services/tools-registry.service.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/modules/tools/services/tools-registry.service.ts"],"sourcesContent":["import { Injectable, Inject, forwardRef } from '@nestjs/common';\nimport { StructuredTool } from '@langchain/core/tools';\nimport { FilesystemToolsService } from './filesystem-tools.service';\nimport { ShellToolsService } from './shell-tools.service';\nimport { SearchToolsService } from './search-tools.service';\nimport { TaskToolsService } from '../../tasks/services/task-tools.service';\nimport { MemoryToolsService } from '../../memory/services/memory-tools.service';\n\n@Injectable()\nexport class ToolsRegistryService {\n  private tools: Map<string, StructuredTool> = new Map();\n\n  constructor(\n    private readonly filesystemTools: FilesystemToolsService,\n    private readonly shellTools: ShellToolsService,\n    private readonly searchTools: SearchToolsService,\n    @Inject(forwardRef(() => TaskToolsService))\n    private readonly taskTools: TaskToolsService,\n    @Inject(forwardRef(() => MemoryToolsService))\n    private readonly memoryTools: MemoryToolsService,\n  ) {\n    this.registerBuiltInTools();\n  }\n\n  private registerBuiltInTools() {\n    const allTools = [\n      ...this.filesystemTools.getTools(),\n      ...this.shellTools.getTools(),\n      ...this.searchTools.getTools(),\n      ...this.taskTools.getTools(),\n      ...this.memoryTools.getTools(),\n    ];\n\n    for (const t of allTools) {\n      this.tools.set(t.name, t);\n    }\n  }\n\n  getTool(name: string): StructuredTool | undefined {\n    return this.tools.get(name);\n  }\n\n  getTools(names: string[]): StructuredTool[] {\n    return names\n      .map((name) => this.tools.get(name))\n      .filter((t): t is StructuredTool => t !== undefined);\n  }\n\n  getAllTools(): StructuredTool[] {\n    return Array.from(this.tools.values());\n  }\n\n  getToolNames(): string[] {\n    return Array.from(this.tools.keys());\n  }\n\n  registerTool(t: StructuredTool) {\n    this.tools.set(t.name, t);\n  }\n}\n"],"names":["ToolsRegistryService","registerBuiltInTools","allTools","filesystemTools","getTools","shellTools","searchTools","taskTools","memoryTools","t","tools","set","name","getTool","get","names","map","filter","undefined","getAllTools","Array","from","values","getToolNames","keys","registerTool","Map","TaskToolsService","MemoryToolsService"],"mappings":";;;;+BASaA;;;eAAAA;;;wBATkC;wCAER;mCACL;oCACC;kCACF;oCACE;;;;;;;;;;;;;;;AAG5B,IAAA,AAAMA,uBAAN,MAAMA;IAeHC,uBAAuB;QAC7B,MAAMC,WAAW;eACZ,IAAI,CAACC,eAAe,CAACC,QAAQ;eAC7B,IAAI,CAACC,UAAU,CAACD,QAAQ;eACxB,IAAI,CAACE,WAAW,CAACF,QAAQ;eACzB,IAAI,CAACG,SAAS,CAACH,QAAQ;eACvB,IAAI,CAACI,WAAW,CAACJ,QAAQ;SAC7B;QAED,KAAK,MAAMK,KAAKP,SAAU;YACxB,IAAI,CAACQ,KAAK,CAACC,GAAG,CAACF,EAAEG,IAAI,EAAEH;QACzB;IACF;IAEAI,QAAQD,IAAY,EAA8B;QAChD,OAAO,IAAI,CAACF,KAAK,CAACI,GAAG,CAACF;IACxB;IAEAR,SAASW,KAAe,EAAoB;QAC1C,OAAOA,MACJC,GAAG,CAAC,CAACJ,OAAS,IAAI,CAACF,KAAK,CAACI,GAAG,CAACF,OAC7BK,MAAM,CAAC,CAACR,IAA2BA,MAAMS;IAC9C;IAEAC,cAAgC;QAC9B,OAAOC,MAAMC,IAAI,CAAC,IAAI,CAACX,KAAK,CAACY,MAAM;IACrC;IAEAC,eAAyB;QACvB,OAAOH,MAAMC,IAAI,CAAC,IAAI,CAACX,KAAK,CAACc,IAAI;IACnC;IAEAC,aAAahB,CAAiB,EAAE;QAC9B,IAAI,CAACC,KAAK,CAACC,GAAG,CAACF,EAAEG,IAAI,EAAEH;IACzB;IA9CA,YACE,AAAiBN,eAAuC,EACxD,AAAiBE,UAA6B,EAC9C,AAAiBC,WAA+B,EAChD,AACiBC,SAA2B,EAC5C,AACiBC,WAA+B,CAChD;aAPiBL,kBAAAA;aACAE,aAAAA;aACAC,cAAAA;aAEAC,YAAAA;aAEAC,cAAAA;aATXE,QAAqC,IAAIgB;QAW/C,IAAI,CAACzB,oBAAoB;IAC3B;AAqCF;;;iEA3C6B0B,kCAAgB;iEAEhBC,sCAAkB"}

package/dist/modules/tools/tools.module.js

@@ -0,0 +1,46 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "ToolsModule", {
+    enumerable: true,
+    get: function() {
+        return ToolsModule;
+    }
+});
+const _common = require("@nestjs/common");
+const _filesystemtoolsservice = require("./services/filesystem-tools.service");
+const _shelltoolsservice = require("./services/shell-tools.service");
+const _searchtoolsservice = require("./services/search-tools.service");
+const _toolsregistryservice = require("./services/tools-registry.service");
+const _permissionsmodule = require("../permissions/permissions.module");
+const _tasksmodule = require("../tasks/tasks.module");
+const _memorymodule = require("../memory/memory.module");
+function _ts_decorate(decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for(var i = decorators.length - 1; i >= 0; i--)if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+let ToolsModule = class ToolsModule {
+};
+ToolsModule = _ts_decorate([
+    (0, _common.Module)({
+        imports: [
+            _permissionsmodule.PermissionsModule,
+            (0, _common.forwardRef)(()=>_tasksmodule.TasksModule),
+            (0, _common.forwardRef)(()=>_memorymodule.MemoryModule)
+        ],
+        providers: [
+            _filesystemtoolsservice.FilesystemToolsService,
+            _shelltoolsservice.ShellToolsService,
+            _searchtoolsservice.SearchToolsService,
+            _toolsregistryservice.ToolsRegistryService
+        ],
+        exports: [
+            _toolsregistryservice.ToolsRegistryService
+        ]
+    })
+], ToolsModule);
+
+//# sourceMappingURL=tools.module.js.map

package/dist/modules/tools/tools.module.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/modules/tools/tools.module.ts"],"sourcesContent":["import { Module, forwardRef } from '@nestjs/common';\nimport { FilesystemToolsService } from './services/filesystem-tools.service';\nimport { ShellToolsService } from './services/shell-tools.service';\nimport { SearchToolsService } from './services/search-tools.service';\nimport { ToolsRegistryService } from './services/tools-registry.service';\nimport { PermissionsModule } from '../permissions/permissions.module';\nimport { TasksModule } from '../tasks/tasks.module';\nimport { MemoryModule } from '../memory/memory.module';\n\n@Module({\n  imports: [PermissionsModule, forwardRef(() => TasksModule), forwardRef(() => MemoryModule)],\n  providers: [\n    FilesystemToolsService,\n    ShellToolsService,\n    SearchToolsService,\n    ToolsRegistryService,\n  ],\n  exports: [ToolsRegistryService],\n})\nexport class ToolsModule {}\n"],"names":["ToolsModule","imports","PermissionsModule","forwardRef","TasksModule","MemoryModule","providers","FilesystemToolsService","ShellToolsService","SearchToolsService","ToolsRegistryService","exports"],"mappings":";;;;+BAmBaA;;;eAAAA;;;wBAnBsB;wCACI;mCACL;oCACC;sCACE;mCACH;6BACN;8BACC;;;;;;;AAYtB,IAAA,AAAMA,cAAN,MAAMA;AAAa;;;QATxBC,SAAS;YAACC,oCAAiB;YAAEC,IAAAA,kBAAU,EAAC,IAAMC,wBAAW;YAAGD,IAAAA,kBAAU,EAAC,IAAME,0BAAY;SAAE;QAC3FC,WAAW;YACTC,8CAAsB;YACtBC,oCAAiB;YACjBC,sCAAkB;YAClBC,0CAAoB;SACrB;QACDC,SAAS;YAACD,0CAAoB;SAAC"}

package/package.json

@@ -0,0 +1,74 @@
+{
+  "name": "cast-code",
+  "version": "1.0.0",
+  "description": "Multi-agent CLI system powered by DeepAgents",
+  "main": "dist/main.js",
+  "bin": {
+    "cast": "./dist/main.js"
+  },
+  "files": [
+    "dist",
+    "templates"
+  ],
+  "scripts": {
+    "build": "nest build && chmod +x dist/main.js",
+    "start": "node dist/main.js",
+    "start:dev": "nest start --watch",
+    "lint": "eslint \"{src,apps,libs,test}/**/*.ts\" --fix",
+    "lint:check": "eslint \"{src,apps,libs,test}/**/*.ts\"",
+    "format": "prettier --write .",
+    "format:check": "prettier --check .",
+    "prepublishOnly": "npm run build"
+  },
+  "keywords": [
+    "ai",
+    "agents",
+    "cli",
+    "langchain",
+    "deepagents",
+    "multi-agent"
+  ],
+  "author": "pedrocastanha",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/pedrocastanha/cast-code"
+  },
+  "dependencies": {
+    "@inquirer/prompts": "^8.2.0",
+    "@langchain/anthropic": "^1.3.12",
+    "@langchain/core": "^1.1.24",
+    "@langchain/google-genai": "^2.1.18",
+    "@langchain/langgraph": "latest",
+    "@langchain/ollama": "^1.2.2",
+    "@langchain/openai": "latest",
+    "@nestjs/common": "^10.0.0",
+    "@nestjs/core": "^10.0.0",
+    "@nestjs/platform-express": "^10.0.0",
+    "@types/js-yaml": "^4.0.9",
+    "chalk": "^4.1.2",
+    "deepagents": "latest",
+    "dotenv": "^17.2.3",
+    "glob": "^11.0.0",
+    "gray-matter": "^4.0.3",
+    "js-yaml": "^4.1.1",
+    "langchain": "latest",
+    "reflect-metadata": "^0.2.0",
+    "rxjs": "^7.8.0",
+    "zod": "^3.23.0"
+  },
+  "devDependencies": {
+    "@nestjs/cli": "^10.0.0",
+    "@nestjs/schematics": "^10.0.0",
+    "@swc/cli": "^0.5.2",
+    "@swc/core": "^1.15.11",
+    "@types/node": "^20.0.0",
+    "esbuild": "^0.27.2",
+    "ts-node": "^10.9.0",
+    "tsconfig-paths": "^4.2.0",
+    "typescript": "^5.3.0"
+  },
+  "engines": {
+    "node": ">=20.0.0"
+  }
+}