prompt-language-shell 0.5.2 → 0.6.0

package/dist/handlers/execution.js

@@ -1,140 +0,0 @@
-import { ComponentName, FeedbackType, TaskType } from '../types/types.js';
-import { createAnswerDefinition, createConfigDefinitionWithKeys, createExecuteDefinition, createFeedback, createIntrospectDefinition, createValidateDefinition, markAsDone, } from '../services/components.js';
-import { StepType } from '../ui/Config.js';
-import { getCancellationMessage } from '../services/messages.js';
-import { exitApp } from '../services/process.js';
-import { withQueueHandler } from '../services/queue.js';
-import { createConfigExecutionAbortedHandler, createConfigExecutionFinishedHandler, } from './config.js';
-import { validateExecuteTasks } from '../services/execution-validator.js';
-/**
- * Creates all execution handlers
- */
-export function createExecutionHandlers(ops, taskHandlers) {
-    const onConfirmed = (tasks) => {
-        ops.setQueue(withQueueHandler(ComponentName.Confirm, (first) => {
-            const allIntrospect = tasks.every((task) => task.type === TaskType.Introspect);
-            const allAnswer = tasks.every((task) => task.type === TaskType.Answer);
-            const allConfig = tasks.every((task) => task.type === TaskType.Config);
-            const allExecute = tasks.every((task) => task.type === TaskType.Execute);
-            const service = ops.service;
-            if (!service) {
-                ops.addToTimeline(markAsDone(first), createFeedback(FeedbackType.Failed, 'Service not available'));
-                exitApp(1);
-                return [];
-            }
-            if (allIntrospect && tasks.length > 0) {
-                ops.addToTimeline(markAsDone(first));
-                return [
-                    createIntrospectDefinition(tasks, service, taskHandlers.introspect.onError, taskHandlers.introspect.onComplete, taskHandlers.introspect.onAborted),
-                ];
-            }
-            else if (allAnswer && tasks.length > 0) {
-                const question = tasks[0].action;
-                ops.addToTimeline(markAsDone(first));
-                return [
-                    createAnswerDefinition(question, service, taskHandlers.answer.onError, taskHandlers.answer.onComplete, taskHandlers.answer.onAborted),
-                ];
-            }
-            else if (allConfig && tasks.length > 0) {
-                const keys = tasks
-                    .map((task) => task.params?.key)
-                    .filter((key) => typeof key === 'string');
-                ops.addToTimeline(markAsDone(first));
-                const handleConfigFinished = (config) => {
-                    ops.setQueue(createConfigExecutionFinishedHandler(ops.addToTimeline, keys)(config));
-                };
-                const handleConfigAborted = () => {
-                    ops.setQueue(createConfigExecutionAbortedHandler(ops.addToTimeline)());
-                };
-                return [
-                    createConfigDefinitionWithKeys(keys, handleConfigFinished, handleConfigAborted),
-                ];
-            }
-            else if (allExecute && tasks.length > 0) {
-                // Validate config requirements before execution
-                const missingConfig = validateExecuteTasks(tasks);
-                if (missingConfig.length > 0) {
-                    // Config is missing - call VALIDATE tool to get contextual descriptions
-                    const keys = missingConfig.map((req) => req.path);
-                    const userRequest = tasks.map((t) => t.action).join(', ');
-                    ops.addToTimeline(markAsDone(first));
-                    // Create handlers for Validate completion
-                    const handleValidateComplete = (configWithDescriptions) => {
-                        ops.setQueue(withQueueHandler(ComponentName.Validate, (first) => {
-                            // Create CONFIG component with descriptions from VALIDATE
-                            const handleConfigFinished = (config) => {
-                                ops.setQueue(createConfigExecutionFinishedHandler(ops.addToTimeline, keys, tasks, service, taskHandlers.execute)(config));
-                            };
-                            const handleConfigAborted = () => {
-                                ops.setQueue(createConfigExecutionAbortedHandler(ops.addToTimeline)());
-                            };
-                            // Create config steps from validated descriptions
-                            const steps = configWithDescriptions.map((req) => {
-                                const keyParts = req.path.split('.');
-                                const shortKey = keyParts[keyParts.length - 1];
-                                // Extract description without the {path} suffix
-                                // Format from VALIDATE: "Description {path}"
-                                let description = req.description || req.path;
-                                const pathPattern = /\s*\{[^}]+\}\s*$/;
-                                description = description.replace(pathPattern, '').trim();
-                                const step = {
-                                    description,
-                                    key: shortKey,
-                                    path: req.path,
-                                    type: StepType.Text,
-                                    value: null,
-                                    validate: () => true,
-                                };
-                                return step;
-                            });
-                            // Mark Validate as done and move to timeline
-                            ops.addToTimeline(markAsDone(first));
-                            return [
-                                {
-                                    id: crypto.randomUUID(),
-                                    name: ComponentName.Config,
-                                    state: { done: false },
-                                    props: {
-                                        steps,
-                                        onFinished: handleConfigFinished,
-                                        onAborted: handleConfigAborted,
-                                    },
-                                },
-                            ];
-                        }));
-                    };
-                    const handleValidateError = (error) => {
-                        ops.addToTimeline(createFeedback(FeedbackType.Failed, error));
-                        exitApp(1);
-                    };
-                    const handleValidateAborted = () => {
-                        ops.addToTimeline(createFeedback(FeedbackType.Aborted, 'Configuration validation cancelled'));
-                        exitApp(0);
-                    };
-                    return [
-                        createValidateDefinition(missingConfig, userRequest, service, handleValidateError, handleValidateComplete, handleValidateAborted),
-                    ];
-                }
-                // No missing config - execute directly
-                ops.addToTimeline(markAsDone(first));
-                return [
-                    createExecuteDefinition(tasks, service, taskHandlers.execute.onError, taskHandlers.execute.onComplete, taskHandlers.execute.onAborted),
-                ];
-            }
-            else {
-                ops.addToTimeline(markAsDone(first), createFeedback(FeedbackType.Failed, 'I can only process one type of task at a time for now.'));
-                exitApp(0);
-                return [];
-            }
-        }));
-    };
-    const onCancelled = (tasks) => {
-        ops.setQueue(withQueueHandler(ComponentName.Confirm, (first) => {
-            const allIntrospect = tasks.every((task) => task.type === TaskType.Introspect);
-            const operation = allIntrospect ? 'introspection' : 'execution';
-            ops.addToTimeline(markAsDone(first), createFeedback(FeedbackType.Aborted, getCancellationMessage(operation)));
-            return undefined;
-        }, true, 0));
-    };
-    return { onConfirmed, onCancelled };
-}

