deepclause-sdk 0.0.68 → 0.0.70

package/dist/cli/tui.js

@@ -7,12 +7,12 @@ import { listCommands } from './commands.js';
 import { getConfigPath, loadConfig, resolveModelSlot, setModel } from './config.js';
 import { run } from './run.js';
 import { formatToolArgs } from './tool-args.js';
-import { createSessionExecutionLogWriter, createLocalSkill, createConductorSession, getConductorSessionDetail, listConductorSessions, runConductorTurn, } from '../system/runtime/conductor.js';
+import { appendConductorSessionMessages, createSessionExecutionLogWriter, createLocalSkill, createConductorSession, getConductorSessionDetail, listConductorSessions, runConductorTurn, } from '../system/runtime/conductor.js';
 import { getSystemAssetSourcePaths } from '../system/assets/index.js';
 import { createShellManager, describeShellExecutionBackend, } from '../system/runtime/shell-manager.js';
 import { buildToolCompletionEvent, buildToolFailureEvent, buildToolStartEvent, createShellToolEventBridge, } from '../system/runtime/shell-tool-events.js';
 const IGNORED_LIVE_LOG_TOOLS = new Set(['set_result', 'update_memory']);
-const BUILTIN_SLASH_COMMANDS = ['new', 'sessions', 'help', 'compile', 'skill-creator', 'set-model', 'cancel', 'exit', 'quit'];
+const BUILTIN_SLASH_COMMANDS = ['new', 'sessions', 'help', 'run', 'compile', 'skill-creator', 'set-model', 'cancel', 'exit', 'quit'];
 const MODEL_SLOTS = ['gateway', 'run', 'compile'];
 const CHILD_EVENT_INDENT = '\t';
 const CHILD_EVENT_TAB_WIDTH = 4;
@@ -23,6 +23,7 @@ const BUSY_RENDER_INTERVAL_MS = 40;
 const TYPING_RENDER_INTERVAL_MS = 90;
 const COMBINING_MARK_RE = /\p{Mark}/u;
 const EXTENDED_PICTOGRAPHIC_RE = /\p{Extended_Pictographic}/u;
