kanbango 3.6.2 → 3.8.0

package/mcp-server.js

@@ -11,13 +11,25 @@ const plan = require('./plan.js');
 const guiRegistry = require('./gui-registry.js');
 const playbook = require('./agent-playbook.js');
 
-const COLS = kanban.COLS;
 const READ_VIEWS = Object.keys(kanban.VIEW_FIELDS);
 const GUI_READY_TIMEOUT_MS = 8000;
 const GUI_READY_POLL_MS = 50;
 let guiProcess = null;
 let guiPort = null;
 
+function activeCols() {
+  return kanban.COLS.slice();
+}
+
+function transitionHint() {
+  const map = kanban.COLUMN_TRANSITIONS || {};
+  const parts = Object.keys(map).map((from) => {
+    const to = (map[from] || []).join('|');
+    return `${from}→${to || '(none)'}`;
+  });
+  return parts.join('; ') || 'see backlog/kanbango.json columns';
+}
+
 function normalizePort(value) {
   return guiRegistry.normalizeGuiPort(value);
 }
@@ -151,12 +163,23 @@ async function buildEpicLookup() {
 }
 
 async function formatTaskResult(task, returnShape) {
-  if (returnShape === 'none') return { ok: true };
+  if (returnShape === 'none') {
+    if (Array.isArray(task.unblocked_tasks) && task.unblocked_tasks.length > 0) {
+      return { ok: true, unblocked_tasks: task.unblocked_tasks };
+    }
+    return { ok: true };
+  }
   const epicLookup = await buildEpicLookup();
-  return kanban.shapeTask(task, {
+  const allTasks = await kanban.allTasks();
+  const shaped = kanban.shapeTask(task, {
     view: returnShape === 'full' ? 'full' : 'summary',
-    epicLookup
+    epicLookup,
+    allTasks
   });
+  if (Array.isArray(task.unblocked_tasks)) {
+    shaped.unblocked_tasks = task.unblocked_tasks;
+  }
+  return shaped;
 }
 
 function guiIdentity(extra = {}) {
@@ -317,6 +340,8 @@ const server = new Server(
 );
 
 server.setRequestHandler(ListToolsRequestSchema, async () => {
+  await require('./workflow.js').ensureBoardConfig();
+  const COLS = activeCols();
   return {
     tools: [
       {
@@ -327,8 +352,8 @@ server.setRequestHandler(ListToolsRequestSchema, async () => {
           properties: {
             operation: {
               type: 'string',
-              enum: ['list', 'show', 'list_epics', 'show_epic', 'help'],
-              description: 'list/show=tasks; list_epics/show_epic=initiative containers; help=token playbook',
+              enum: ['list', 'show', 'list_epics', 'show_epic', 'context', 'help'],
+              description: 'list/show=tasks; context=compact next action; list_epics/show_epic=initiative containers; help=token playbook',
               default: 'list'
             },
             task_id: {
@@ -452,6 +477,16 @@ server.setRequestHandler(ListToolsRequestSchema, async () => {
               description: 'Verification scenarios',
               items: { type: 'string' }
             },
+            depends_on: {
+              type: 'array',
+              description: 'Task ids that must be done before this task can enter active/gates',
+              items: { type: 'string' }
+            },
+            files: {
+              type: 'array',
+              description: 'Touched file paths for this task (create/update/plan_evidence)',
+              items: { type: 'string' }
+            },
             subtasks: {
               type: 'array',
               description: 'Full subtask list replace on update (send complete array, not a single toggle)',
@@ -504,8 +539,8 @@ server.setRequestHandler(ListToolsRequestSchema, async () => {
               enum: COLS,
               description:
                 'Target column for move (not col). Must be a legal transition from the current column. '
-                + 'icebox→planned; planned→active|icebox|testing; active→planned|testing|icebox; '
-                + 'testing→active|review; review→active|done; done→active. Illegal → INVALID_TRANSITION + allowed_columns.'
+                + `Allowed (from project config): ${transitionHint()}. `
+                + 'Illegal → INVALID_TRANSITION + allowed_columns.'
             },
             patch: {
               type: 'object',
@@ -523,31 +558,35 @@ server.setRequestHandler(ListToolsRequestSchema, async () => {
             steps: {
               type: 'array',
               items: { type: 'string' },
-              description: 'plan_create: implementation steps between red/green test steps'
+              description: 'create/plan_create: checklist texts → subtasks (create uses when subtasks omitted; plan_create uses as-is, no forced TDD steps)'
             },
             project_root: {
               type: 'string',
-              description: 'plan_create: root for test-runner detect (default cwd)'
+              description: 'plan_create: root for optional test-runner detect (default cwd); missing runner → null, not error'
             },
             diff: {
               type: 'string',
-              description: 'plan_evidence: short diff or summary (not whole repo)'
+              description: 'plan_evidence: short diff or note (one of diff/summary/test_command required)'
+            },
+            summary: {
+              type: 'string',
+              description: 'plan_evidence: short implementation summary (alternative to diff)'
             },
             test_command: {
               type: 'string',
-              description: 'plan_evidence: exact command run'
+              description: 'plan_evidence: optional exact command run'
             },
             stdout: {
               type: 'string',
-              description: 'plan_evidence: test stdout (truncate to last ~2KB if huge)'
+              description: 'plan_evidence: optional test stdout (truncate to last ~2KB if huge)'
             },
             stderr: {
               type: 'string',
-              description: 'plan_evidence: test stderr (truncate if huge)'
+              description: 'plan_evidence: optional test stderr (truncate if huge)'
             },
             exit_code: {
               type: 'integer',
-              description: 'plan_evidence: process exit code'
+              description: 'plan_evidence: optional process exit code'
             }
           },
           required: ['action'],
@@ -593,12 +632,23 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
           break;
         }
 
+        await require('./workflow.js').ensureBoardConfig();
+
+        if (operation === 'context') {
+          result = await kanban.getContextPayload({
+            epic: args.epic,
+            epic_id: args.epic_id
+          });
+          break;
+        }
+
         const readOptions = normalizeReadOptions(args, 'summary');
 
         if (operation === 'list') {
           await kanban.migrateEpicGroups();
           const epics = await kanban.listEpicEntities();
-          let tasks = await kanban.allTasks();
+          const allBoardTasks = await kanban.allTasks();
+          let tasks = allBoardTasks;
           if (args.col) {
             tasks = tasks.filter((task) => task.column === args.col);
           }
@@ -613,8 +663,7 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
             });
           }
 
-          // summary omits epic_goals; no lookup needed for list tokens
-          result = tasks.map((task) => kanban.shapeTask(task, readOptions));
+          result = tasks.map((task) => kanban.shapeTask(task, { ...readOptions, allTasks: allBoardTasks }));
         } else if (operation === 'show') {
           if (!args.task_id) {
             throw invalidRequest(
@@ -626,9 +675,11 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
 
           await kanban.migrateEpicGroups();
           const epicLookup = await buildEpicLookup();
+          const allTasks = await kanban.allTasks();
           result = kanban.shapeTask(await kanban.getTask(args.task_id), {
             ...readOptions,
-            epicLookup
+            epicLookup,
+            allTasks
           });
         } else if (operation === 'list_epics') {
           await kanban.migrateEpicGroups();
@@ -666,7 +717,7 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
         } else {
           throw invalidRequest(
             `Unknown operation: ${operation}`,
-            'Use one of: list, show, list_epics, show_epic, help',
+            'Use one of: list, show, list_epics, show_epic, context, help',
             { operation }
           );
         }
@@ -676,9 +727,19 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
       case 'kanban_manage': {
         const action = args.action;
         const returnShape = normalizeReturnShape(args.return);
+        await require('./workflow.js').ensureBoardConfig();
 
         switch (action) {
           case 'create': {
+            let subtasks = args.subtasks;
+            if (subtasks === undefined && Array.isArray(args.steps)) {
+              subtasks = args.steps.filter(Boolean).map(String).map((text, index) => ({
+                id: `st-${index + 1}`,
+                text,
+                done: false,
+                description: ''
+              }));
+            }
             const createPayload = {
               description: args.description,
               specs: args.specs,
@@ -686,8 +747,10 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
               out_of_scope: args.out_of_scope,
               acceptance_criteria: args.acceptance_criteria,
               test_cases: args.test_cases,
-              subtasks: args.subtasks,
-              notes: args.notes
+              subtasks,
+              notes: args.notes,
+              depends_on: args.depends_on,
+              files: args.files
             };
             const epicRef = args.epic_id || args.epic || '—';
             const created = await kanban.doCreate(args.title, args.col || 'planned', epicRef, createPayload);
@@ -842,6 +905,8 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
             if (args.test_cases !== undefined) patch.test_cases = args.test_cases;
             if (args.subtasks !== undefined) patch.subtasks = args.subtasks;
             if (args.notes !== undefined) patch.notes = args.notes;
+            if (args.depends_on !== undefined) patch.depends_on = args.depends_on;
+            if (args.files !== undefined) patch.files = args.files;
             if (args.adr !== undefined) patch.adr = args.adr;
             if (args.epic_id !== undefined) patch.epic_id = args.epic_id;
             else if (args.epic !== undefined) patch.epic = args.epic;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "kanbango",
-  "version": "3.6.2",
+  "version": "3.8.0",
   "description": "JSON-first local Kanban board with web GUI, CLI, and MCP server",
   "main": "index.js",
   "bin": {

package/plan.js

@@ -55,17 +55,13 @@ async function detectTestRunner(projectRoot = process.cwd()) {
     }
   }
 
-  throw planError('NO_TEST_RUNNER', 'No supported test runner was found',
-    'Add a supported project manifest or set OPENCODE_TEST_COMMAND', { project_root: projectRoot });
+  return null;
 }
 
 function planSubtasks(implementationSteps) {
-  const steps = [
-    'Write tests',
-    'Run tests and confirm red',
-    ...implementationSteps,
-    'Run tests and confirm green'
-  ];
+  const steps = Array.isArray(implementationSteps)
+    ? implementationSteps.filter(Boolean).map(String)
+    : [];
   return steps.map((text, index) => ({ id: `st-${index + 1}`, text, done: false, description: '' }));
 }
 
@@ -93,6 +89,8 @@ async function create(payload = {}) {
     test_cases: payload.test_cases,
     subtasks: planSubtasks(implementationSteps),
     notes: payload.notes,
+    depends_on: payload.depends_on,
+    files: payload.files,
     plan: { runner, status: 'active' },
     evidence: []
   });
@@ -116,28 +114,30 @@ async function advance(payload = {}) {
 }
 
 async function evidence(payload = {}) {
-  const required = ['diff', 'test_command', 'stdout', 'stderr', 'exit_code'];
-  for (const field of required) {
-    if (payload[field] === undefined) {
-      throw planError('MISSING_REQUIRED_FIELD', `${field} is required`,
-        'Provide diff, test_command, stdout, stderr, and exit_code', { field });
-    }
+  const diff = payload.diff !== undefined ? String(payload.diff) : '';
+  const summary = payload.summary !== undefined ? String(payload.summary) : '';
+  const testCommand = payload.test_command !== undefined ? String(payload.test_command) : '';
+  if (!diff && !summary && !testCommand) {
+    throw planError('MISSING_REQUIRED_FIELD', 'diff, summary, or test_command is required',
+      'Provide at least one of diff, summary, or test_command', { field: 'diff' });
   }
-  if (!Number.isInteger(payload.exit_code)) {
+  if (payload.exit_code !== undefined && !Number.isInteger(payload.exit_code)) {
     throw planError('VALIDATION_ERROR', 'exit_code must be an integer',
-      'Use the process exit code from the test command', { field: 'exit_code' });
+      'Use the process exit code from the test command, or omit exit_code', { field: 'exit_code' });
   }
   const task = await kanban.getTask(payload.task_id);
-  const entry = {
-    diff: String(payload.diff),
-    test_command: String(payload.test_command),
-    stdout: String(payload.stdout),
-    stderr: String(payload.stderr),
-    exit_code: payload.exit_code,
+  const patch = { evidence: [...task.evidence, {
+    diff,
+    test_command: testCommand,
+    stdout: payload.stdout !== undefined ? String(payload.stdout) : '',
+    stderr: payload.stderr !== undefined ? String(payload.stderr) : '',
+    exit_code: Number.isInteger(payload.exit_code) ? payload.exit_code : null,
+    summary,
     created: new Date().toISOString()
-  };
-  const updated = await kanban.updateTask(task.id, { evidence: [...task.evidence, entry] });
-  return result(updated, { evidence: entry });
+  }] };
+  if (payload.files !== undefined) patch.files = payload.files;
+  const updated = await kanban.updateTask(task.id, patch);
+  return result(updated, { evidence: patch.evidence[patch.evidence.length - 1] });
 }
 
 async function done(payload = {}) {
@@ -147,11 +147,15 @@ async function done(payload = {}) {
     throw planError('PLAN_INCOMPLETE', 'Plan has incomplete subtasks',
       'Advance every plan step before marking the workflow done', { incomplete });
   }
+  const workflow = require('./workflow.js');
+  const targetColumn = await workflow.planDoneColumn();
   const updated = await kanban.updateTask(task.id, {
-    column: 'testing',
+    column: targetColumn,
     plan: { ...(task.plan || {}), status: 'done' }
   });
-  return result(updated, { status: 'done', column: updated.column });
+  const extra = { status: 'done', column: updated.column };
+  if (Array.isArray(updated.unblocked_tasks)) extra.unblocked_tasks = updated.unblocked_tasks;
+  return result(updated, extra);
 }
 
 async function status(taskId) {

package/tests/run.js

@@ -5,6 +5,8 @@ function runNode(scriptPath, args, label) {
   const fullPath = path.join(process.cwd(), scriptPath);
   const result = spawnSync(process.execPath, [fullPath, ...(args || [])], {
     stdio: 'inherit',
+    // Agent shells often export KANBANGO_AUTO_GUI=1; MCP child tests would hang.
+    env: { ...process.env, KANBANGO_AUTO_GUI: '0' }
   });
   if (result.status !== 0) {
     console.error(`✗ ${label} failed`);
@@ -23,10 +25,13 @@ runNode(path.join('tests', 'fenced-text.test.js'), [], 'Fenced text test');
 runNode(path.join('tests', 'kanban-mermaid-vendor.test.js'), [], 'Kanban mermaid vendor route test');
 runNode(path.join('tests', 'plan-workflow.test.js'), [], 'Plan workflow test');
 runNode(path.join('tests', 'workflow-gates.test.js'), [], 'Workflow gates test');
+runNode(path.join('tests', 'board-config.test.js'), [], 'Board config columns/agents test');
+runNode(path.join('tests', 'config-wizard.test.js'), [], 'Config wizard TUI test');
 runNode(path.join('tests', 'kanban.js'), [], 'Kanban core test');
 runNode(path.join('tests', 'index.js'), [], 'Package index export test');
 runNode(path.join('tests', 'bin-kanban.test.js'), [], 'CLI bin/kanban test');
 runNode(path.join('tests', 'agent-playbook.test.js'), [], 'Agent playbook test');
+runNode(path.join('tests', 'agent-context.test.js'), [], 'Agent context / depends_on / files test');
 runNode(path.join('tests', 'epics.test.js'), [], 'Epics test');
 runNode(path.join('tests', 'kanban-epic-goals-adr.test.js'), [], 'Epic goals + ADR test');
 runNode(path.join('tests', 'delete-archive.test.js'), [], 'Delete/archive test');