package/dist/handlers/introspect.js

@@ -1,21 +0,0 @@
-import { ComponentName } from '../types/types.js';
-import { createReportDefinition } from '../services/components.js';
-import { createErrorHandler, withQueueHandler } from '../services/queue.js';
-/**
- * Creates all introspect handlers
- */
-export function createIntrospectHandlers(ops, handleAborted) {
-    const onError = (error) => {
-        ops.setQueue(createErrorHandler(ComponentName.Introspect, ops.addToTimeline)(error));
-    };
-    const onComplete = (message, capabilities) => {
-        ops.setQueue(withQueueHandler(ComponentName.Introspect, () => {
-            ops.addToTimeline(createReportDefinition(message, capabilities));
-            return undefined;
-        }, true, 0));
-    };
-    const onAborted = () => {
-        handleAborted('Introspection');
-    };
-    return { onError, onComplete, onAborted };
-}

package/dist/handlers/plan.js

@@ -1,79 +0,0 @@
-import { ComponentName, FeedbackType, TaskType } from '../types/types.js';
-import { createConfirmDefinition, createFeedback, createPlanDefinition, markAsDone, createRefinement, } from '../services/components.js';
-import { FeedbackMessages, formatErrorMessage, getRefiningMessage, } from '../services/messages.js';
-import { exitApp } from '../services/process.js';
-/**
- * Creates all plan handlers
- */
-export function createPlanHandlers(ops, handleAborted, executionHandlers) {
-    const onAborted = () => {
-        handleAborted('Task selection');
-    };
-    const createAbortHandler = (tasks) => {
-        const allIntrospect = tasks.every((task) => task.type === TaskType.Introspect);
-        if (allIntrospect) {
-            return () => {
-                handleAborted('Introspection');
-            };
-        }
-        return onAborted;
-    };
-    const onSelectionConfirmed = async (selectedTasks) => {
-        const refinementDef = createRefinement(getRefiningMessage(), () => {
-            handleAborted('Plan refinement');
-        });
-        ops.setQueue((currentQueue) => {
-            if (currentQueue.length === 0)
-                return currentQueue;
-            const [first] = currentQueue;
-            if (first.name === ComponentName.Plan) {
-                ops.addToTimeline(markAsDone(first));
-            }
-            return [refinementDef];
-        });
-        try {
-            const service = ops.service;
-            if (!service) {
-                ops.addToTimeline(createFeedback(FeedbackType.Failed, FeedbackMessages.UnexpectedError, 'Service not available'));
-                exitApp(1);
-                return;
-            }
-            const refinedCommand = selectedTasks
-                .map((task) => {
-                const action = task.action.toLowerCase().replace(/,/g, ' -');
-                const type = task.type;
-                return `${action} (type: ${type})`;
-            })
-                .join(', ');
-            const result = await service.processWithTool(refinedCommand, 'plan');
-            ops.setQueue((currentQueue) => {
-                if (currentQueue.length > 0 &&
-                    currentQueue[0].id === refinementDef.id) {
-                    ops.addToTimeline(markAsDone(currentQueue[0]));
-                }
-                return [];
-            });
-            const planDefinition = createPlanDefinition(result.message, result.tasks, createAbortHandler(result.tasks), undefined);
-            const confirmDefinition = createConfirmDefinition(() => {
-                executionHandlers.onConfirmed(result.tasks);
-            }, () => {
-                executionHandlers.onCancelled(result.tasks);
-            });
-            ops.addToTimeline(planDefinition);
-            ops.setQueue([confirmDefinition]);
-        }
-        catch (error) {
-            const errorMessage = formatErrorMessage(error);
-            ops.setQueue((currentQueue) => {
-                if (currentQueue.length > 0 &&
-                    currentQueue[0].id === refinementDef.id) {
-                    ops.addToTimeline(markAsDone(currentQueue[0]));
-                }
-                return [];
-            });
-            ops.addToTimeline(createFeedback(FeedbackType.Failed, FeedbackMessages.UnexpectedError, errorMessage));
-            exitApp(1);
-        }
-    };
-    return { onAborted, createAbortHandler, onSelectionConfirmed };
-}

package/dist/types/handlers.js

@@ -1 +0,0 @@
-export {};

package/dist/ui/AnswerDisplay.js

@@ -1,8 +0,0 @@
-import { jsx as _jsx } from "react/jsx-runtime";
-import { Box, Text } from 'ink';
-import { Colors } from '../services/colors.js';
-export function AnswerDisplay({ answer }) {
-    // Split answer into lines and display with indentation
-    const lines = answer.split('\n');
-    return (_jsx(Box, { flexDirection: "column", paddingLeft: 2, children: lines.map((line, index) => (_jsx(Text, { color: Colors.Text.Active, children: line }, index))) }));
-}

package/dist/ui/Column.js

@@ -1,7 +0,0 @@
-import { jsx as _jsx } from "react/jsx-runtime";
-import React from 'react';
-import { Box } from 'ink';
-import { Component } from './Component.js';
-export const Column = React.memo(({ items, debug }) => {
-    return (_jsx(Box, { marginTop: 1, marginBottom: 1, marginLeft: 1, flexDirection: "column", gap: 1, children: items.map((item) => (_jsx(Box, { children: _jsx(Component, { def: item, debug: debug }) }, item.id))) }));
-});