@andypai/agent-kanban 0.2.0 → 0.3.0

package/src/__tests__/index.test.ts

@@ -3,63 +3,118 @@ import { Database } from 'bun:sqlite'
 import { mkdtempSync, rmSync } from 'node:fs'
 import { join } from 'node:path'
 import { tmpdir } from 'node:os'
-import { run } from '../index.ts'
+import { ErrorCode, KanbanError, type ErrorCodeValue } from '../errors.ts'
+import type { Task } from '../types.ts'
+import { parseServeArgs, run } from '../index.ts'
+
+async function withTempDb(runTest: (dbPath: string) => Promise<void>): Promise<void> {
+  const dir = mkdtempSync(join(tmpdir(), 'kanban-run-'))
+  const dbPath = join(dir, 'board.db')
+  const prevProvider = process.env['KANBAN_PROVIDER']
+  process.env['KANBAN_PROVIDER'] = 'local'
+
+  try {
+    await runTest(dbPath)
+  } finally {
+    if (prevProvider === undefined) delete process.env['KANBAN_PROVIDER']
+    else process.env['KANBAN_PROVIDER'] = prevProvider
+    rmSync(dir, { recursive: true, force: true })
+  }
+}
+
+function expectOk<T>(result: Awaited<ReturnType<typeof run>>): T {
+  expect(result.exitCode).toBe(0)
+  expect(result.output.ok).toBe(true)
+  if (!result.output.ok) {
+    throw new Error('expected successful CLI output')
+  }
+  return result.output.data as T
+}
+
+async function expectKanbanError(
+  runPromise: Promise<Awaited<ReturnType<typeof run>>>,
+  code: ErrorCodeValue,
+): Promise<KanbanError> {
+  const err = await runPromise.then(
+    () => null,
+    (e: unknown) => e,
+  )
+  expect(err).toBeInstanceOf(KanbanError)
+  expect((err as KanbanError).code).toBe(code)
+  return err as KanbanError
+}
+
+describe('parseServeArgs', () => {
+  test('defaults: no tunnel, port from PORT env or 3000', () => {
+    const prev = process.env['PORT']
+    delete process.env['PORT']
+    try {
+      expect(parseServeArgs(['serve'])).toEqual({ db: undefined, port: 3000, tunnel: false })
+      process.env['PORT'] = '4001'
+      expect(parseServeArgs(['serve'])).toEqual({ db: undefined, port: 4001, tunnel: false })
+    } finally {
+      if (prev === undefined) delete process.env['PORT']
+      else process.env['PORT'] = prev
+    }
+  })
+
+  test('--tunnel opts in; --port and --db override', () => {
+    const opts = parseServeArgs(['serve', '--tunnel', '--port', '5050', '--db', '/tmp/b.db'])
+    expect(opts).toEqual({ db: '/tmp/b.db', port: 5050, tunnel: true })
+  })
+})
 
 describe('run', () => {
   test('applies schema migration before task commands', async () => {
-    process.env['KANBAN_PROVIDER'] = 'local'
-    const dir = mkdtempSync(join(tmpdir(), 'kanban-run-'))
-    const dbPath = join(dir, 'board.db')
-
-    const legacy = new Database(dbPath)
-    legacy.run(
-      `CREATE TABLE columns (
-        id TEXT PRIMARY KEY,
-        name TEXT UNIQUE NOT NULL,
-        position INTEGER NOT NULL,
-        color TEXT,
-        created_at TEXT NOT NULL DEFAULT (datetime('now')),
-        updated_at TEXT NOT NULL DEFAULT (datetime('now'))
-      )`,
-    )
-    legacy.run(
-      `CREATE TABLE tasks (
-        id TEXT PRIMARY KEY,
-        title TEXT NOT NULL,
-        description TEXT NOT NULL DEFAULT '',
-        column_id TEXT NOT NULL,
-        position INTEGER NOT NULL DEFAULT 0,
-        priority TEXT NOT NULL DEFAULT 'medium',
-        assignee TEXT NOT NULL DEFAULT '',
-        metadata TEXT NOT NULL DEFAULT '{}',
-        created_at TEXT NOT NULL DEFAULT (datetime('now')),
-        updated_at TEXT NOT NULL DEFAULT (datetime('now'))
-      )`,
-    )
-    legacy.run(
-      `CREATE TABLE activity_log (
-        id TEXT PRIMARY KEY,
-        task_id TEXT NOT NULL,
-        action TEXT NOT NULL,
-        field_changed TEXT,
-        old_value TEXT,
-        new_value TEXT,
-        timestamp TEXT NOT NULL DEFAULT (datetime('now'))
-      )`,
-    )
-    legacy.run(
-      `CREATE TABLE column_time_tracking (
-        id TEXT PRIMARY KEY,
-        task_id TEXT NOT NULL,
-        column_id TEXT NOT NULL,
-        entered_at TEXT NOT NULL DEFAULT (datetime('now')),
-        exited_at TEXT
-      )`,
-    )
-    legacy.run("INSERT INTO columns (id, name, position) VALUES ('c_backlog', 'backlog', 0)")
-    legacy.close()
+    await withTempDb(async (dbPath) => {
+      const legacy = new Database(dbPath)
+      legacy.run(
+        `CREATE TABLE columns (
+          id TEXT PRIMARY KEY,
+          name TEXT UNIQUE NOT NULL,
+          position INTEGER NOT NULL,
+          color TEXT,
+          created_at TEXT NOT NULL DEFAULT (datetime('now')),
+          updated_at TEXT NOT NULL DEFAULT (datetime('now'))
+        )`,
+      )
+      legacy.run(
+        `CREATE TABLE tasks (
+          id TEXT PRIMARY KEY,
+          title TEXT NOT NULL,
+          description TEXT NOT NULL DEFAULT '',
+          column_id TEXT NOT NULL,
+          position INTEGER NOT NULL DEFAULT 0,
+          priority TEXT NOT NULL DEFAULT 'medium',
+          assignee TEXT NOT NULL DEFAULT '',
+          metadata TEXT NOT NULL DEFAULT '{}',
+          created_at TEXT NOT NULL DEFAULT (datetime('now')),
+          updated_at TEXT NOT NULL DEFAULT (datetime('now'))
+        )`,
+      )
+      legacy.run(
+        `CREATE TABLE activity_log (
+          id TEXT PRIMARY KEY,
+          task_id TEXT NOT NULL,
+          action TEXT NOT NULL,
+          field_changed TEXT,
+          old_value TEXT,
+          new_value TEXT,
+          timestamp TEXT NOT NULL DEFAULT (datetime('now'))
+        )`,
+      )
+      legacy.run(
+        `CREATE TABLE column_time_tracking (
+          id TEXT PRIMARY KEY,
+          task_id TEXT NOT NULL,
+          column_id TEXT NOT NULL,
+          entered_at TEXT NOT NULL DEFAULT (datetime('now')),
+          exited_at TEXT
+        )`,
+      )
+      legacy.run("INSERT INTO columns (id, name, position) VALUES ('c_backlog', 'backlog', 0)")
+      legacy.close()
 
-    try {
       const result = await run(['--db', dbPath, 'task', 'add', 'Migrated task'])
       expect(result.exitCode).toBe(0)
       expect(result.output.ok).toBe(true)
@@ -68,8 +123,130 @@ describe('run', () => {
       const columns = verify.query('PRAGMA table_info(tasks)').all() as { name: string }[]
       expect(columns.some((column) => column.name === 'project')).toBe(true)
       verify.close()
-    } finally {
-      rmSync(dir, { recursive: true, force: true })
-    }
+    })
+  })
+
+  test('runs task lifecycle commands through the real CLI path', async () => {
+    await withTempDb(async (dbPath) => {
+      const created = expectOk<Task>(
+        await run([
+          '--db',
+          dbPath,
+          'task',
+          'add',
+          'Build feature',
+          '-d',
+          'Do the thing',
+          '-c',
+          'recurring',
+          '-p',
+          'high',
+          '-a',
+          'alice',
+          '--project',
+          'Platform',
+          '-m',
+          '{"sprint":5}',
+        ]),
+      )
+      expect(created.title).toBe('Build feature')
+      expect(created.description).toBe('Do the thing')
+      expect(created.priority).toBe('high')
+      expect(created.assignee).toBe('alice')
+      expect(created.project).toBe('Platform')
+      expect(created.metadata).toBe('{"sprint":5}')
+
+      const listed = expectOk<Task[]>(
+        await run(['--db', dbPath, 'task', 'list', '-c', 'recurring']),
+      )
+      expect(listed).toHaveLength(1)
+      expect(listed[0]!.id).toBe(created.id)
+
+      const viewed = expectOk<Task>(await run(['--db', dbPath, 'task', 'view', created.id]))
+      expect(viewed.id).toBe(created.id)
+
+      const updated = expectOk<Task>(
+        await run([
+          '--db',
+          dbPath,
+          'task',
+          'update',
+          created.id,
+          '--title',
+          'Modified feature',
+          '-d',
+          'Ship it',
+          '-p',
+          'urgent',
+          '-a',
+          'bob',
+          '--project',
+          'Infra',
+          '-m',
+          '{"sprint":6}',
+        ]),
+      )
+      expect(updated.title).toBe('Modified feature')
+      expect(updated.description).toBe('Ship it')
+      expect(updated.priority).toBe('urgent')
+      expect(updated.assignee).toBe('bob')
+      expect(updated.project).toBe('Infra')
+      expect(updated.metadata).toBe('{"sprint":6}')
+
+      const moved = expectOk<Task>(
+        await run(['--db', dbPath, 'task', 'move', created.id, 'in-progress']),
+      )
+      expect(moved.column_id).toBeTruthy()
+
+      const assigned = expectOk<Task>(
+        await run(['--db', dbPath, 'task', 'assign', created.id, 'carol']),
+      )
+      expect(assigned.assignee).toBe('carol')
+
+      const prioritized = expectOk<Task>(
+        await run(['--db', dbPath, 'task', 'prioritize', created.id, 'low']),
+      )
+      expect(prioritized.priority).toBe('low')
+
+      const deleted = expectOk<Task>(await run(['--db', dbPath, 'task', 'delete', created.id]))
+      expect(deleted.id).toBe(created.id)
+
+      await expectKanbanError(
+        run(['--db', dbPath, 'task', 'view', created.id]),
+        ErrorCode.TASK_NOT_FOUND,
+      )
+    })
+  })
+
+  test('lists and filters tasks through the CLI path', async () => {
+    await withTempDb(async (dbPath) => {
+      expectOk<Task>(await run(['--db', dbPath, 'task', 'add', 'A', '-c', 'recurring']))
+      expectOk<Task>(await run(['--db', dbPath, 'task', 'add', 'B', '-c', 'done']))
+
+      const allTasks = expectOk<Task[]>(await run(['--db', dbPath, 'task', 'list']))
+      expect(allTasks).toHaveLength(2)
+
+      const recurring = expectOk<Task[]>(
+        await run(['--db', dbPath, 'task', 'list', '-c', 'recurring']),
+      )
+      expect(recurring).toHaveLength(1)
+      expect(recurring[0]!.title).toBe('A')
+    })
+  })
+
+  test('raises CLI errors for missing task arguments', async () => {
+    await withTempDb(async (dbPath) => {
+      const missingTitle = await expectKanbanError(
+        run(['--db', dbPath, 'task', 'add']),
+        ErrorCode.MISSING_ARGUMENT,
+      )
+      expect(missingTitle.message).toContain('Task title is required')
+
+      const missingId = await expectKanbanError(
+        run(['--db', dbPath, 'task', 'view']),
+        ErrorCode.MISSING_ARGUMENT,
+      )
+      expect(missingId.message).toContain('Task ID is required')
+    })
   })
 })

package/src/__tests__/jira-adf.test.ts

@@ -0,0 +1,168 @@
+import { describe, expect, test } from 'bun:test'
+import { adfToPlainText, plainTextToAdf, type AdfDocument } from '../providers/jira-adf.ts'
+
+describe('plainTextToAdf / adfToPlainText', () => {
+  test('empty doc round-trip', () => {
+    const doc = plainTextToAdf('')
+    expect(doc).toEqual({ version: 1, type: 'doc', content: [] })
+    expect(adfToPlainText(doc)).toBe('')
+  })
+
+  test('single paragraph round-trip', () => {
+    const input = 'hello world'
+    const doc = plainTextToAdf(input)
+    expect(doc).toEqual({
+      version: 1,
+      type: 'doc',
+      content: [{ type: 'paragraph', content: [{ type: 'text', text: 'hello world' }] }],
+    })
+    expect(adfToPlainText(doc)).toBe(input)
+  })
+
+  test('multi-paragraph round-trip (blank-line separated)', () => {
+    const input = 'first paragraph\n\nsecond paragraph\n\nthird'
+    const doc = plainTextToAdf(input)
+    expect(doc.content).toHaveLength(3)
+    expect(doc.content[0]).toEqual({
+      type: 'paragraph',
+      content: [{ type: 'text', text: 'first paragraph' }],
+    })
+    expect(adfToPlainText(doc)).toBe(input)
+  })
+
+  test('bullet list round-trip (- and * both accepted, - emitted)', () => {
+    const input = '- one\n* two\n- three'
+    const doc = plainTextToAdf(input)
+    expect(doc.content).toHaveLength(1)
+    const list = doc.content[0] as { type: string; content: unknown[] }
+    expect(list.type).toBe('bulletList')
+    expect(list.content).toHaveLength(3)
+    // Output always uses `- `.
+    expect(adfToPlainText(doc)).toBe('- one\n- two\n- three')
+  })
+
+  test('ordered list round-trip starting at 1', () => {
+    const input = '1. first\n2. second\n3. third'
+    const doc = plainTextToAdf(input)
+    const list = doc.content[0] as {
+      type: string
+      attrs?: { order?: number }
+      content: unknown[]
+    }
+    expect(list.type).toBe('orderedList')
+    expect(list.attrs).toBeUndefined()
+    expect(list.content).toHaveLength(3)
+    expect(adfToPlainText(doc)).toBe(input)
+  })
+
+  test('ordered list preserves non-default attrs.order', () => {
+    const input = '5. fifth\n6. sixth'
+    const doc = plainTextToAdf(input)
+    const list = doc.content[0] as {
+      type: string
+      attrs?: { order?: number }
+    }
+    expect(list.type).toBe('orderedList')
+    expect(list.attrs?.order).toBe(5)
+    expect(adfToPlainText(doc)).toBe(input)
+  })
+
+  test('fenced code block round-trip without language', () => {
+    const input = '```\nconst x = 1\nconst y = 2\n```'
+    const doc = plainTextToAdf(input)
+    const code = doc.content[0] as {
+      type: string
+      attrs?: { language?: string }
+    }
+    expect(code.type).toBe('codeBlock')
+    expect(code.attrs).toBeUndefined()
+    expect(adfToPlainText(doc)).toBe(input)
+  })
+
+  test('fenced code block round-trip with language tag', () => {
+    const input = '```ts\nconst x: number = 1\n```'
+    const doc = plainTextToAdf(input)
+    const code = doc.content[0] as {
+      type: string
+      attrs?: { language?: string }
+    }
+    expect(code.type).toBe('codeBlock')
+    expect(code.attrs?.language).toBe('ts')
+    expect(adfToPlainText(doc)).toBe(input)
+  })
+
+  test('mixed content (paragraph + list + code block) round-trip', () => {
+    const input = 'intro paragraph\n\n- a\n- b\n\n```js\nconsole.log(1)\n```\n\nouttro'
+    const doc = plainTextToAdf(input)
+    expect(doc.content).toHaveLength(4)
+    expect(doc.content[0]?.type).toBe('paragraph')
+    expect(doc.content[1]?.type).toBe('bulletList')
+    expect(doc.content[2]?.type).toBe('codeBlock')
+    expect(doc.content[3]?.type).toBe('paragraph')
+    expect(adfToPlainText(doc)).toBe(input)
+  })
+
+  test('heading flattened to plain text (read path)', () => {
+    const doc: AdfDocument = {
+      version: 1,
+      type: 'doc',
+      content: [
+        {
+          type: 'heading',
+          attrs: { level: 2 },
+          content: [{ type: 'text', text: 'Big Title' }],
+        },
+        {
+          type: 'paragraph',
+          content: [{ type: 'text', text: 'body' }],
+        },
+      ],
+    }
+    // Heading renders as bare inner text (no `#` prefix).
+    expect(adfToPlainText(doc)).toBe('Big Title\n\nbody')
+  })
+
+  test('unknown block node type is gracefully skipped, no throw', () => {
+    const doc: AdfDocument = {
+      version: 1,
+      type: 'doc',
+      content: [
+        {
+          type: 'paragraph',
+          content: [{ type: 'text', text: 'before' }],
+        },
+        { type: 'mediaSingle', attrs: { layout: 'center' } },
+        {
+          type: 'paragraph',
+          content: [{ type: 'text', text: 'after' }],
+        },
+      ],
+    }
+    expect(() => adfToPlainText(doc)).not.toThrow()
+    expect(adfToPlainText(doc)).toBe('before\n\nafter')
+  })
+
+  test('inline text marks are stripped on read', () => {
+    const doc: AdfDocument = {
+      version: 1,
+      type: 'doc',
+      content: [
+        {
+          type: 'paragraph',
+          content: [
+            { type: 'text', text: 'bold', marks: [{ type: 'strong' }] },
+            { type: 'text', text: ' normal' },
+          ],
+        },
+      ],
+    }
+    expect(adfToPlainText(doc)).toBe('bold normal')
+  })
+
+  test('bullet item containing digits-dot substring is still a bullet', () => {
+    const input = '- item containing 1. something'
+    const doc = plainTextToAdf(input)
+    expect(doc.content[0]?.type).toBe('bulletList')
+    expect(adfToPlainText(doc)).toBe(input)
+  })
+})