@pheem49/mint 1.5.5 → 1.6.1

package/src/System/task_manager.js

@@ -1,222 +0,0 @@
-const fs = require('fs');
-const path = require('path');
-const os = require('os');
-
-const CONFIG_DIR = path.join(os.homedir(), '.config', 'mint');
-const TASKS_FILE = path.join(CONFIG_DIR, 'tasks.json');
-
-// Ensure directory exists
-if (!fs.existsSync(CONFIG_DIR)) {
-    fs.mkdirSync(CONFIG_DIR, { recursive: true });
-}
-
-// Migration Logic: Move tasks.json from ~/.mint to ~/.config/mint
-if (!fs.existsSync(TASKS_FILE)) {
-    const legacyPath = path.join(os.homedir(), '.mint', 'tasks.json');
-    if (fs.existsSync(legacyPath)) {
-        try {
-            fs.copyFileSync(legacyPath, TASKS_FILE);
-            console.log('[TaskManager] Migrated tasks from ~/.mint');
-        } catch (e) { console.error('[TaskManager] Migration failed:', e); }
-    }
-}
-
-/**
- * Task Statuses:
- * - 'pending': Waiting for agent to pick up
- * - 'running': Agent is currently working on it
- * - 'completed': Done
- * - 'failed': Error occurred
- */
-
-function readTasks() {
-    if (!fs.existsSync(TASKS_FILE)) return [];
-    try {
-        const content = fs.readFileSync(TASKS_FILE, 'utf8');
-        return JSON.parse(content);
-    } catch (e) {
-        console.error('[TaskManager] Error reading tasks:', e.message);
-        return [];
-    }
-}
-
-function writeTasks(tasks) {
-    try {
-        fs.writeFileSync(TASKS_FILE, JSON.stringify(tasks, null, 2));
-    } catch (e) {
-        console.error('[TaskManager] Error writing tasks:', e.message);
-    }
-}
-
-function addTask(description) {
-    const tasks = readTasks();
-    const newTask = {
-        id: Date.now().toString(),
-        description,
-        status: 'pending',
-        createdAt: new Date().toISOString(),
-        updatedAt: new Date().toISOString(),
-        steps: [],
-        subtasks: [],
-        checkpoints: [],
-        artifacts: [],
-        retryCount: 0,
-        maxRetries: 1,
-        lastCheckpointAt: null,
-        result: null
-    };
-    tasks.push(newTask);
-    writeTasks(tasks);
-    return newTask;
-}
-
-function getPendingTask() {
-    const tasks = readTasks();
-    return tasks.find(t => t.status === 'pending');
-}
-
-function updateTask(id, updates) {
-    const tasks = readTasks();
-    const idx = tasks.findIndex(t => t.id === id);
-    if (idx !== -1) {
-        tasks[idx] = { ...tasks[idx], ...updates, updatedAt: new Date().toISOString() };
-        writeTasks(tasks);
-        return tasks[idx];
-    }
-    return null;
-}
-
-function getTask(id) {
-    return readTasks().find(t => t.id === id) || null;
-}
-
-function normalizeTask(task) {
-    return {
-        ...task,
-        steps: Array.isArray(task.steps) ? task.steps : [],
-        subtasks: Array.isArray(task.subtasks) ? task.subtasks : [],
-        checkpoints: Array.isArray(task.checkpoints) ? task.checkpoints : [],
-        artifacts: Array.isArray(task.artifacts) ? task.artifacts : [],
-        retryCount: Number.isFinite(task.retryCount) ? task.retryCount : 0,
-        maxRetries: Number.isFinite(task.maxRetries) ? task.maxRetries : 1
-    };
-}
-
-function mutateTask(id, mutator) {
-    const tasks = readTasks();
-    const idx = tasks.findIndex(t => t.id === id);
-    if (idx === -1) return null;
-    const next = normalizeTask(tasks[idx]);
-    mutator(next);
-    next.updatedAt = new Date().toISOString();
-    tasks[idx] = next;
-    writeTasks(tasks);
-    return next;
-}
-
-function addSubtask(taskId, title, extra = {}) {
-    return mutateTask(taskId, task => {
-        task.subtasks.push({
-            id: `${taskId}-${task.subtasks.length + 1}`,
-            title,
-            status: extra.status || 'pending',
-            createdAt: new Date().toISOString(),
-            updatedAt: new Date().toISOString(),
-            ...extra
-        });
-    });
-}
-
-function updateSubtask(taskId, subtaskId, updates = {}) {
-    return mutateTask(taskId, task => {
-        const subtask = task.subtasks.find(item => item.id === subtaskId);
-        if (!subtask) return;
-        Object.assign(subtask, updates, { updatedAt: new Date().toISOString() });
-    });
-}
-
-function addCheckpoint(taskId, checkpoint = {}) {
-    return mutateTask(taskId, task => {
-        const entry = {
-            id: `${taskId}-checkpoint-${task.checkpoints.length + 1}`,
-            time: new Date().toISOString(),
-            ...checkpoint
-        };
-        task.checkpoints.push(entry);
-        task.lastCheckpointAt = entry.time;
-        task.steps.push(entry);
-    });
-}
-
-function addArtifact(taskId, artifact = {}) {
-    return mutateTask(taskId, task => {
-        task.artifacts.push({
-            id: `${taskId}-artifact-${task.artifacts.length + 1}`,
-            time: new Date().toISOString(),
-            ...artifact
-        });
-    });
-}
-
-function failTaskWithRetry(id, errorMessage) {
-    return mutateTask(id, task => {
-        const retryCount = Number(task.retryCount) || 0;
-        const maxRetries = Number.isFinite(task.maxRetries) ? task.maxRetries : 1;
-        task.result = errorMessage;
-        task.retryCount = retryCount + 1;
-        task.status = task.retryCount <= maxRetries ? 'pending' : 'failed';
-        const checkpoint = {
-            id: `${id}-checkpoint-${task.checkpoints.length + 1}`,
-            time: new Date().toISOString(),
-            phase: task.status === 'pending' ? 'retry_scheduled' : 'failed',
-            message: errorMessage,
-            retryCount: task.retryCount,
-            maxRetries
-        };
-        task.checkpoints.push(checkpoint);
-        task.steps.push(checkpoint);
-    });
-}
-
-function resumeRunningTasks() {
-    const resumed = [];
-    const tasks = readTasks().map(task => {
-        if (task.status !== 'running') return task;
-        const normalized = normalizeTask(task);
-        normalized.status = 'pending';
-        const checkpoint = {
-            id: `${normalized.id}-checkpoint-${normalized.checkpoints.length + 1}`,
-            time: new Date().toISOString(),
-            phase: 'resume_after_restart',
-            message: 'Task was running during shutdown and has been re-queued.'
-        };
-        normalized.checkpoints.push(checkpoint);
-        normalized.steps.push(checkpoint);
-        normalized.updatedAt = new Date().toISOString();
-        resumed.push(normalized);
-        return normalized;
-    });
-    writeTasks(tasks);
-    return resumed;
-}
-
-function clearCompletedTasks() {
-    const tasks = readTasks();
-    const activeTasks = tasks.filter(t => t.status === 'pending' || t.status === 'running');
-    writeTasks(activeTasks);
-}
-
-module.exports = {
-    addTask,
-    addArtifact,
-    addCheckpoint,
-    addSubtask,
-    failTaskWithRetry,
-    getTask,
-    getPendingTask,
-    resumeRunningTasks,
-    updateTask,
-    updateSubtask,
-    readTasks,
-    clearCompletedTasks
-};

