deepclause-sdk 0.0.69 → 0.0.70

package/dist/cli/tui.js

@@ -12,7 +12,7 @@ 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;
@@ -829,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);
@@ -924,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,
@@ -963,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) {
@@ -2589,6 +2654,7 @@ 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)}`,
@@ -2900,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()) {
@@ -2977,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) => {
@@ -3059,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;
@@ -3074,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({
@@ -3100,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) {
@@ -3682,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',
@@ -3689,6 +3890,7 @@ 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',