cast-code 1.0.0

package/dist/modules/repl/services/repl.service.js

@@ -0,0 +1,647 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "ReplService", {
+    enumerable: true,
+    get: function() {
+        return ReplService;
+    }
+});
+const _common = require("@nestjs/common");
+const _deepagentservice = require("../../core/services/deep-agent.service");
+const _configservice = require("../../../common/services/config.service");
+const _configmanagerservice = require("../../config/services/config-manager.service");
+const _mentionsservice = require("../../mentions/services/mentions.service");
+const _mcpregistryservice = require("../../mcp/services/mcp-registry.service");
+const _agentregistryservice = require("../../agents/services/agent-registry.service");
+const _skillregistryservice = require("../../skills/services/skill-registry.service");
+const _planmodeservice = require("../../core/services/plan-mode.service");
+const _smartinput = require("./smart-input");
+const _welcomescreenservice = require("./welcome-screen.service");
+const _replcommandsservice = require("./commands/repl-commands.service");
+const _gitcommandsservice = require("./commands/git-commands.service");
+const _agentcommandsservice = require("./commands/agent-commands.service");
+const _mcpcommandsservice = require("./commands/mcp-commands.service");
+const _configcommandsservice = require("../../config/services/config-commands.service");
+const _projectcommandsservice = require("./commands/project-commands.service");
+const _toolsregistryservice = require("../../tools/services/tools-registry.service");
+const _theme = require("../utils/theme");
+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);
+}
+let ReplService = class ReplService {
+    async start() {
+        const initResult = await this.deepAgent.initialize();
+        const agentCount = this.agentRegistry.resolveAllAgents().length;
+        this.welcomeScreen.printWelcomeScreen({
+            projectPath: initResult.projectPath || undefined,
+            model: this.getModelDisplayName(),
+            toolCount: initResult.toolCount,
+            agentCount
+        });
+        this.smartInput = new _smartinput.SmartInput({
+            prompt: `${_theme.Colors.cyan}${_theme.Colors.bold}>${_theme.Colors.reset} `,
+            promptVisibleLen: 2,
+            getCommandSuggestions: (input)=>this.getCommandSuggestions(input),
+            getMentionSuggestions: (partial)=>this.getMentionSuggestions(partial),
+            onSubmit: (line)=>this.handleLine(line),
+            onCancel: ()=>this.handleCancel(),
+            onExit: ()=>this.handleExit()
+        });
+        this.smartInput.start();
+    }
+    getCommandSuggestions(input) {
+        const commands = [
+            {
+                text: '/help',
+                display: '/help',
+                description: 'Show help'
+            },
+            {
+                text: '/clear',
+                display: '/clear',
+                description: 'Clear conversation'
+            },
+            {
+                text: '/compact',
+                display: '/compact',
+                description: 'Compact history'
+            },
+            {
+                text: '/exit',
+                display: '/exit',
+                description: 'Exit'
+            },
+            {
+                text: '/status',
+                display: '/status',
+                description: 'Git status'
+            },
+            {
+                text: '/diff',
+                display: '/diff',
+                description: 'Git diff'
+            },
+            {
+                text: '/log',
+                display: '/log',
+                description: 'Git log'
+            },
+            {
+                text: '/commit',
+                display: '/commit',
+                description: 'Commit changes'
+            },
+            {
+                text: '/up',
+                display: '/up',
+                description: 'Smart commit & push'
+            },
+            {
+                text: '/split-up',
+                display: '/split-up',
+                description: 'Split commits'
+            },
+            {
+                text: '/pr',
+                display: '/pr',
+                description: 'Create Pull Request'
+            },
+            {
+                text: '/review',
+                display: '/review',
+                description: 'Code review'
+            },
+            {
+                text: '/fix',
+                display: '/fix',
+                description: 'Auto-fix code'
+            },
+            {
+                text: '/ident',
+                display: '/ident',
+                description: 'Format code'
+            },
+            {
+                text: '/release',
+                display: '/release',
+                description: 'Release notes'
+            },
+            {
+                text: '/tools',
+                display: '/tools',
+                description: 'List tools'
+            },
+            {
+                text: '/agents',
+                display: '/agents',
+                description: 'List agents'
+            },
+            {
+                text: '/skills',
+                display: '/skills',
+                description: 'List skills'
+            },
+            {
+                text: '/context',
+                display: '/context',
+                description: 'Session info'
+            },
+            {
+                text: '/mentions',
+                display: '/mentions',
+                description: 'Mentions help'
+            },
+            {
+                text: '/model',
+                display: '/model',
+                description: 'Show model'
+            },
+            {
+                text: '/config',
+                display: '/config',
+                description: 'Configuration'
+            },
+            {
+                text: '/project',
+                display: '/project',
+                description: 'Project context'
+            },
+            {
+                text: '/project-deep',
+                display: '/project-deep',
+                description: 'Deep project analysis'
+            },
+            {
+                text: '/init',
+                display: '/init',
+                description: 'Analyze project and generate context'
+            },
+            {
+                text: '/mcp',
+                display: '/mcp',
+                description: 'MCP servers'
+            }
+        ];
+        return commands.filter((c)=>c.text.startsWith(input));
+    }
+    getMentionSuggestions(partial) {
+        const fs = require('fs');
+        const path = require('path');
+        const gitOpts = [
+            {
+                text: '@git:status',
+                display: '@git:status',
+                description: 'Git status'
+            },
+            {
+                text: '@git:diff',
+                display: '@git:diff',
+                description: 'Git diff'
+            },
+            {
+                text: '@git:log',
+                display: '@git:log',
+                description: 'Git log'
+            },
+            {
+                text: '@git:branch',
+                display: '@git:branch',
+                description: 'Branches'
+            }
+        ];
+        if (partial === '') return [
+            ...gitOpts,
+            ...this.getFileEntries('')
+        ];
+        if (partial.startsWith('git:')) return gitOpts.filter((o)=>o.text.startsWith('@' + partial));
+        return [
+            ...gitOpts.filter((o)=>o.text.startsWith('@' + partial)),
+            ...this.getFileEntries(partial)
+        ].slice(0, 30);
+    }
+    getFileEntries(partial) {
+        const fs = require('fs');
+        const path = require('path');
+        try {
+            let dir;
+            let prefix;
+            if (partial.endsWith('/')) {
+                dir = partial.slice(0, -1) || '.';
+                prefix = '';
+            } else if (partial.includes('/')) {
+                dir = path.dirname(partial);
+                prefix = path.basename(partial);
+            } else {
+                dir = '.';
+                prefix = partial;
+            }
+            const resolved = path.resolve(process.cwd(), dir);
+            if (!fs.existsSync(resolved) || !fs.statSync(resolved).isDirectory()) return [];
+            const entries = fs.readdirSync(resolved, {
+                withFileTypes: true
+            });
+            const ignore = [
+                'node_modules',
+                '.git',
+                'dist',
+                'coverage',
+                '.next',
+                '__pycache__'
+            ];
+            return entries.filter((e)=>!ignore.includes(e.name)).filter((e)=>!e.name.startsWith('.') || prefix.startsWith('.')).filter((e)=>prefix === '' || e.name.toLowerCase().startsWith(prefix.toLowerCase())).map((e)=>{
+                const relDir = dir === '.' ? '' : dir + '/';
+                const isDir = e.isDirectory();
+                return {
+                    text: '@' + relDir + e.name + (isDir ? '/' : ''),
+                    display: '@' + relDir + e.name + (isDir ? '/' : ''),
+                    description: isDir ? 'dir' : ''
+                };
+            }).slice(0, 20);
+        } catch  {
+            return [];
+        }
+    }
+    handleCancel() {
+        if (this.isProcessing && this.abortController) {
+            this.abortController.abort();
+            this.stopSpinner();
+            process.stdout.write(`\r\n${_theme.Colors.yellow}  Cancelled${_theme.Colors.reset}\r\n\r\n`);
+            this.isProcessing = false;
+        } else {
+            process.stdout.write(`${_theme.Colors.dim}  (Use /exit to quit)${_theme.Colors.reset}\r\n`);
+            this.smartInput?.showPrompt();
+        }
+    }
+    handleExit() {
+        process.stdout.write(`${_theme.Colors.dim}  Goodbye!${_theme.Colors.reset}\r\n`);
+        this.stop();
+        process.exit(0);
+    }
+    async handleLine(input) {
+        const trimmed = input.trim();
+        if (!trimmed) {
+            this.smartInput?.showPrompt();
+            return;
+        }
+        if (trimmed.startsWith('/')) {
+            await this.handleCommand(trimmed);
+        } else {
+            await this.handleMessage(trimmed);
+        }
+        this.smartInput?.showPrompt();
+    }
+    async handleCommand(command) {
+        const parts = command.slice(1).split(/\s+/);
+        const cmd = parts[0].toLowerCase();
+        const args = parts.slice(1);
+        switch(cmd){
+            case 'help':
+                this.replCommands.printHelp();
+                break;
+            case 'clear':
+                this.replCommands.cmdClear(this.welcomeScreen);
+                break;
+            case 'exit':
+            case 'quit':
+                this.handleExit();
+                return;
+            case 'compact':
+                await this.handleCompact();
+                break;
+            case 'context':
+                this.replCommands.cmdContext();
+                break;
+            case 'config':
+                await this.configCommands.handleConfigCommand(args, this.smartInput);
+                break;
+            case 'model':
+                this.replCommands.cmdModel(args);
+                break;
+            case 'init':
+                await this.projectCommands.cmdProject([
+                    'analyze'
+                ], this.smartInput);
+                break;
+            case 'mentions':
+                this.replCommands.cmdMentionsHelp();
+                break;
+            case 'tools':
+                this.cmdTools();
+                break;
+            case 'status':
+                this.gitCommands.runGit('git status');
+                break;
+            case 'diff':
+                this.gitCommands.runGit(args.length ? `git diff ${args.join(' ')}` : 'git diff');
+                break;
+            case 'log':
+                this.gitCommands.runGit('git log --oneline -15');
+                break;
+            case 'commit':
+                await this.gitCommands.cmdCommit(args, this.smartInput);
+                break;
+            case 'up':
+                await this.gitCommands.cmdUp(this.smartInput);
+                break;
+            case 'split-up':
+                await this.gitCommands.cmdSplitUp(this.smartInput);
+                break;
+            case 'pr':
+                await this.gitCommands.cmdPr(this.smartInput);
+                break;
+            case 'review':
+                await this.gitCommands.cmdReview(args);
+                break;
+            case 'fix':
+                await this.gitCommands.cmdFix(args);
+                break;
+            case 'ident':
+                await this.gitCommands.cmdIdent();
+                break;
+            case 'release':
+                await this.gitCommands.cmdRelease(args);
+                break;
+            case 'agents':
+                await this.agentCommands.cmdAgents(args, this.smartInput);
+                break;
+            case 'skills':
+                await this.agentCommands.cmdSkills(args, this.smartInput);
+                break;
+            case 'mcp':
+                await this.mcpCommands.cmdMcp(args, this.smartInput);
+                break;
+            case 'project':
+                await this.projectCommands.cmdProject(args, this.smartInput);
+                break;
+            case 'project-deep':
+                await this.projectCommands.cmdProject([
+                    'deep'
+                ], this.smartInput);
+                break;
+            default:
+                process.stdout.write(`${_theme.Colors.red}  Unknown: /${cmd}${_theme.Colors.reset}  ${_theme.Colors.dim}Try /help${_theme.Colors.reset}\r\n`);
+        }
+    }
+    async handleCompact() {
+        const msgCount = this.deepAgent.getMessageCount();
+        if (msgCount < 4) {
+            process.stdout.write(`${_theme.Colors.dim}  Nothing to compact (${msgCount} messages)${_theme.Colors.reset}\r\n`);
+            return;
+        }
+        process.stdout.write(`${_theme.Colors.dim}  Summarizing ${msgCount} messages...${_theme.Colors.reset}\r\n`);
+        const result = await this.deepAgent.compactHistory();
+        if (result.compacted) {
+            process.stdout.write(`${_theme.Colors.green}  Compacted: ${result.messagesBefore} → ${result.messagesAfter} messages${_theme.Colors.reset}\r\n`);
+        } else {
+            process.stdout.write(`${_theme.Colors.yellow}  Could not compact (summarization failed)${_theme.Colors.reset}\r\n`);
+        }
+    }
+    async handleMessage(message) {
+        this.isProcessing = true;
+        this.abortController = new AbortController();
+        this.smartInput?.enterPassiveMode();
+        try {
+            let messageToProcess = message;
+            const planCheck = await this.planMode.shouldEnterPlanMode(message);
+            if (planCheck.shouldPlan) {
+                const usePlan = await this.smartInput.askChoice('📝 Complex task. Create a plan?', [
+                    {
+                        key: 'y',
+                        label: 'yes',
+                        description: 'Create structured plan'
+                    },
+                    {
+                        key: 'n',
+                        label: 'no',
+                        description: 'Proceed without plan'
+                    }
+                ]);
+                if (usePlan === 'y') {
+                    const plannedMessage = await this.runInteractivePlanMode(message);
+                    if (!plannedMessage) {
+                        this.isProcessing = false;
+                        this.smartInput?.exitPassiveMode();
+                        return;
+                    }
+                    messageToProcess = plannedMessage;
+                }
+            }
+            const mentionResult = await this.mentionsService.processMessage(messageToProcess);
+            if (mentionResult.mentions.length > 0) {
+                const summary = this.mentionsService.getMentionsSummary(mentionResult.mentions);
+                for (const line of summary){
+                    process.stdout.write(`${_theme.Colors.dim}${line}${_theme.Colors.reset}\r\n`);
+                }
+                process.stdout.write('\r\n');
+            }
+            this.startSpinner('Thinking');
+            let firstChunk = true;
+            let fullResponse = '';
+            for await (const chunk of this.deepAgent.chat(mentionResult.expandedMessage)){
+                if (this.abortController?.signal.aborted) break;
+                const isToolOutput = chunk.includes('\x1b[') && (chunk.includes('⏿') || chunk.includes('tokens:') || chunk.includes('conversation compacted'));
+                if (firstChunk && !isToolOutput) {
+                    this.stopSpinner();
+                    process.stdout.write(`\r\n${_theme.Colors.magenta}${_theme.Colors.bold}${_theme.Icons.chestnut} Cast${_theme.Colors.reset}\r\n`);
+                    firstChunk = false;
+                }
+                if (!isToolOutput) {
+                    fullResponse += chunk;
+                }
+                process.stdout.write(chunk);
+            }
+            if (!firstChunk) {
+                process.stdout.write('\r\n');
+            } else {
+                this.stopSpinner();
+            }
+        } catch (error) {
+            this.stopSpinner();
+            const msg = error.message;
+            if (!msg.includes('abort')) {
+                process.stdout.write(`\r\n${_theme.Colors.red}  Error: ${msg}${_theme.Colors.reset}\r\n\r\n`);
+            }
+        } finally{
+            this.isProcessing = false;
+            this.abortController = null;
+            this.smartInput?.exitPassiveMode();
+        }
+    }
+    async runInteractivePlanMode(userMessage) {
+        process.stdout.write(`\r\n${_theme.Colors.cyan}${_theme.Colors.bold}📋 PLAN MODE${_theme.Colors.reset}\r\n`);
+        process.stdout.write(`${_theme.Colors.dim}Build plan first, execute after approval${_theme.Colors.reset}\r\n\r\n`);
+        const clarifyingQuestions = await this.planMode.generateClarifyingQuestions(userMessage);
+        const answers = [];
+        if (clarifyingQuestions.length > 0) {
+            process.stdout.write(`${_theme.Colors.dim}I need a few quick clarifications:${_theme.Colors.reset}\r\n`);
+            for(let i = 0; i < clarifyingQuestions.length; i++){
+                const q = clarifyingQuestions[i];
+                const answer = await this.smartInput.question(`${_theme.Colors.yellow}Q${i + 1}:${_theme.Colors.reset} ${q} `);
+                if (answer.trim()) {
+                    answers.push(`- ${q} => ${answer.trim()}`);
+                }
+            }
+            process.stdout.write('\r\n');
+        }
+        const context = answers.length > 0 ? `User clarifications:\n${answers.join('\n')}` : undefined;
+        let plan = await this.planMode.generatePlan(userMessage, context);
+        while(true){
+            process.stdout.write(this.planMode.formatPlanForDisplay(plan));
+            const action = await this.smartInput.askChoice('Plan options', [
+                {
+                    key: 'a',
+                    label: 'accept',
+                    description: 'Use this plan and continue'
+                },
+                {
+                    key: 'r',
+                    label: 'refine',
+                    description: 'Refine plan with extra feedback'
+                },
+                {
+                    key: 'c',
+                    label: 'cancel',
+                    description: 'Cancel and return to prompt'
+                }
+            ]);
+            if (action === 'c') {
+                process.stdout.write(`${_theme.Colors.dim}  Plan cancelled${_theme.Colors.reset}\r\n\r\n`);
+                return null;
+            }
+            if (action === 'r') {
+                const feedback = await this.smartInput.question(`${_theme.Colors.cyan}Refinement feedback:${_theme.Colors.reset} `);
+                if (!feedback.trim()) {
+                    process.stdout.write(`${_theme.Colors.dim}  No feedback provided. Keeping current plan.${_theme.Colors.reset}\r\n\r\n`);
+                    continue;
+                }
+                plan = await this.planMode.refinePlan(plan, feedback.trim());
+                continue;
+            }
+            return this.buildPlanExecutionPrompt(userMessage, plan, answers);
+        }
+    }
+    buildPlanExecutionPrompt(userMessage, plan, clarifications) {
+        const lines = [];
+        lines.push(userMessage);
+        lines.push('');
+        lines.push('Approved execution plan:');
+        lines.push(`Title: ${plan.title}`);
+        lines.push(`Overview: ${plan.overview}`);
+        lines.push('Steps:');
+        for (const step of plan.steps){
+            const files = step.files.length > 0 ? ` | files: ${step.files.join(', ')}` : '';
+            lines.push(`${step.id}. ${step.description}${files}`);
+        }
+        if (clarifications.length > 0) {
+            lines.push('');
+            lines.push('User clarifications:');
+            lines.push(...clarifications);
+        }
+        lines.push('');
+        lines.push('Execute the task following this approved plan and report progress by step.');
+        return lines.join('\n');
+    }
+    startSpinner(label) {
+        let i = 0;
+        this.spinnerTimer = setInterval(()=>{
+            process.stdout.write(`\r${_theme.Colors.cyan}${_theme.Icons.thinkingChestnut[i++ % _theme.Icons.thinkingChestnut.length]}${_theme.Colors.reset} ${_theme.Colors.dim}${label}...${_theme.Colors.reset}`);
+        }, 80);
+    }
+    stopSpinner() {
+        if (this.spinnerTimer) {
+            clearInterval(this.spinnerTimer);
+            this.spinnerTimer = null;
+            process.stdout.write('\r\x1b[K');
+        }
+    }
+    cmdTools() {
+        const allTools = this.toolsRegistry.getAllTools();
+        const tools = allTools.map((t)=>[
+                t.name,
+                t.description.slice(0, 60)
+            ]);
+        if (tools.length > 0) {
+            const maxLen = Math.max(...tools.map(([n])=>n.length));
+            process.stdout.write('\r\n');
+            process.stdout.write(`${_theme.Colors.bold}Built-in Tools (${tools.length}):${_theme.Colors.reset}\r\n`);
+            for (const [name, desc] of tools){
+                process.stdout.write(`  ${_theme.Colors.cyan}${name.padEnd(maxLen)}${_theme.Colors.reset}  ${_theme.Colors.dim}${desc}${_theme.Colors.reset}\r\n`);
+            }
+        }
+        const mcpTools = this.mcpRegistry.getAllMcpTools();
+        if (mcpTools.length > 0) {
+            process.stdout.write(`\r\n${_theme.Colors.bold}MCP Tools (${mcpTools.length}):${_theme.Colors.reset}\r\n`);
+            for (const t of mcpTools.slice(0, 10)){
+                process.stdout.write(`  ${_theme.Colors.cyan}${t.name}${_theme.Colors.reset}  ${_theme.Colors.dim}${t.description.slice(0, 50)}${_theme.Colors.reset}\r\n`);
+            }
+        }
+        process.stdout.write('\r\n');
+    }
+    getModelDisplayName() {
+        try {
+            const modelConfig = this.configManager.getModelConfig('default');
+            if (modelConfig) {
+                return `${modelConfig.provider}/${modelConfig.model}`;
+            }
+        } catch  {}
+        return `${this.configService.getProvider()}/${this.configService.getModel()}`;
+    }
+    stop() {
+        this.stopSpinner();
+        this.smartInput?.destroy();
+    }
+    constructor(deepAgent, configService, configManager, mentionsService, mcpRegistry, agentRegistry, skillRegistry, welcomeScreen, planMode, replCommands, gitCommands, agentCommands, mcpCommands, configCommands, projectCommands, toolsRegistry){
+        this.deepAgent = deepAgent;
+        this.configService = configService;
+        this.configManager = configManager;
+        this.mentionsService = mentionsService;
+        this.mcpRegistry = mcpRegistry;
+        this.agentRegistry = agentRegistry;
+        this.skillRegistry = skillRegistry;
+        this.welcomeScreen = welcomeScreen;
+        this.planMode = planMode;
+        this.replCommands = replCommands;
+        this.gitCommands = gitCommands;
+        this.agentCommands = agentCommands;
+        this.mcpCommands = mcpCommands;
+        this.configCommands = configCommands;
+        this.projectCommands = projectCommands;
+        this.toolsRegistry = toolsRegistry;
+        this.smartInput = null;
+        this.abortController = null;
+        this.isProcessing = false;
+        this.spinnerTimer = null;
+    }
+};
+ReplService = _ts_decorate([
+    (0, _common.Injectable)(),
+    _ts_metadata("design:type", Function),
+    _ts_metadata("design:paramtypes", [
+        typeof _deepagentservice.DeepAgentService === "undefined" ? Object : _deepagentservice.DeepAgentService,
+        typeof _configservice.ConfigService === "undefined" ? Object : _configservice.ConfigService,
+        typeof _configmanagerservice.ConfigManagerService === "undefined" ? Object : _configmanagerservice.ConfigManagerService,
+        typeof _mentionsservice.MentionsService === "undefined" ? Object : _mentionsservice.MentionsService,
+        typeof _mcpregistryservice.McpRegistryService === "undefined" ? Object : _mcpregistryservice.McpRegistryService,
+        typeof _agentregistryservice.AgentRegistryService === "undefined" ? Object : _agentregistryservice.AgentRegistryService,
+        typeof _skillregistryservice.SkillRegistryService === "undefined" ? Object : _skillregistryservice.SkillRegistryService,
+        typeof _welcomescreenservice.WelcomeScreenService === "undefined" ? Object : _welcomescreenservice.WelcomeScreenService,
+        typeof _planmodeservice.PlanModeService === "undefined" ? Object : _planmodeservice.PlanModeService,
+        typeof _replcommandsservice.ReplCommandsService === "undefined" ? Object : _replcommandsservice.ReplCommandsService,
+        typeof _gitcommandsservice.GitCommandsService === "undefined" ? Object : _gitcommandsservice.GitCommandsService,
+        typeof _agentcommandsservice.AgentCommandsService === "undefined" ? Object : _agentcommandsservice.AgentCommandsService,
+        typeof _mcpcommandsservice.McpCommandsService === "undefined" ? Object : _mcpcommandsservice.McpCommandsService,
+        typeof _configcommandsservice.ConfigCommandsService === "undefined" ? Object : _configcommandsservice.ConfigCommandsService,
+        typeof _projectcommandsservice.ProjectCommandsService === "undefined" ? Object : _projectcommandsservice.ProjectCommandsService,
+        typeof _toolsregistryservice.ToolsRegistryService === "undefined" ? Object : _toolsregistryservice.ToolsRegistryService
+    ])
+], ReplService);
+
+//# sourceMappingURL=repl.service.js.map