package/src/System/tool_registry.js

@@ -1,293 +0,0 @@
-const TOOL_REGISTRY = Object.freeze({
-    none: {
-        permission: 'safe',
-        required: [],
-        description: 'No action.'
-    },
-    web_search: {
-        permission: 'safe',
-        required: ['query'],
-        codeAgentOnly: true,
-        description: 'Search the internet when outside knowledge is required.'
-    },
-    list_files: {
-        permission: 'safe',
-        required: [],
-        codeAgentOnly: true,
-        description: 'List files under a workspace-relative path.'
-    },
-    read_file: {
-        permission: 'safe',
-        required: ['path'],
-        codeAgentOnly: true,
-        description: 'Read a workspace file, optionally bounded by startLine/endLine.'
-    },
-    search_code: {
-        permission: 'safe',
-        required: ['query'],
-        codeAgentOnly: true,
-        description: 'Search text in the workspace.'
-    },
-    find_path: {
-        permission: 'safe',
-        required: ['query'],
-        chatAction: true,
-        description: 'Find files or folders by name.'
-    },
-    run_shell: {
-        permission: 'approval',
-        required: ['command'],
-        codeAgentOnly: true,
-        important: true,
-        description: 'Run a non-destructive shell command after user approval.'
-    },
-    verify: {
-        permission: 'approval',
-        required: [],
-        codeAgentOnly: true,
-        important: true,
-        description: 'Run test/build/lint verification commands after user approval.'
-    },
-    plan: {
-        permission: 'approval',
-        required: ['plan'],
-        codeAgentOnly: true,
-        description: 'Present a multi-file edit plan before changing files.'
-    },
-    apply_patch: {
-        permission: 'approval',
-        required: ['patch'],
-        codeAgentOnly: true,
-        important: true,
-        description: 'Patch an existing file after user approval.'
-    },
-    write_file: {
-        permission: 'approval',
-        required: ['path', 'content'],
-        codeAgentOnly: true,
-        important: true,
-        description: 'Create or replace a file after user approval.'
-    },
-    ask_user: {
-        permission: 'safe',
-        required: ['question'],
-        codeAgentOnly: true,
-        description: 'Ask the user for clarification.'
-    },
-    open_url: {
-        permission: 'safe',
-        required: ['target'],
-        chatAction: true,
-        description: 'Open a URL.'
-    },
-    search: {
-        permission: 'safe',
-        required: ['target'],
-        chatAction: true,
-        description: 'Open a web search.'
-    },
-    open_app: {
-        permission: 'safe',
-        required: ['target'],
-        chatAction: true,
-        description: 'Open a local application.'
-    },
-    web_automation: {
-        permission: 'safe',
-        required: ['target'],
-        chatAction: true,
-        important: true,
-        description: 'Perform browser automation.'
-    },
-    create_folder: {
-        permission: 'safe',
-        required: ['target'],
-        chatAction: true,
-        description: 'Create a folder.'
-    },
-    open_file: {
-        permission: 'safe',
-        required: ['target'],
-        chatAction: true,
-        description: 'Open a local file.'
-    },
-    open_folder: {
-        permission: 'safe',
-        required: ['target'],
-        chatAction: true,
-        description: 'Open a local folder.'
-    },
-    delete_file: {
-        permission: 'dangerous',
-        required: ['target'],
-        chatAction: true,
-        important: true,
-        description: 'Delete a file only after explicit dangerous-action permission.'
-    },
-    clipboard_write: {
-        permission: 'safe',
-        required: ['target'],
-        chatAction: true,
-        description: 'Write text to clipboard.'
-    },
-    learn_file: {
-        permission: 'safe',
-        required: ['target'],
-        chatAction: true,
-        description: 'Index a file into the knowledge base.'
-    },
-    learn_folder: {
-        permission: 'safe',
-        required: ['target'],
-        chatAction: true,
-        description: 'Index a folder into the knowledge base.'
-    },
-    system_info: {
-        permission: 'safe',
-        required: [],
-        chatAction: true,
-        description: 'Read local system info, or weather when target is a city.'
-    },
-    plugin: {
-        permission: 'safe',
-        required: ['pluginName', 'target'],
-        chatAction: true,
-        description: 'Run a Mint plugin.'
-    },
-    mcp_tool: {
-        permission: 'safe',
-        required: ['server', 'target'],
-        chatAction: true,
-        description: 'Call an MCP tool.'
-    },
-    mouse_click: {
-        permission: 'safe',
-        required: ['x', 'y'],
-        chatAction: true,
-        important: true,
-        description: 'Click at screen coordinates.'
-    },
-    mouse_move: {
-        permission: 'safe',
-        required: ['x', 'y'],
-        chatAction: true,
-        description: 'Move the mouse.'
-    },
-    type_text: {
-        permission: 'safe',
-        required: ['target'],
-        chatAction: true,
-        important: true,
-        description: 'Type text into the active UI.'
-    },
-    key_tap: {
-        permission: 'safe',
-        required: ['target'],
-        chatAction: true,
-        important: true,
-        description: 'Press a key.'
-    },
-    system_automation: {
-        permission: 'approval',
-        required: ['target'],
-        chatAction: true,
-        important: true,
-        description: 'Change system settings after approval.'
-    },
-    finish: {
-        permission: 'safe',
-        required: ['summary'],
-        codeAgentOnly: true,
-        description: 'Finish the task and reply.'
-    }
-});
-
-function getTool(name) {
-    return TOOL_REGISTRY[name] || null;
-}
-
-function listToolNames(filter = {}) {
-    return Object.entries(TOOL_REGISTRY)
-        .filter(([, tool]) => {
-            if (filter.chatAction === true && tool.chatAction !== true) return false;
-            if (filter.codeAgent === true && tool.chatAction === true && tool.codeAgentOnly !== true) return true;
-            return true;
-        })
-        .map(([name]) => name);
-}
-
-function listChatActionNames() {
-    return Object.entries(TOOL_REGISTRY)
-        .filter(([, tool]) => tool.chatAction === true)
-        .map(([name]) => name);
-}
-
-function listCodeAgentActionNames() {
-    return Object.entries(TOOL_REGISTRY)
-        .filter(([, tool]) => tool.codeAgentOnly === true || tool.chatAction === true || tool.required)
-        .map(([name]) => name);
-}
-
-function isEmptyToolValue(value) {
-    if (value === undefined || value === null) return true;
-    if (typeof value === 'string') return value.trim() === '';
-    if (Array.isArray(value)) return value.length === 0;
-    if (typeof value === 'object') return Object.keys(value).length === 0;
-    return false;
-}
-
-function validateToolInput(action, input = {}) {
-    const tool = getTool(action);
-    if (!tool) {
-        throw new Error(`Unsupported action: ${action}`);
-    }
-
-    const missing = (tool.required || []).filter(field => {
-        if (!isEmptyToolValue(input[field])) return false;
-        if (field === 'target' && (!isEmptyToolValue(input.path) || !isEmptyToolValue(input.query))) return false;
-        if (field === 'query' && !isEmptyToolValue(input.target)) return false;
-        return true;
-    });
-    if (missing.length > 0) {
-        throw new Error(`Action "${action}" is missing required input field(s): ${missing.join(', ')}`);
-    }
-
-    if (action === 'apply_patch') {
-        const patchInput = input.patch || {};
-        if (!patchInput.path || !Array.isArray(patchInput.hunks) || patchInput.hunks.length === 0) {
-            throw new Error('Action "apply_patch" requires input.patch.path and at least one hunk.');
-        }
-    }
-
-    return tool;
-}
-
-function isImportantAction(action) {
-    const tool = getTool(action);
-    return !!(tool && tool.important);
-}
-
-function buildChatActionTypeUnion() {
-    return ['none', ...listChatActionNames()].filter((name, index, arr) => arr.indexOf(name) === index).map(name => `"${name}"`).join(' | ');
-}
-
-function buildToolPromptSection() {
-    const lines = ['\n\nAVAILABLE BUILT-IN ACTIONS:'];
-    for (const name of listChatActionNames()) {
-        const tool = getTool(name);
-        lines.push(`- ${name}: ${tool.description}`);
-    }
-    return lines.join('\n');
-}
-
-module.exports = {
-    TOOL_REGISTRY,
-    getTool,
-    listToolNames,
-    listChatActionNames,
-    listCodeAgentActionNames,
-    validateToolInput,
-    isImportantAction,
-    buildChatActionTypeUnion,
-    buildToolPromptSection
-};