kanbango 3.6.2 → 5.1.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "kanbango",
-  "version": "3.6.2",
+  "version": "5.1.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: []
   });
@@ -100,44 +98,41 @@ async function create(payload = {}) {
 }
 
 async function advance(payload = {}) {
-  const task = await kanban.getTask(payload.task_id);
-  const index = payload.index !== undefined ? Number(payload.index)
-    : task.subtasks.findIndex((subtask) => !subtask.done);
-  if (!Number.isInteger(index) || index < 0 || index >= task.subtasks.length) {
-    throw planError('INVALID_SUBTASK_INDEX', 'No valid plan step was provided',
-      'Provide the zero-based index of an incomplete subtask', { index, total_subtasks: task.subtasks.length });
-  }
-  const subtasks = task.subtasks.map((subtask, subtaskIndex) => ({
-    ...subtask,
-    done: subtaskIndex === index ? true : subtask.done
-  }));
-  const updated = await kanban.updateTask(task.id, { subtasks });
+  const hasIndex = payload.index !== undefined && payload.index !== null && payload.index !== '';
+  const patch = hasIndex
+    ? { mark_subtask_done: Number(payload.index) }
+    : { mark_subtask_done: null };
+  const updated = await kanban.updateTask(payload.task_id, patch);
   return result(updated, { current_step: updated.subtasks.findIndex((subtask) => !subtask.done) });
 }
 
 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,