+const MAX_PERSISTED_SHELL_STREAM_CHARS = 4000;
 const TEXT_FILE_EXTENSIONS = new Set([
     '.dml', '.md', '.txt', '.json', '.yaml', '.yml', '.toml', '.ts', '.tsx', '.js', '.jsx', '.mjs', '.cjs',
     '.css', '.scss', '.html', '.sql', '.py', '.sh', '.bash', '.zsh', '.pro', '.pl', '.csv', '.env', '.example',
@@ -828,6 +829,9 @@ class FullscreenTui {
                 this.requestRender();
                 return;
             }
+            case 'run':
+                await this.executeRunFile(parsed.args);
+                return;
             case 'compile':
             case 'skill-creator':
                 await this.executeSkillCreator(parsed.name, parsed.rawArgs);
@@ -923,7 +927,7 @@ class FullscreenTui {
         this.statusLine = `Running /${skillName}...`;
         this.requestRender();
         try {
-            const result = await runSkillCommand(this.workspaceRoot, skillName, args, {
+            const result = await runSlashCommand(this.workspaceRoot, skillName, args, {
                 sessionId: this.selectedSessionId || undefined,
                 sandbox: this.options.sandbox,
                 signal: this.currentAbortController.signal,
@@ -962,6 +966,68 @@ class FullscreenTui {
             }
         }
     }
+    async executeRunFile(args) {
+        if (args.length === 0) {
+            this.statusLine = 'Provide a DML file after /run.';
+            this.requestRender();
+            return;
+        }
+        const [fileSpec, ...runArgs] = args;
+        const sessionId = this.selectedSessionId || 'global';
+        const activity = this.activityFor(sessionId);
+        const commandText = `/run ${args.join(' ')}`;
+        const previewTag = path.basename(fileSpec, path.extname(fileSpec)) || 'run';
+        this.lastSubmittedInput = { kind: 'builtin', name: 'run', rawArgs: args.join(' '), args: [...args] };
+        this.focusedPane = 'messages';
+        this.paneScroll.messages = 0;
+        this.paneScroll.process = 0;
+        this.beginExecutionPreview(sessionId, 'skill', { role: 'system', content: commandText }, previewTag);
+        activity.pushLine(`run ${commandText}`);
+        this.busy = true;
+        this.currentAbortController = new AbortController();
+        this.startAnimation();
+        this.statusLine = `Running ${commandText}...`;
+        this.requestRender();
+        try {
+            const result = await runFileCommand(this.workspaceRoot, fileSpec, runArgs, {
+                sessionId: this.selectedSessionId || undefined,
+                sandbox: this.options.sandbox,
+                signal: this.currentAbortController.signal,
+                onUserInput: (question) => this.requestClarification(question),
+                onEvent: (event) => {
+                    activity.handle(event);
+                    this.updatePreviewFromEvent(event);
+                    this.requestRender();
+                },
+            });
+            activity.finish();
+            await this.refreshCommands();
+            this.finishExecutionPreview({
+                persist: true,
+                finalText: result.answer || summarizeRunResult(result),
+                error: result.error,
+            });
+            this.statusLine = result.error ? `${commandText} failed.` : `${commandText} finished.`;
+        }
+        catch (error) {
+            activity.finish();
+            const message = error.message;
+            activity.pushLine(`[run] error ${message}`);
+            this.finishExecutionPreview({ persist: true, error: message });
+            this.statusLine = `${commandText} failed.`;
+        }
+        finally {
+            this.busy = false;
+            this.currentAbortController = null;
+            this.stopAnimation();
+            if (this.exitRequested) {
+                this.close();
+            }
+            else {
+                this.requestRender();
+            }
+        }
+    }
     async executeSkillCreator(commandName, specText) {
         const trimmedSpec = specText.trim();
         if (!trimmedSpec) {
@@ -1021,16 +1087,16 @@ class FullscreenTui {
             }
         }
     }
-    async executeShellCommand(commandText) {
+    async executeShellCommand(commandText, persistOutput = false) {
         const trimmedCommand = commandText.trim();
         if (!trimmedCommand) {
-            this.statusLine = 'Enter a shell command after !.';
+            this.statusLine = 'Enter a shell command after ! or !!.';
             this.requestRender();
             return;
         }
         const sessionId = this.selectedSessionId || 'global';
         const activity = this.activityFor(sessionId);
-        this.lastSubmittedInput = { kind: 'shell', command: trimmedCommand };
+        this.lastSubmittedInput = { kind: 'shell', command: trimmedCommand, persistOutput };
         this.focusedPane = 'messages';
         this.paneScroll.messages = 0;
         this.paneScroll.process = 0;
@@ -1038,14 +1104,15 @@ class FullscreenTui {
             role: 'system',
             kind: 'output',
             tag: 'shell',
-            content: `!${trimmedCommand}`,
+            content: `${persistOutput ? '!!' : '!'}${trimmedCommand}`,
         }, 'shell');
-        activity.pushLine(`shell !${trimmedCommand}`);
+        activity.pushLine(`shell ${persistOutput ? '!!' : '!'}${trimmedCommand}`);
         this.busy = true;
         this.currentAbortController = new AbortController();
         this.startAnimation();
-        this.statusLine = `Running !${trimmedCommand}...`;
+        this.statusLine = `Running ${persistOutput ? '!!' : '!'}${trimmedCommand}...`;
         this.requestRender();
+        let persistenceStarted = false;
         try {
             const result = await runShellCommand(this.workspaceRoot, trimmedCommand, {
                 sandbox: this.options.sandbox,
@@ -1057,16 +1124,31 @@ class FullscreenTui {
             });
             activity.finish();
             await this.refreshCommands();
-            this.finishExecutionPreview(result.success
-                ? { persist: true, finalText: formatShellCommandSummary(result) }
-                : { persist: true, error: formatShellCommandSummary(result) });
-            this.statusLine = result.success ? 'Shell command finished.' : 'Shell command failed.';
+            if (persistOutput) {
+                persistenceStarted = true;
+                const persistedSessionId = await this.persistShellCommandResult(trimmedCommand, result);
+                await this.refreshSessions({ createIfMissing: true, selectedSessionId: persistedSessionId });
+                this.finishExecutionPreview({ persist: false });
+                this.statusLine = result.success
+                    ? 'Shell command finished and was added to the session.'
+                    : 'Shell command failed and its output was added to the session.';
+            }
+            else {
+                this.finishExecutionPreview(result.success
+                    ? { persist: true, finalText: formatShellCommandSummary(result) }
+                    : { persist: true, error: formatShellCommandSummary(result) });
+                this.statusLine = result.success ? 'Shell command finished.' : 'Shell command failed.';
+            }
         }
         catch (error) {
             activity.finish();
             const message = error.message;
             this.finishExecutionPreview({ persist: true, error: message });
-            this.statusLine = isAbortError(error) ? 'Shell command cancelled.' : 'Shell command failed.';
+            this.statusLine = isAbortError(error)
+                ? 'Shell command cancelled.'
+                : persistOutput && persistenceStarted
+                    ? 'Shell command finished, but saving its transcript failed.'
+                    : 'Shell command failed.';
         }
         finally {
             this.busy = false;
@@ -1423,6 +1505,7 @@ class FullscreenTui {
                     '',
                     'Use F10 or Ctrl+G for the menu bar, Ctrl+W to cycle panes, and /cancel to stop a running execution.',
                     'Type !<command> to run a direct shell command in the configured workspace shell.',
+                    'Type !!<command> to run a shell command and append its transcript to the active session.',
                     'The Skills and Files menus open searchable pickers, and Ctrl+P opens the action palette directly.',
                 ].join('\n'), { preferredExtension: '.txt' });
                 return;
@@ -1974,7 +2057,7 @@ class FullscreenTui {
             return;
         }
         if (this.lastSubmittedInput.kind === 'shell') {
-            await this.executeShellCommand(this.lastSubmittedInput.command);
+            await this.executeShellCommand(this.lastSubmittedInput.command, this.lastSubmittedInput.persistOutput);
             return;
         }
         if (this.lastSubmittedInput.kind === 'builtin') {
@@ -2333,6 +2416,18 @@ class FullscreenTui {
         this.activityBySessionId.set(key, created);
         return created;
     }
+    async persistShellCommandResult(command, result) {
+        let sessionId = this.selectedSessionId;
+        if (!sessionId) {
+            await this.refreshSessions({ createIfMissing: true });
+            sessionId = this.selectedSessionId;
+        }
+        if (!sessionId) {
+            throw new Error('No conductor session available to persist shell output.');
+        }
+        await appendConductorSessionMessages(this.workspaceRoot, sessionId, buildPersistedShellTranscript(command, result));
+        return sessionId;
+    }
     requestRender() {
         if (this.renderTimer) {
             return;
@@ -2559,8 +2654,10 @@ class FullscreenTui {
             'System Asset Sources',
             `Conductor DML ${formatSystemAssetSourcePath(this.workspaceRoot, systemAssetSources.conductorDml)}`,
             `Conductor Prompt ${formatSystemAssetSourcePath(this.workspaceRoot, systemAssetSources.conductorPrompt)}`,
+            `Plan DML ${formatSystemAssetSourcePath(this.workspaceRoot, systemAssetSources.planDml)}`,
             `Skill Creator DML ${formatSystemAssetSourcePath(this.workspaceRoot, systemAssetSources.skillCreatorDml)}`,
             `Skill Creator Prompt ${formatSystemAssetSourcePath(this.workspaceRoot, systemAssetSources.skillCreatorPrompt)}`,
+            `Task Prompt ${formatSystemAssetSourcePath(this.workspaceRoot, systemAssetSources.taskPrompt)}`,
             'Changes apply on the next turn or /compile run. No TUI reload is required.',
             '',
             'Shell Execution',
@@ -2869,6 +2966,38 @@ async function startLineTui(workspaceRoot = process.cwd(), options = {}) {
                             console.log(helpLine);
                         }
                         continue;
+                    case 'run':
+                        if (parsed.args.length === 0) {
+                            console.log('Provide a DML file after /run.');
+                            continue;
+                        }
+                        console.log(divider('-'));
+                        console.log(`${paint('run', ANSI.dim)} /run ${parsed.args.join(' ')}`);
+                        console.log(divider('-'));
+                        {
+                            const printer = new LiveExecutionPrinter();
+                            try {
+                                await runFileCommand(workspaceRoot, parsed.args[0], parsed.args.slice(1), {
+                                    sessionId: session.id,
+                                    sandbox: options.sandbox,
+                                    onUserInput: async (question) => {
+                                        printer.finish();
+                                        console.log(`${paint('clarify', ANSI.yellow)} ${question}`);
+                                        return (await rl.question('> ')).trim();
+                                    },
+                                    onEvent: (event) => printer.handle(event),
+                                });
+                            }
+                            catch (error) {
+                                printer.finish();
+                                console.log(`${paint('error', ANSI.red)} ${error.message}`);
+                            }
+                            printer.finish();
+                        }
+                        console.log('');
+                        console.log(divider('-'));
+                        console.log('');
+                        continue;
                     case 'compile':
                     case 'skill-creator':
                         if (!parsed.rawArgs.trim()) {
@@ -2946,7 +3075,7 @@ async function startLineTui(workspaceRoot = process.cwd(), options = {}) {
                 console.log(divider('-'));
                 const printer = new LiveExecutionPrinter();
                 try {
-                    await runSkillCommand(workspaceRoot, parsed.name, parsed.args, {
+                    await runSlashCommand(workspaceRoot, parsed.name, parsed.args, {
                         sessionId: session.id,
                         sandbox: options.sandbox,
                         onUserInput: async (question) => {
@@ -3028,13 +3157,57 @@ export async function runSkillCommand(workspaceRoot, skillName, args, options =
     if (!command) {
         throw new Error(`Unknown skill: ${skillName}`);
     }
+    return executeRunnableCommand(workspaceRoot, {
+        inputText: `/${skillName}${args.length > 0 ? ` ${args.join(' ')}` : ''}`,
+        runPath: command.path,
+        childSlug: skillName,
+        skillName,
+    }, args, options);
+}
+export async function runSlashCommand(workspaceRoot, name, args, options = {}) {
+    const commands = await listCommands(workspaceRoot);
+    const command = commands.find((entry) => entry.name === name);
+    if (command) {
+        return executeRunnableCommand(workspaceRoot, {
+            inputText: `/${name}${args.length > 0 ? ` ${args.join(' ')}` : ''}`,
+            runPath: command.path,
+            childSlug: name,
+            skillName: name,
+        }, args, options);
+    }
+    const resolvedPlanPath = await resolveWorkspaceDmlPath(workspaceRoot, name, { mode: 'plans-only' });
+    if (!resolvedPlanPath) {
+        throw new Error(`Unknown skill or plan: ${name}`);
+    }
+    const childSlug = path.basename(resolvedPlanPath, path.extname(resolvedPlanPath)) || name;
+    return executeRunnableCommand(workspaceRoot, {
+        inputText: `/${name}${args.length > 0 ? ` ${args.join(' ')}` : ''}`,
+        runPath: resolvedPlanPath,
+        childSlug,
+        skillName: childSlug,
+    }, args, options);
+}
+export async function runFileCommand(workspaceRoot, fileSpec, args, options = {}) {
+    const resolvedPath = await resolveWorkspaceDmlPath(workspaceRoot, fileSpec, { mode: 'direct' });
+    if (!resolvedPath) {
+        throw new Error(`DML file not found: ${fileSpec}`);
+    }
+    const childSlug = path.basename(resolvedPath, path.extname(resolvedPath)) || 'run';
+    return executeRunnableCommand(workspaceRoot, {
+        inputText: `/run ${[fileSpec, ...args].join(' ')}`.trim(),
+        runPath: resolvedPath,
+        childSlug,
+        skillName: childSlug,
+    }, args, options);
+}
+async function executeRunnableCommand(workspaceRoot, target, args, options = {}) {
     const executionLog = options.sessionId
         ? createSessionExecutionLogWriter({
             workspaceRoot,
             sessionId: options.sessionId,
             executionKind: 'skill',
-            inputText: `/${skillName}${args.length > 0 ? ` ${args.join(' ')}` : ''}`,
-            skillName,
+            inputText: target.inputText,
+            skillName: target.skillName,
             args,
         })
         : null;
@@ -3043,14 +3216,14 @@ export async function runSkillCommand(workspaceRoot, skillName, args, options =
         options.onEvent?.(event);
     };
     try {
-        const result = await run(command.path, args, {
+        const result = await run(target.runPath, args, {
             configRoot: workspaceRoot,
             headless: true,
             stream: true,
             sandbox: options.sandbox,
             signal: options.signal,
             onUserInput: options.onUserInput,
-            onEvent: (event) => emitLogEvent({ scope: 'child', childSlug: skillName, event }),
+            onEvent: (event) => emitLogEvent({ scope: 'child', childSlug: target.childSlug, event }),
             onChildEvent: (childSlug, event) => emitLogEvent({ scope: 'child', childSlug, event }),
         });
         await executionLog?.finish({
@@ -3069,6 +3242,64 @@ export async function runSkillCommand(workspaceRoot, skillName, args, options =
         throw error;
     }
 }
+async function resolveWorkspaceDmlPath(workspaceRoot, fileSpec, options) {
+    const trimmed = fileSpec.trim();
+    if (!trimmed) {
+        return null;
+    }
+    const candidates = options.mode === 'plans-only'
+        ? buildPlanOnlyCandidates(workspaceRoot, trimmed)
+        : buildDirectDmlCandidates(workspaceRoot, trimmed);
+    for (const candidate of candidates) {
+        if (await fileExists(candidate)) {
+            return candidate;
+        }
+    }
+    return null;
+}
+function buildDirectDmlCandidates(workspaceRoot, fileSpec) {
+    const trimmed = fileSpec.trim();
+    const candidates = new Set();
+    const directPath = path.resolve(workspaceRoot, trimmed);
+    candidates.add(directPath);
+    if (!trimmed.endsWith('.dml')) {
+        candidates.add(path.resolve(workspaceRoot, `${trimmed}.dml`));
+    }
+    const normalized = trimLeadingPathSeparators(trimmed).replace(/\\/g, '/');
+    const planRelative = normalized.startsWith('plans/') ? normalized : path.posix.join('plans', normalized);
+    candidates.add(path.resolve(workspaceRoot, planRelative));
+    if (!planRelative.endsWith('.dml')) {
+        candidates.add(path.resolve(workspaceRoot, `${planRelative}.dml`));
+    }
+    return Array.from(candidates);
+}
+function buildPlanOnlyCandidates(workspaceRoot, fileSpec) {
+    const normalized = trimLeadingPathSeparators(fileSpec.trim()).replace(/\\/g, '/');
+    const planRelative = normalized.startsWith('plans/') ? normalized : path.posix.join('plans', normalized);
+    const plansRoot = path.resolve(workspaceRoot, 'plans');
+    const candidates = [
+        path.resolve(workspaceRoot, planRelative),
+        ...(planRelative.endsWith('.dml') ? [] : [path.resolve(workspaceRoot, `${planRelative}.dml`)]),
+    ];
+    return candidates.filter((candidate, index, all) => {
+        if (all.indexOf(candidate) !== index) {
+            return false;
+        }
+        return candidate === plansRoot || candidate.startsWith(`${plansRoot}${path.sep}`);
+    });
+}
+function trimLeadingPathSeparators(value) {
+    return value.replace(/^[/\\]+/, '');
+}
+async function fileExists(filePath) {
+    try {
+        await fs.access(filePath);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
 async function runSkillCreatorCommand(workspaceRoot, sessionId, spec, options = {}) {
     const trimmedSpec = spec.trim();
     if (!trimmedSpec) {
@@ -3163,6 +3394,41 @@ function formatShellCommandSummary(result) {
     }
     return result.summary || `Shell command failed with exit code ${result.exitCode}.`;
 }
+function buildPersistedShellTranscript(command, result) {
+    const sections = [
+        '[shell result]',
+        `Command: ${command}`,
+        `Summary: ${formatShellCommandSummary(result)}`,
+        `Backend: ${result.backendLabel ?? result.backend}`,
+        `Exit code: ${result.exitCode}`,
+    ];
+    const stdout = truncateShellTranscriptStream(result.stdout, 'stdout');
+    const stderr = truncateShellTranscriptStream(result.stderr, 'stderr');
+    if (stdout) {
+        sections.push(`stdout:\n${stdout}`);
+    }
+    if (stderr) {
+        sections.push(`stderr:\n${stderr}`);
+    }
+    if (!stdout && !stderr) {
+        sections.push('No stdout or stderr output.');
+    }
+    return [
+        { role: 'user', content: `[shell command]\n${command}` },
+        { role: 'assistant', content: sections.join('\n\n') },
+    ];
+}
+function truncateShellTranscriptStream(content, label) {
+    const trimmed = content.trim();
+    if (!trimmed) {
+        return '';
+    }
+    if (trimmed.length <= MAX_PERSISTED_SHELL_STREAM_CHARS) {
+        return trimmed;
+    }
+    const omitted = trimmed.length - MAX_PERSISTED_SHELL_STREAM_CHARS;
+    return `${trimmed.slice(0, MAX_PERSISTED_SHELL_STREAM_CHARS).trimEnd()}\n\n[${label} truncated: ${omitted} more chars omitted]`;
+}
 function isAbortError(error) {
     return error instanceof Error && error.name === 'AbortError';
 }
@@ -3254,8 +3520,11 @@ export function parseCommandBarInput(line) {
     if (trimmedStart.startsWith('\\!')) {
         return { kind: 'text', prompt: trimmedStart.slice(1).trim() };
     }
+    if (trimmedStart.startsWith('!!')) {
+        return { kind: 'shell', command: trimmedStart.slice(2).trim(), persistOutput: true };
+    }
     if (trimmedStart.startsWith('!')) {
-        return { kind: 'shell', command: trimmedStart.slice(1).trim() };
+        return { kind: 'shell', command: trimmedStart.slice(1).trim(), persistOutput: false };
     }
     const trimmed = line.trim();
     if (!trimmed.startsWith('/')) {
@@ -3613,6 +3882,7 @@ function buildHelpLines() {
         'commands',
         '/new [title]    create a new conductor session',
         '/sessions       refresh or choose sessions',
+        '/run <file> [args] run a workspace DML file directly',
         '/compile <spec> compile and publish a new local skill',
         '/skill-creator <spec> alias for /compile',
         '/set-model <model> [--slot <slot>] update the configured model selection',
@@ -3620,7 +3890,9 @@ function buildHelpLines() {
         '/help           show this help',
         '/quit           exit the TUI',
         '/<skill> [args] run a compiled skill directly',
+        '/<plan> [args]  run plans/<plan>.dml when no compiled skill matches',
         '!<command>     run a shell command directly in the workspace shell',
+        '!!<command>    run a shell command and add its result to the session transcript',
         'keys',
         'F10 / Ctrl+G    open the menu bar',
         'Ctrl+P          open the action palette',