@synergenius/flow-weaver-pack-weaver 0.9.59 → 0.9.77

package/dist/cli-handlers.js

@@ -1289,9 +1289,15 @@ export async function handleSession(opts) {
     const parallelism = opts.sessionParallel ?? 1;
     // Crash recovery
     if (continuous) {
-        const { TaskQueue } = await import('./bot/task-queue.js');
-        const recoveryQueue = new TaskQueue();
-        const recovered = await recoveryQueue.recoverOrphans();
+        const { TaskStore } = await import('./bot/task-store.js');
+        const recoveryStore = new TaskStore(projectDir);
+        // Recover orphaned in-progress tasks back to pending
+        const inProgressTasks = await recoveryStore.list({ status: 'in-progress' });
+        let recovered = 0;
+        for (const t of inProgressTasks) {
+            await recoveryStore.update(t.id, { status: 'pending' });
+            recovered++;
+        }
         if (recovered > 0)
             renderer.info(`Recovered ${recovered} orphaned task(s)`);
     }
@@ -1338,9 +1344,9 @@ export async function handleSession(opts) {
         return;
     }
     // Continuous mode: loop until deadline/maxTasks/interrupt
-    const { TaskQueue } = await import('./bot/task-queue.js');
+    const { TaskStore } = await import('./bot/task-store.js');
     const { isTransientError, getErrorGuidance } = await import('./bot/error-classifier.js');
-    const queue = new TaskQueue();
+    const taskStore = new TaskStore(projectDir);
     let taskCount = 0;
     let interrupted = false;
     let consecutiveErrors = 0;
@@ -1356,9 +1362,10 @@ export async function handleSession(opts) {
     const running = new Map();
     const filesInUse = new Set();
     const processTask = async (task) => {
+        const taskPayload = { id: task.id, instruction: task.title, description: task.description, targets: task.context.files };
         try {
             const result = await runWorkflow(workflowPath, {
-                params: { projectDir, taskJson: JSON.stringify(task) },
+                params: { projectDir, taskJson: JSON.stringify(taskPayload) },
                 verbose: opts.verbose,
                 dryRun: opts.dryRun,
                 config,
@@ -1371,19 +1378,19 @@ export async function handleSession(opts) {
                 result.summary.includes('nothing to') ||
                 result.outcome === 'no-op');
             if (isNoOp) {
-                await queue.markNoOp(task.id);
+                await taskStore.update(task.id, { status: 'done' });
                 sessionNoOp++;
                 consecutiveNoOps++;
                 consecutiveErrors = 0;
             }
             else if (result.success) {
-                await queue.markComplete(task.id);
+                await taskStore.update(task.id, { status: 'done' });
                 sessionCompleted++;
                 consecutiveErrors = 0;
                 consecutiveNoOps = 0;
             }
             else {
-                await queue.markFailed(task.id, result.summary || result.outcome || 'unknown error');
+                await taskStore.update(task.id, { status: 'failed' });
                 sessionFailed++;
                 consecutiveErrors++;
                 consecutiveNoOps = 0;
@@ -1399,14 +1406,14 @@ export async function handleSession(opts) {
             const msg = err instanceof Error ? err.message : String(err);
             const guidance = getErrorGuidance(msg);
             renderer.error(`Task ${task.id.slice(0, 8)} error`, guidance ? `${msg}\n  Hint: ${guidance}` : msg);
-            await queue.markFailed(task.id, msg);
+            await taskStore.update(task.id, { status: 'failed' });
             sessionFailed++;
             if (!isTransientError(err)) {
                 consecutiveErrors++;
             }
         }
         finally {
-            for (const f of task.targets ?? [])
+            for (const f of task.context.files)
                 filesInUse.delete(f);
             running.delete(task.id);
         }
@@ -1431,7 +1438,8 @@ export async function handleSession(opts) {
             await Promise.race(running.values());
             continue;
         }
-        const task = await queue.next();
+        const pendingTasks = await taskStore.list({ status: 'pending', limit: 1 });
+        const task = pendingTasks[0] ?? null;
         if (!task) {
             if (running.size > 0) {
                 // Tasks still running — wait for one to finish
@@ -1444,22 +1452,25 @@ export async function handleSession(opts) {
         }
         // Auto-decompose broad tasks into per-file tasks
         const { decomposeTask } = await import('./bot/task-decomposer.js');
-        const { decomposed, tasks: subtasks } = decomposeTask(task, projectDir);
+        const decomposable = { id: task.id, instruction: task.title, targets: task.context.files, priority: task.priority };
+        const { decomposed, tasks: subtasks } = decomposeTask(decomposable, projectDir);
         if (decomposed && subtasks.length > 1) {
             // Replace the broad task with per-file tasks
-            await queue.markComplete(task.id);
-            let decomposedCount = 0;
+            await taskStore.update(task.id, { status: 'done' });
             for (const st of subtasks) {
-                const { duplicate } = await queue.add({ instruction: st.instruction, mode: st.mode, targets: st.targets, priority: st.priority ?? 0 });
-                if (!duplicate)
-                    decomposedCount++;
+                await taskStore.create({
+                    title: st.instruction,
+                    description: st.instruction,
+                    priority: st.priority ?? 0,
+                    createdBy: 'ai',
+                });
             }
             renderer.info(`Decomposed into ${subtasks.length} per-file tasks`);
             continue;
         }
         // File conflict check: if task targets overlap with files in use, wait
-        const taskTargets = task.targets ?? [];
-        const hasConflict = taskTargets.some(f => filesInUse.has(f));
+        const taskTargets = task.context.files;
+        const hasConflict = taskTargets.some((f) => filesInUse.has(f));
         if (hasConflict && running.size > 0) {
             await Promise.race(running.values());
             continue;
@@ -1467,8 +1478,8 @@ export async function handleSession(opts) {
         taskCount++;
         if (opts.verbose)
             process.env.WEAVER_VERBOSE = '1';
-        renderer.taskStart(taskCount, task.instruction ?? task.id);
-        await queue.markRunning(task.id);
+        renderer.taskStart(taskCount, task.title ?? task.id);
+        await taskStore.update(task.id, { status: 'in-progress' });
         // Reserve files
         for (const f of taskTargets)
             filesInUse.add(f);
@@ -1678,8 +1689,9 @@ export async function handleSteer(opts) {
     console.log(`[weaver] Steering command sent: ${subcommand}${opts.botFile ? ' "' + opts.botFile + '"' : ''}`);
 }
 export async function handleQueue(opts) {
-    const { TaskQueue } = await import('./bot/task-queue.js');
-    const queue = new TaskQueue();
+    const { TaskStore } = await import('./bot/task-store.js');
+    const projectDir = process.env.WEAVER_PROJECT_DIR ?? process.cwd();
+    const store = new TaskStore(projectDir);
     const action = opts.botTask;
     if (!action || !['add', 'list', 'clear', 'remove', 'retry'].includes(action)) {
         console.error('[weaver] Usage: flow-weaver weaver queue <add|list|clear|remove|retry> [task|id]');
@@ -1692,17 +1704,12 @@ export async function handleQueue(opts) {
                 console.error('[weaver] Usage: flow-weaver weaver queue add "task instruction"');
                 process.exit(1);
             }
-            const { id, duplicate } = await queue.add({ instruction, priority: 0 });
-            if (duplicate) {
-                console.log(`[weaver] Task already queued (${id}).`);
-            }
-            else {
-                console.log(`[weaver] Task added: ${id}`);
-            }
+            const task = await store.create({ title: instruction, description: instruction, priority: 0, createdBy: 'user' });
+            console.log(`[weaver] Task added: ${task.id}`);
             break;
         }
         case 'list': {
-            const tasks = await queue.list();
+            const tasks = await store.list();
             if (opts.historyJson) {
                 console.log(JSON.stringify(tasks, null, 2));
             }
@@ -1710,15 +1717,20 @@ export async function handleQueue(opts) {
                 console.log('No tasks in queue.');
             }
             else {
-                console.log('ID'.padEnd(10) + 'STATUS'.padEnd(12) + 'PRIORITY'.padEnd(10) + 'INSTRUCTION');
+                console.log('ID'.padEnd(10) + 'STATUS'.padEnd(14) + 'PRIORITY'.padEnd(10) + 'TITLE');
                 for (const t of tasks) {
-                    console.log(t.id.padEnd(10) + t.status.padEnd(12) + String(t.priority).padEnd(10) + t.instruction.slice(0, 60));
+                    console.log(t.id.padEnd(10) + t.status.padEnd(14) + String(t.priority).padEnd(10) + t.title.slice(0, 60));
                 }
             }
             break;
         }
         case 'clear': {
-            const count = await queue.clear();
+            const tasks = await store.list();
+            let count = 0;
+            for (const t of tasks) {
+                await store.update(t.id, { status: 'cancelled' });
+                count++;
+            }
             console.log(`Cleared ${count} task(s).`);
             break;
         }
@@ -1728,20 +1740,33 @@ export async function handleQueue(opts) {
                 console.error('[weaver] Usage: flow-weaver weaver queue remove <id>');
                 process.exit(1);
             }
-            const removed = await queue.remove(id);
-            console.log(removed ? `Removed task ${id}.` : `No task found with id "${id}".`);
+            try {
+                await store.update(id, { status: 'cancelled' });
+                console.log(`Cancelled task ${id}.`);
+            }
+            catch {
+                console.log(`No task found with id "${id}".`);
+            }
             break;
         }
         case 'retry': {
             const id = opts.botFile;
             if (id) {
-                // Retry a specific task
-                const retried = await queue.retry(id);
-                console.log(retried ? `Task ${id} reset to pending.` : `No failed/running task found with id "${id}".`);
+                try {
+                    await store.update(id, { status: 'pending' });
+                    console.log(`Task ${id} reset to pending.`);
+                }
+                catch {
+                    console.log(`No task found with id "${id}".`);
+                }
             }
             else {
-                // Retry all failed tasks
-                const count = await queue.retryAll();
+                const failed = await store.list({ status: 'failed' });
+                let count = 0;
+                for (const t of failed) {
+                    await store.update(t.id, { status: 'pending' });
+                    count++;
+                }
                 console.log(`Reset ${count} failed task(s) to pending.`);
             }
             break;
@@ -1750,14 +1775,15 @@ export async function handleQueue(opts) {
 }
 export async function handleStatus(opts) {
     const store = new RunStore();
-    const { TaskQueue } = await import('./bot/task-queue.js');
-    const queue = new TaskQueue();
+    const { TaskStore } = await import('./bot/task-store.js');
+    const projectDir = process.env.WEAVER_PROJECT_DIR ?? process.cwd();
+    const taskStore = new TaskStore(projectDir);
     const orphans = store.checkOrphans();
     const recentRuns = store.list({ limit: 5 });
-    const tasks = await queue.list();
+    const tasks = await taskStore.list();
     const pending = tasks.filter(t => t.status === 'pending').length;
-    const running = tasks.filter(t => t.status === 'running').length;
-    const completed = tasks.filter(t => t.status === 'completed').length;
+    const running = tasks.filter(t => t.status === 'in-progress').length;
+    const completed = tasks.filter(t => t.status === 'done').length;
     const failed = tasks.filter(t => t.status === 'failed').length;
     if (opts.historyJson) {
         console.log(JSON.stringify({
@@ -2233,16 +2259,15 @@ export async function handleDoctor(opts) {
     }
     // Queue status
     try {
-        const { TaskQueue } = await import('./bot/task-queue.js');
-        process.env.WEAVER_PROJECT_DIR = dir;
-        const queue = new TaskQueue();
-        const tasks = await queue.list();
+        const { TaskStore } = await import('./bot/task-store.js');
+        const taskStore = new TaskStore(dir);
+        const tasks = await taskStore.list();
         const pending = tasks.filter(t => t.status === 'pending').length;
-        const running = tasks.filter(t => t.status === 'running').length;
-        checks.push({ label: 'Queue', status: 'ok', detail: `${pending} pending, ${running} running` });
+        const inProgress = tasks.filter(t => t.status === 'in-progress').length;
+        checks.push({ label: 'Queue', status: 'ok', detail: `${pending} pending, ${inProgress} in-progress` });
     }
     catch {
-        checks.push({ label: 'Queue', status: 'ok', detail: 'Empty (no queue file)' });
+        checks.push({ label: 'Queue', status: 'ok', detail: 'Empty (no tasks file)' });
     }
     // Plan file
     const planPath = path.join(dir, '.weaver-plan.md');