@treenity/mods 3.0.1

package/board/board.test.ts

@@ -0,0 +1,212 @@
+// Board task tests — status flow, actions, field updates
+
+import { type NodeData, resolve } from '@treenity/core';
+import './types';
+import { createMemoryTree } from '@treenity/core/tree';
+import assert from 'node:assert/strict';
+import { describe, it } from 'node:test';
+
+function makeTask(overrides?: Partial<NodeData>): NodeData {
+  return {
+    $path: '/board/data/t-1',
+    $type: 'board.task',
+    title: 'Test task',
+    description: '',
+    status: 'backlog',
+    assignee: '',
+    priority: 'normal',
+    result: '',
+    createdAt: Date.now(),
+    updatedAt: 0,
+    ...overrides,
+  } as NodeData;
+}
+
+async function execAction(store: ReturnType<typeof createMemoryTree>, path: string, action: string, data?: unknown) {
+  const handler = resolve('board.task', `action:${action}`) as any;
+  assert.ok(handler, `action:${action} must be registered`);
+  const node = await store.get(path);
+  assert.ok(node, `node at ${path} must exist`);
+  await handler({ node, comp: node, store, signal: AbortSignal.timeout(5000) }, data);
+  return node;
+}
+
+describe('board.task registration', () => {
+  it('registers all expected actions', () => {
+    const actions = ['assign', 'start', 'submit', 'approve', 'reject', 'reopen'];
+    for (const action of actions) {
+      assert.ok(resolve('board.task', `action:${action}`), `action:${action} should be registered`);
+    }
+  });
+});
+
+describe('board.task.assign', () => {
+  it('sets assignee and moves to todo', async () => {
+    const store = createMemoryTree();
+    await store.set(makeTask());
+
+    const node = await execAction(store, '/board/data/t-1', 'assign', { to: 'alice' });
+    assert.equal(node.assignee, 'alice');
+    assert.equal(node.status, 'todo');
+    assert.ok((node.updatedAt as number) > 0);
+  });
+
+  it('trims whitespace from assignee', async () => {
+    const store = createMemoryTree();
+    await store.set(makeTask());
+
+    const node = await execAction(store, '/board/data/t-1', 'assign', { to: '  bob  ' });
+    assert.equal(node.assignee, 'bob');
+  });
+
+  it('throws on empty assignee', async () => {
+    const store = createMemoryTree();
+    await store.set(makeTask());
+
+    await assert.rejects(
+      () => execAction(store, '/board/data/t-1', 'assign', { to: '' }),
+      (err: Error) => err.message.includes('assignee'),
+    );
+  });
+});
+
+describe('board.task.start', () => {
+  it('moves from backlog to doing', async () => {
+    const store = createMemoryTree();
+    await store.set(makeTask({ status: 'backlog' }));
+
+    const node = await execAction(store, '/board/data/t-1', 'start');
+    assert.equal(node.status, 'doing');
+  });
+
+  it('moves from todo to doing', async () => {
+    const store = createMemoryTree();
+    await store.set(makeTask({ status: 'todo' }));
+
+    const node = await execAction(store, '/board/data/t-1', 'start');
+    assert.equal(node.status, 'doing');
+  });
+
+  it('throws from review', async () => {
+    const store = createMemoryTree();
+    await store.set(makeTask({ status: 'review' }));
+
+    await assert.rejects(
+      () => execAction(store, '/board/data/t-1', 'start'),
+      (err: Error) => err.message.includes('review'),
+    );
+  });
+});
+
+describe('board.task.submit', () => {
+  it('moves from doing to review', async () => {
+    const store = createMemoryTree();
+    await store.set(makeTask({ status: 'doing' }));
+
+    const node = await execAction(store, '/board/data/t-1', 'submit');
+    assert.equal(node.status, 'review');
+  });
+
+  it('stores result in result field', async () => {
+    const store = createMemoryTree();
+    await store.set(makeTask({ status: 'doing' }));
+
+    const node = await execAction(store, '/board/data/t-1', 'submit', { result: 'done it' });
+    assert.equal(node.result, 'done it');
+  });
+
+  it('throws from backlog', async () => {
+    const store = createMemoryTree();
+    await store.set(makeTask({ status: 'backlog' }));
+
+    await assert.rejects(
+      () => execAction(store, '/board/data/t-1', 'submit'),
+      (err: Error) => err.message.includes('backlog'),
+    );
+  });
+});
+
+describe('board.task.approve', () => {
+  it('moves from review to done', async () => {
+    const store = createMemoryTree();
+    await store.set(makeTask({ status: 'review' }));
+
+    const node = await execAction(store, '/board/data/t-1', 'approve');
+    assert.equal(node.status, 'done');
+  });
+
+  it('throws from doing', async () => {
+    const store = createMemoryTree();
+    await store.set(makeTask({ status: 'doing' }));
+
+    await assert.rejects(
+      () => execAction(store, '/board/data/t-1', 'approve'),
+      (err: Error) => err.message.includes('doing'),
+    );
+  });
+});
+
+describe('board.task.reject', () => {
+  it('moves from review back to doing', async () => {
+    const store = createMemoryTree();
+    await store.set(makeTask({ status: 'review' }));
+
+    const node = await execAction(store, '/board/data/t-1', 'reject');
+    assert.equal(node.status, 'doing');
+  });
+
+  it('stores rejection reason in result', async () => {
+    const store = createMemoryTree();
+    await store.set(makeTask({ status: 'review' }));
+
+    const node = await execAction(store, '/board/data/t-1', 'reject', { reason: 'needs tests' });
+    assert.ok((node.result as string).includes('needs tests'));
+  });
+
+  it('throws from backlog', async () => {
+    const store = createMemoryTree();
+    await store.set(makeTask({ status: 'backlog' }));
+
+    await assert.rejects(
+      () => execAction(store, '/board/data/t-1', 'reject'),
+      (err: Error) => err.message.includes('backlog'),
+    );
+  });
+});
+
+describe('board.task.reopen', () => {
+  it('resets to backlog, clears assignee and result', async () => {
+    const store = createMemoryTree();
+    await store.set(makeTask({ status: 'done', assignee: 'alice', result: 'old result' }));
+
+    const node = await execAction(store, '/board/data/t-1', 'reopen');
+    assert.equal(node.status, 'backlog');
+    assert.equal(node.assignee, '');
+    assert.equal(node.result, '');
+    assert.ok((node.updatedAt as number) > 0);
+  });
+});
+
+describe('board.task full lifecycle', () => {
+  it('backlog → assign → start → submit → approve', async () => {
+    const store = createMemoryTree();
+    await store.set(makeTask());
+
+    await execAction(store, '/board/data/t-1', 'assign', { to: 'ai-agent' });
+    const a1 = await store.get('/board/data/t-1');
+    assert.equal(a1?.status, 'todo');
+
+    await execAction(store, '/board/data/t-1', 'start');
+    const a2 = await store.get('/board/data/t-1');
+    assert.equal(a2?.status, 'doing');
+
+    await execAction(store, '/board/data/t-1', 'submit', { result: 'implemented' });
+    const a3 = await store.get('/board/data/t-1');
+    assert.equal(a3?.status, 'review');
+    assert.equal(a3?.result, 'implemented');
+
+    await execAction(store, '/board/data/t-1', 'approve');
+    const a4 = await store.get('/board/data/t-1');
+    assert.equal(a4?.status, 'done');
+  });
+});