-    created: new Date().toISOString()
+  const patch = {
+    appendEvidence: {
+      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(payload.task_id, patch);
+  const evidenceList = updated.evidence || [];
+  return result(updated, { evidence: evidenceList[evidenceList.length - 1] });
 }
 
 async function done(payload = {}) {
@@ -147,11 +142,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/plugins/tui-kanban-controller.js

@@ -0,0 +1,117 @@
+const path = require('path');
+
+const LIST_COLUMNS = ['active', 'planned', 'icebox'];
+
+const kanbanPalette = {
+  commandName: 'kanban.open',
+  title: 'Kanban',
+  desc: 'Browse board and paste a start prompt',
+  category: 'Kanban',
+  slashName: 'kanban',
+  shortcut: 'ctrl+alt+k'
+};
+
+function defaultKanban() {
+  return require(path.join(__dirname, '..', 'kanban.js'));
+}
+
+function formatEpicLabel(epic) {
+  if (!epic || !epic.id) return '—';
+  const title = typeof epic.title === 'string' ? epic.title.trim() : '';
+  return title ? `${epic.id}/${title}` : String(epic.id);
+}
+
+function formatStartPrompt(task, epic) {
+  const id = task && task.id != null ? String(task.id) : '';
+  const title = task && task.title != null ? String(task.title) : '';
+  return `Zacznij implementować zadanie #${id}: ${title} z epiku ${formatEpicLabel(epic)}.`;
+}
+
+function epicLookup(epics) {
+  const byId = new Map();
+  for (const epic of epics || []) {
+    if (epic && epic.id) byId.set(epic.id, epic);
+  }
+  return byId;
+}
+
+function shapeRow(task, epicsById, allTasks, unmetDependencies) {
+  const unmet = unmetDependencies(task, allTasks) || [];
+  const epic = task.epic_id ? epicsById.get(task.epic_id) : null;
+  return {
+    id: task.id,
+    title: task.title || '',
+    column: task.column,
+    epic_id: task.epic_id || '',
+    epicTitle: epic && epic.title ? epic.title : '',
+    epicLabel: formatEpicLabel(epic || (task.epic_id ? { id: task.epic_id } : null)),
+    blocked: unmet.length > 0,
+    unmet_dependencies: unmet,
+    description: task.description || '',
+    acceptance_criteria: Array.isArray(task.acceptance_criteria) ? task.acceptance_criteria : [],
+    depends_on: Array.isArray(task.depends_on) ? task.depends_on : []
+  };
+}
+
+function toBoardRows(tasks, epics, helpers = {}) {
+  const filterTasksForList = helpers.filterTasksForList || ((list) => list);
+  const unmetDependencies = helpers.unmetDependencies || (() => []);
+  const filtered = filterTasksForList(tasks || [], epics || [], {});
+  const epicsById = epicLookup(epics);
+  const byColumn = new Map(LIST_COLUMNS.map((column) => [column, []]));
+  for (const task of filtered) {
+    if (!task || !byColumn.has(task.column)) continue;
+    byColumn.get(task.column).push(shapeRow(task, epicsById, tasks, unmetDependencies));
+  }
+  return LIST_COLUMNS.flatMap((column) => byColumn.get(column));
+}
+
+async function loadBoard(options = {}) {
+  const kanban = options.kanban || defaultKanban();
+  const cwd = options.cwd;
+  const previous = process.cwd();
+  let changed = false;
+  try {
+    if (cwd && cwd !== previous) {
+      process.chdir(cwd);
+      changed = true;
+    }
+    const tasks = await kanban.allTasks();
+    const epics = await kanban.listEpicEntities();
+    return {
+      rows: toBoardRows(tasks, epics, {
+        filterTasksForList: kanban.filterTasksForList,
+        unmetDependencies: kanban.unmetDependencies
+      }),
+      tasks,
+      epics
+    };
+  } finally {
+    if (changed) process.chdir(previous);
+  }
+}
+
+function moveSelection(index, delta, length) {
+  if (!length || length <= 0) return 0;
+  const next = Number(index || 0) + Number(delta || 0);
+  if (next < 0) return 0;
+  if (next >= length) return length - 1;
+  return next;
+}
+
+function selectedRow(rows, index) {
+  if (!Array.isArray(rows) || rows.length === 0) return null;
+  if (index < 0 || index >= rows.length) return null;
+  return rows[index];
+}
+
+module.exports = {
+  LIST_COLUMNS,
+  kanbanPalette,
+  formatEpicLabel,
+  formatStartPrompt,
+  toBoardRows,
+  loadBoard,
+  moveSelection,
+  selectedRow
+};

package/plugins/tui-kanban.tsx

@@ -0,0 +1,314 @@
+/** @jsxImportSource @opentui/solid */
+import { createRequire } from 'node:module';
+import type { TuiPlugin, TuiPluginApi, TuiPluginModule, TuiThemeCurrent } from '@opencode-ai/plugin/tui';
+import { createSignal, For, Show, type Accessor } from 'solid-js';
+
+type BoardRow = {
+  id: string;
+  title: string;
+  column: string;
+  epic_id: string;
+  epicTitle: string;
+  epicLabel: string;
+  blocked: boolean;
+  unmet_dependencies: Array<{ id: string }>;
+  description: string;
+  acceptance_criteria: string[];
+  depends_on: string[];
+};
+
+const requireController = createRequire(import.meta.url);
+const controller = requireController('./tui-kanban-controller.js') as {
+  kanbanPalette: {
+    commandName: string;
+    title: string;
+    desc: string;
+    category: string;
+    slashName: string;
+    shortcut: string;
+  };
+  formatStartPrompt: (
+    task: { id: string; title: string },
+    epic: { id?: string; title?: string } | null
+  ) => string;
+  loadBoard: (options?: { cwd?: string }) => Promise<{ rows: BoardRow[] }>;
+  moveSelection: (index: number, delta: number, length: number) => number;
+  selectedRow: (rows: BoardRow[], index: number) => BoardRow | null;
+};
+
+const id = 'kanbango.tui';
+type TuiApi = TuiPluginApi;
+type Theme = TuiThemeCurrent;
+
+type View =
+  | { status: 'loading' }
+  | { status: 'error'; message: string }
+  | { status: 'ready'; rows: BoardRow[]; selected: number };
+
+type DialogCtrl = {
+  view: Accessor<View>;
+  reload: () => Promise<void>;
+  move: (delta: number) => void;
+  confirm: () => Promise<void>;
+};
+
+let dialogOpen = false;
+let dialogCtrl: DialogCtrl | null = null;
+
+function closeKanbanDialog(api: TuiApi) {
+  dialogOpen = false;
+  dialogCtrl = null;
+  api.ui.dialog.clear();
+}
+
+function createDialogController(api: TuiApi): DialogCtrl {
+  const [view, setView] = createSignal<View>({ status: 'loading' });
+
+  const reload = async () => {
+    setView({ status: 'loading' });
+    try {
+      const board = await controller.loadBoard({ cwd: api.state.path.directory });
+      setView({
+        status: 'ready',
+        rows: board.rows,
+        selected: controller.moveSelection(0, 0, board.rows.length)
+      });
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      setView({ status: 'error', message });
+    }
+  };
+
+  const move = (delta: number) => {
+    setView((current) => {
+      if (current.status !== 'ready') return current;
+      return {
+        ...current,
+        selected: controller.moveSelection(current.selected, delta, current.rows.length)
+      };
+    });
+  };
+
+  const confirm = async () => {
+    const current = view();
+    if (current.status !== 'ready') return;
+    const row = controller.selectedRow(current.rows, current.selected);
+    if (!row) return;
+    const epic = row.epic_id ? { id: row.epic_id, title: row.epicTitle } : null;
+    const text = controller.formatStartPrompt(row, epic);
+    await api.client.tui.appendPrompt({ text });
+    closeKanbanDialog(api);
+  };
+
+  return { view, reload, move, confirm };
+}
+
+export function openKanbanDialog(api: TuiApi) {
+  const ctrl = createDialogController(api);
+  dialogCtrl = ctrl;
+  dialogOpen = true;
+  api.ui.dialog.setSize('large');
+  api.ui.dialog.replace(
+    () => <KanbanDialog api={api} ctrl={ctrl} />,
+    () => {
+      dialogOpen = false;
+      if (dialogCtrl === ctrl) dialogCtrl = null;
+    }
+  );
+  void ctrl.reload();
+}
+
+function registerPalette(api: TuiApi) {
+  api.keymap.registerLayer({
+    commands: [
+      {
+        name: controller.kanbanPalette.commandName,
+        title: controller.kanbanPalette.title,
+        desc: controller.kanbanPalette.desc,
+        category: controller.kanbanPalette.category,
+        namespace: 'palette',
+        slashName: controller.kanbanPalette.slashName,
+        run() {
+          openKanbanDialog(api);
+        }
+      }
+    ]
+  });
+}
+
+function registerShortcut(api: TuiApi) {
+  api.keymap.registerLayer({
+    enabled: () => !dialogOpen,
+    bindings: [
+      {
+        key: controller.kanbanPalette.shortcut,
+        cmd: () => openKanbanDialog(api),
+        desc: controller.kanbanPalette.title
+      }
+    ]
+  });
+}
+
+function registerDialogKeys(api: TuiApi) {
+  api.keymap.registerLayer({
+    enabled: () => dialogOpen && api.ui.dialog.open,
+    bindings: [
+      { key: 'up', cmd: () => dialogCtrl?.move(-1), desc: 'Previous task' },
+      { key: 'down', cmd: () => dialogCtrl?.move(1), desc: 'Next task' },
+      { key: 'k', cmd: () => dialogCtrl?.move(-1), desc: 'Previous task' },
+      { key: 'j', cmd: () => dialogCtrl?.move(1), desc: 'Next task' },
+      { key: 'return', cmd: () => void dialogCtrl?.confirm(), desc: 'Paste start prompt' },
+      { key: 'escape', cmd: () => closeKanbanDialog(api), desc: 'Close' }
+    ]
+  });
+}
+
+const tui: TuiPlugin = async (api) => {
+  registerPalette(api);
+  registerShortcut(api);
+  registerDialogKeys(api);
+};
+
+function KanbanDialog(props: { api: TuiApi; ctrl: DialogCtrl }) {
+  const theme = () => props.api.theme.current as Theme;
+  const state = () => props.ctrl.view();
+  const selected = () => {
+    const current = state();
+    if (current.status !== 'ready') return null;
+    return controller.selectedRow(current.rows, current.selected);
+  };
+
+  return (
+    <box flexDirection="column" width="100%" height="100%" padding={1} gap={1}>
+      <text>
+        <span style={{ fg: theme().primary, bold: true }}>Kanban</span>
+        <span style={{ fg: theme().textMuted }}>  · Enter paste start  · Esc close</span>
+      </text>
+      <Show when={state().status === 'loading'}>
+        <text fg={theme().textMuted}>Loading board…</text>
+      </Show>
+      <Show when={state().status === 'error'}>
+        <text fg={theme().error}>{(state() as { message: string }).message}</text>
+      </Show>
+      <Show when={state().status === 'ready'}>
+        <box flexDirection="row" width="100%" height="100%" gap={1} flexGrow={1}>
+          <TaskList
+            rows={(state() as Extract<View, { status: 'ready' }>).rows}
+            selected={(state() as Extract<View, { status: 'ready' }>).selected}
+            theme={theme()}
+          />
+          <DetailPanel row={selected()} theme={theme()} />
+        </box>
+      </Show>
+    </box>
+  );
+}
+
+function groupedRows(rows: BoardRow[]) {
+  const groups: Array<{ column: string; items: Array<{ row: BoardRow; index: number }> }> = [];
+  for (let index = 0; index < rows.length; index++) {
+    const row = rows[index];
+    const last = groups[groups.length - 1];
+    if (!last || last.column !== row.column) {
+      groups.push({ column: row.column, items: [{ row, index }] });
+    } else {
+      last.items.push({ row, index });
+    }
+  }
+  return groups;
+}
+
+function TaskList(props: { rows: BoardRow[]; selected: number; theme: Theme }) {
+  const groups = () => groupedRows(props.rows);
+  return (
+    <box
+      flexDirection="column"
+      flexGrow={1}
+      width="50%"
+      height="100%"
+      border={true}
+      borderColor={props.theme.border}
+      padding={1}
+      title=" tasks "
+      titleAlignment="left"
+    >
+      <Show when={props.rows.length > 0} fallback={<text fg={props.theme.textMuted}>No open tasks</text>}>
+        <For each={groups()}>
+          {(group) => (
+            <box flexDirection="column" gap={0}>
+              <text>
+                <span style={{ fg: props.theme.accent ?? props.theme.primary, bold: true }}>
+                  {group.column}
+                </span>
+              </text>
+              <For each={group.items}>
+                {(item) => (
+                  <TaskRow row={item.row} selected={item.index === props.selected} theme={props.theme} />
+                )}
+              </For>
+            </box>
+          )}
+        </For>
+      </Show>
+    </box>
+  );
+}
+
+function TaskRow(props: { row: BoardRow; selected: boolean; theme: Theme }) {
+  const mark = props.row.blocked ? '!' : ' ';
+  return (
+    <text>
+      <span style={{ fg: props.theme.primary }}>{props.selected ? '❯ ' : '  '}</span>
+      <span style={{ fg: props.row.blocked ? props.theme.error : props.theme.textMuted }}>{mark}</span>
+      <span style={{ fg: props.selected ? props.theme.primary : props.theme.textMuted }}>
+        {` ${props.row.id} `}
+      </span>
+      <span style={{ fg: props.selected ? props.theme.text : props.theme.textMuted }}>
+        {props.row.title}
+      </span>
+      <span style={{ fg: props.theme.textMuted }}>{`  ${props.row.epicLabel}`}</span>
+    </text>
+  );
+}
+
+function DetailPanel(props: { row: BoardRow | null; theme: Theme }) {
+  const row = () => props.row;
+  const ac = () => row()?.acceptance_criteria ?? [];
+  const unmet = () => (row()?.unmet_dependencies ?? []).map((item) => item.id).join(', ');
+  return (
+    <box
+      flexDirection="column"
+      flexGrow={1}
+      width="50%"
+      height="100%"
+      border={true}
+      borderColor={props.theme.borderActive ?? props.theme.primary}
+      padding={1}
+      title=" detail "
+      titleAlignment="left"
+      gap={0}
+    >
+      <Show when={row()} fallback={<text fg={props.theme.textMuted}>Select a task</text>}>
+        <text>
+          <span style={{ fg: props.theme.primary, bold: true }}>{row()!.id}</span>
+          <span style={{ fg: props.theme.text }}>{`  ${row()!.title}`}</span>
+        </text>
+        <text fg={props.theme.textMuted}>{`epic  ${row()!.epicLabel}`}</text>
+        <Show when={row()!.blocked}>
+          <text fg={props.theme.error}>{`blocked  ${unmet() || 'yes'}`}</text>
+        </Show>
+        <text fg={props.theme.textMuted}>
+          {`depends_on  ${row()!.depends_on.length ? row()!.depends_on.join(', ') : '—'}`}
+        </text>
+        <text fg={props.theme.text}>{row()!.description || '(no description)'}</text>
+        <text fg={props.theme.textMuted}>acceptance criteria</text>
+        <Show when={ac().length > 0} fallback={<text fg={props.theme.textMuted}>—</text>}>
+          <For each={ac()}>{(line) => <text fg={props.theme.text}>{`- ${line}`}</text>}</For>
+        </Show>
+      </Show>
+    </box>
+  );
+}
+
+const plugin: TuiPluginModule & { id: string } = { id, tui };
+export default plugin;