package/board/client.ts

@@ -0,0 +1 @@
+import './view';

package/board/seed.ts

@@ -0,0 +1,26 @@
+// Board seed — kanban at /board, typed columns with query mounts
+
+import { type NodeData } from '@treenity/core';
+import { registerPrefab } from '@treenity/core/mod';
+
+registerPrefab('board', 'seed', [
+  { $path: 'board', $type: 'board.kanban' },
+  { $path: 'board/data', $type: 'dir' },
+
+  // Typed columns — each is a board.column + query mount
+  { $path: 'board/backlog', $type: 'board.column', label: 'Backlog', color: 'border-zinc-400', order: 0,
+    mount: { $type: 't.mount.query' },
+    query: { $type: 'query', source: '/board/data', match: { status: 'backlog' } } },
+  { $path: 'board/todo', $type: 'board.column', label: 'To Do', color: 'border-blue-400', order: 1,
+    mount: { $type: 't.mount.query' },
+    query: { $type: 'query', source: '/board/data', match: { status: 'todo' } } },
+  { $path: 'board/doing', $type: 'board.column', label: 'In Progress', color: 'border-yellow-400', order: 2,
+    mount: { $type: 't.mount.query' },
+    query: { $type: 'query', source: '/board/data', match: { status: 'doing' } } },
+  { $path: 'board/review', $type: 'board.column', label: 'Review', color: 'border-purple-400', order: 3,
+    mount: { $type: 't.mount.query' },
+    query: { $type: 'query', source: '/board/data', match: { status: 'review' } } },
+  { $path: 'board/done', $type: 'board.column', label: 'Done', color: 'border-green-400', order: 4,
+    mount: { $type: 't.mount.query' },
+    query: { $type: 'query', source: '/board/data', match: { status: 'done' } } },
+] as NodeData[], undefined, { tier: 'core' });

package/board/server.ts

@@ -0,0 +1,5 @@
+// Board module — types + seed
+// No bridge actions — AI chat is a separate component (ECS composition)
+
+import './types';
+import './seed';

package/board/types.ts

@@ -0,0 +1,87 @@
+// Board task — universal task management, dogfooded inside Treenity
+
+import { registerType } from '@treenity/core/comp';
+
+/** Task card — status-driven workflow with assignment and priority */
+export class BoardTask {
+  title = '';
+  /** @format textarea */
+  description = '';
+  status: 'backlog' | 'todo' | 'doing' | 'review' | 'done' = 'backlog';
+  assignee = '';
+  priority: 'low' | 'normal' | 'high' | 'urgent' = 'normal';
+  /** @format textarea */
+  result = '';
+  createdAt = 0;
+  updatedAt = 0;
+
+  /** @description Assign task to a person or AI, moves to todo */
+  assign(data: { /** Assignee name or 'ai' for AI agent */ to: string }) {
+    if (!data.to?.trim()) throw new Error('assignee required');
+    this.assignee = data.to.trim();
+    this.status = 'todo';
+    this.updatedAt = Date.now();
+  }
+
+  /** @description Start working on this task */
+  start() {
+    if (this.status !== 'todo' && this.status !== 'backlog')
+      throw new Error(`cannot start from "${this.status}"`);
+    this.status = 'doing';
+    this.updatedAt = Date.now();
+  }
+
+  /** @description Submit task for review */
+  submit(data?: { /** Result notes */ result?: string }) {
+    if (this.status !== 'doing') throw new Error(`cannot submit from "${this.status}"`);
+    if (data?.result) this.result = data.result;
+    this.status = 'review';
+    this.updatedAt = Date.now();
+  }
+
+  /** @description Approve task — mark as done */
+  approve() {
+    if (this.status !== 'review') throw new Error(`cannot approve from "${this.status}"`);
+    this.status = 'done';
+    this.updatedAt = Date.now();
+  }
+
+  /** @description Reject task — send back to doing */
+  reject(data?: { /** Reason for rejection */ reason?: string }) {
+    if (this.status !== 'review') throw new Error(`cannot reject from "${this.status}"`);
+    if (data?.reason) this.result = `Rejected: ${data.reason}`;
+    this.status = 'doing';
+    this.updatedAt = Date.now();
+  }
+
+  /** @description Move task to any status (kanban DnD) */
+  move(data: { /** Target status */ status: 'backlog' | 'todo' | 'doing' | 'review' | 'done' }) {
+    if (this.status === data.status) return;
+    this.status = data.status;
+    this.updatedAt = Date.now();
+  }
+
+  /** @description Reopen task — reset to backlog */
+  reopen() {
+    this.status = 'backlog';
+    this.assignee = '';
+    this.result = '';
+    this.updatedAt = Date.now();
+  }
+}
+
+registerType('board.task', BoardTask);
+
+/** Kanban board — container node, columns are children */
+export class BoardKanban {}
+
+registerType('board.kanban', BoardKanban);
+
+/** Kanban column — label + color + sort order. Query mount provides filtered tasks. */
+export class BoardColumn {
+  label = '';
+  color = 'border-zinc-400';
+  order = 0;
+}
+
+registerType('board.column', BoardColumn);