@sqaoss/flowy 1.3.1 → 1.4.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sqaoss/flowy",
-  "version": "1.3.1",
+  "version": "1.4.0",
   "description": "Agentic persistent planning",
   "type": "module",
   "bin": {

package/src/commands/feature.test.ts

@@ -1,4 +1,4 @@
-import { describe, expect, test, vi } from 'vitest'
+import { beforeEach, describe, expect, test, vi } from 'vitest'
 
 const mockUpdateProjectConfig = vi.fn()
 
@@ -22,6 +22,10 @@ vi.mock('../util/format.ts', () => ({
 }))
 
 describe('feature command', () => {
+  beforeEach(() => {
+    vi.clearAllMocks()
+  })
+
   test('exports a command group named "feature" with subcommands', async () => {
     const { featureCommand } = await import('./feature.ts')
     expect(featureCommand.name()).toBe('feature')
@@ -31,6 +35,8 @@ describe('feature command', () => {
     expect(subcommandNames).toContain('unset')
     expect(subcommandNames).toContain('list')
     expect(subcommandNames).toContain('show')
+    expect(subcommandNames).toContain('update')
+    expect(subcommandNames).toContain('delete')
   })
 
   test('create calls outputError when no active project', async () => {
@@ -68,4 +74,158 @@ describe('feature command', () => {
 
     expect(output).toHaveBeenCalledWith({ activeFeature: null })
   })
+
+  test('update sends updateNode with only the title when title-only', async () => {
+    const { graphql } = await import('../util/client.ts')
+    const { output } = await import('../util/format.ts')
+    const { featureCommand } = await import('./feature.ts')
+
+    vi.mocked(graphql).mockResolvedValueOnce({
+      updateNode: { id: 'feat_1', title: 'New' },
+    })
+
+    const updateCmd = featureCommand.commands.find(
+      (c) => c.name() === 'update',
+    )!
+    await updateCmd.parseAsync(['feat_1', '--title', 'New'], { from: 'user' })
+
+    expect(graphql).toHaveBeenCalledWith(
+      expect.stringContaining('updateNode'),
+      {
+        id: 'feat_1',
+        title: 'New',
+      },
+    )
+    expect(output).toHaveBeenCalledWith({ id: 'feat_1', title: 'New' })
+  })
+
+  test('update sends updateNode with only the description when description-only', async () => {
+    const { graphql } = await import('../util/client.ts')
+    const { featureCommand } = await import('./feature.ts')
+
+    vi.mocked(graphql).mockResolvedValueOnce({ updateNode: { id: 'feat_1' } })
+
+    const updateCmd = featureCommand.commands.find(
+      (c) => c.name() === 'update',
+    )!
+    await updateCmd.parseAsync(['feat_1', '--description', 'Body'], {
+      from: 'user',
+    })
+
+    expect(graphql).toHaveBeenCalledWith(
+      expect.stringContaining('updateNode'),
+      {
+        id: 'feat_1',
+        description: 'Body',
+      },
+    )
+  })
+
+  test('update sends updateNode with only the metadata when metadata-only', async () => {
+    const { graphql } = await import('../util/client.ts')
+    const { featureCommand } = await import('./feature.ts')
+
+    vi.mocked(graphql).mockResolvedValueOnce({ updateNode: { id: 'feat_1' } })
+
+    const updateCmd = featureCommand.commands.find(
+      (c) => c.name() === 'update',
+    )!
+    await updateCmd.parseAsync(['feat_1', '--metadata', '{"k":"v"}'], {
+      from: 'user',
+    })
+
+    expect(graphql).toHaveBeenCalledWith(
+      expect.stringContaining('updateNode'),
+      {
+        id: 'feat_1',
+        metadata: '{"k":"v"}',
+      },
+    )
+  })
+
+  test('update sends updateNode with combined fields', async () => {
+    const { graphql } = await import('../util/client.ts')
+    const { featureCommand } = await import('./feature.ts')
+
+    vi.mocked(graphql).mockResolvedValueOnce({ updateNode: { id: 'feat_1' } })
+
+    const updateCmd = featureCommand.commands.find(
+      (c) => c.name() === 'update',
+    )!
+    await updateCmd.parseAsync(
+      ['feat_1', '--title', 'New', '--description', 'Body', '--metadata', '{}'],
+      { from: 'user' },
+    )
+
+    expect(graphql).toHaveBeenCalledWith(
+      expect.stringContaining('updateNode'),
+      {
+        id: 'feat_1',
+        title: 'New',
+        description: 'Body',
+        metadata: '{}',
+      },
+    )
+  })
+
+  test('delete sends deleteNode mutation', async () => {
+    const { graphql } = await import('../util/client.ts')
+    const { output } = await import('../util/format.ts')
+    const { featureCommand } = await import('./feature.ts')
+
+    vi.mocked(graphql).mockResolvedValueOnce({ deleteNode: true })
+
+    const deleteCmd = featureCommand.commands.find(
+      (c) => c.name() === 'delete',
+    )!
+    await deleteCmd.parseAsync(['feat_1'], { from: 'user' })
+
+    expect(graphql).toHaveBeenCalledWith(
+      expect.stringContaining('deleteNode'),
+      {
+        id: 'feat_1',
+      },
+    )
+    expect(output).toHaveBeenCalledWith({ deleted: true })
+  })
+
+  test('delete surfaces CONFLICT via outputError with its code', async () => {
+    const { graphql } = await import('../util/client.ts')
+    const { outputError } = await import('../util/format.ts')
+    const { featureCommand } = await import('./feature.ts')
+
+    const conflict = Object.assign(new Error('has children'), {
+      code: 'CONFLICT',
+    })
+    vi.mocked(graphql).mockRejectedValueOnce(conflict)
+
+    const deleteCmd = featureCommand.commands.find(
+      (c) => c.name() === 'delete',
+    )!
+    await deleteCmd.parseAsync(['feat_1'], { from: 'user' })
+
+    expect(outputError).toHaveBeenCalledWith(
+      expect.objectContaining({ code: 'CONFLICT' }),
+    )
+  })
+
+  test('delete surfaces NOT_FOUND via outputError with its code', async () => {
+    const { graphql } = await import('../util/client.ts')
+    const { outputError } = await import('../util/format.ts')
+    const { featureCommand } = await import('./feature.ts')
+
+    const notFound = Object.assign(new Error('Node feat_x not found'), {
+      code: 'NOT_FOUND',
+    })
+    vi.mocked(graphql).mockRejectedValueOnce(notFound)
+
+    const deleteCmd = featureCommand.commands.find(
+      (c) => c.name() === 'delete',
+    )!
+    await deleteCmd.parseAsync(['feat_x'], { from: 'user' })
+
+    expect(outputError).toHaveBeenCalledWith(
+      expect.objectContaining({ code: 'NOT_FOUND' }),
+    )
+  })
 })

package/src/commands/feature.ts

@@ -126,6 +126,75 @@ featureCommand
     }
   })
 
+featureCommand
+  .command('update')
+  .description('Update a feature')
+  .argument('[id]', 'Feature ID (defaults to active feature)')
+  .option('--title <title>', 'New title')
+  .option(
+    '--description <text>',
+    'New description, used verbatim (never read as a file path)',
+  )
+  .option(
+    '--description-file <path>',
+    'Read the new description from a file, or "-" for stdin',
+  )
+  .option('--metadata <json>', 'New metadata as a JSON string')
+  .action(async (id: string | undefined, opts) => {
+    try {
+      const featureId = id ?? resolveFeature()
+      if (!featureId) {
+        throw new Error(
+          'No feature specified. Pass an ID or set an active feature.',
+        )
+      }
+      const variables: Record<string, unknown> = { id: featureId }
+      if (opts.title != null) variables.title = opts.title
+      if (opts.description != null || opts.descriptionFile != null) {
+        variables.description = await resolveDescription({
+          description: opts.description,
+          descriptionFile: opts.descriptionFile,
+        })
+      }
+      if (opts.metadata != null) variables.metadata = opts.metadata
+      const data = await graphql<{ updateNode: unknown }>(
+        `mutation UpdateNode($id: String!, $title: String, $description: String, $metadata: String) {
+          updateNode(id: $id, title: $title, description: $description, metadata: $metadata) {
+            id type title description status metadata createdAt updatedAt
+          }
+        }`,
+        variables,
+      )
+      output(data.updateNode)
+    } catch (error) {
+      outputError(error)
+    }
+  })
+
+featureCommand
+  .command('delete')
+  .description('Delete a feature')
+  .argument('[id]', 'Feature ID (defaults to active feature)')
+  .action(async (id?: string) => {
+    try {
+      const featureId = id ?? resolveFeature()
+      if (!featureId) {
+        throw new Error(
+          'No feature specified. Pass an ID or set an active feature.',
+        )
+      }
+      const data = await graphql<{ deleteNode: boolean }>(
+        `mutation DeleteNode($id: String!) {
+          deleteNode(id: $id)
+        }`,
+        { id: featureId },
+      )
+      output({ deleted: data.deleteNode })
+    } catch (error) {
+      outputError(error)
+    }
+  })
+
 featureCommand
   .command('show')
   .description('Show feature details')

package/src/commands/project.test.ts

@@ -3,6 +3,10 @@ import { homedir } from 'node:os'
 import { resolve } from 'node:path'
 import { afterEach, beforeEach, describe, expect, test, vi } from 'vitest'
 
+vi.mock('../util/client.ts', () => ({
+  graphql: vi.fn(),
+}))
+
 const CONFIG_PATH = resolve(homedir(), '.config', 'flowy', 'config.json')
 
 describe('project command', () => {
@@ -24,7 +28,7 @@ describe('project command', () => {
     vi.restoreAllMocks()
   })
 
-  test('exports a command group named "project" with create, set, list, show subcommands', async () => {
+  test('exports a command group named "project" with create, set, list, show, update, delete subcommands', async () => {
     const { projectCommand } = await import('./project.ts')
     expect(projectCommand.name()).toBe('project')
     const subcommandNames = projectCommand.commands.map((c) => c.name())
@@ -32,7 +36,9 @@ describe('project command', () => {
     expect(subcommandNames).toContain('set')
     expect(subcommandNames).toContain('list')
     expect(subcommandNames).toContain('show')
-    expect(projectCommand.commands).toHaveLength(4)
+    expect(subcommandNames).toContain('update')
+    expect(subcommandNames).toContain('delete')
+    expect(projectCommand.commands).toHaveLength(6)
   })
 
   test('show without id calls requireProject which throws when no project configured', async () => {
@@ -80,4 +86,165 @@ describe('project command', () => {
       name: 'Second',
     })
   })
+
+  test('update sends updateNode with only the title when title-only', async () => {
+    const { graphql } = await import('../util/client.ts')
+    const { projectCommand } = await import('./project.ts')
+    vi.spyOn(console, 'log').mockImplementation(() => {})
+
+    vi.mocked(graphql).mockResolvedValueOnce({
+      updateNode: { id: 'proj_1', title: 'New' },
+    })
+
+    const updateCmd = projectCommand.commands.find(
+      (c) => c.name() === 'update',
+    )!
+    await updateCmd.parseAsync(['proj_1', '--title', 'New'], { from: 'user' })
+
+    expect(graphql).toHaveBeenCalledWith(
+      expect.stringContaining('updateNode'),
+      {
+        id: 'proj_1',
+        title: 'New',
+      },
+    )
+  })
+
+  test('update sends updateNode with only the description when description-only', async () => {
+    const { graphql } = await import('../util/client.ts')
+    const { projectCommand } = await import('./project.ts')
+    vi.spyOn(console, 'log').mockImplementation(() => {})
+
+    vi.mocked(graphql).mockResolvedValueOnce({ updateNode: { id: 'proj_1' } })
+
+    const updateCmd = projectCommand.commands.find(
+      (c) => c.name() === 'update',
+    )!
+    await updateCmd.parseAsync(['proj_1', '--description', 'Body'], {
+      from: 'user',
+    })
+
+    expect(graphql).toHaveBeenCalledWith(
+      expect.stringContaining('updateNode'),
+      {
+        id: 'proj_1',
+        description: 'Body',
+      },
+    )
+  })
+
+  test('update sends updateNode with only the metadata when metadata-only', async () => {
+    const { graphql } = await import('../util/client.ts')
+    const { projectCommand } = await import('./project.ts')
+    vi.spyOn(console, 'log').mockImplementation(() => {})
+
+    vi.mocked(graphql).mockResolvedValueOnce({ updateNode: { id: 'proj_1' } })
+
+    const updateCmd = projectCommand.commands.find(
+      (c) => c.name() === 'update',
+    )!
+    await updateCmd.parseAsync(['proj_1', '--metadata', '{"k":"v"}'], {
+      from: 'user',
+    })
+
+    expect(graphql).toHaveBeenCalledWith(
+      expect.stringContaining('updateNode'),
+      {
+        id: 'proj_1',
+        metadata: '{"k":"v"}',
+      },
+    )
+  })
+
+  test('update sends updateNode with combined fields', async () => {
+    const { graphql } = await import('../util/client.ts')
+    const { projectCommand } = await import('./project.ts')
+    vi.spyOn(console, 'log').mockImplementation(() => {})
+
+    vi.mocked(graphql).mockResolvedValueOnce({ updateNode: { id: 'proj_1' } })
+
+    const updateCmd = projectCommand.commands.find(
+      (c) => c.name() === 'update',
+    )!
+    await updateCmd.parseAsync(
+      ['proj_1', '--title', 'New', '--description', 'Body', '--metadata', '{}'],
+      { from: 'user' },
+    )
+
+    expect(graphql).toHaveBeenCalledWith(
+      expect.stringContaining('updateNode'),
+      {
+        id: 'proj_1',
+        title: 'New',
+        description: 'Body',
+        metadata: '{}',
+      },
+    )
+  })
+
+  test('delete sends deleteNode mutation', async () => {
+    const { graphql } = await import('../util/client.ts')
+    const { projectCommand } = await import('./project.ts')
+    vi.spyOn(console, 'log').mockImplementation(() => {})
+
+    vi.mocked(graphql).mockResolvedValueOnce({ deleteNode: true })
+
+    const deleteCmd = projectCommand.commands.find(
+      (c) => c.name() === 'delete',
+    )!
+    await deleteCmd.parseAsync(['proj_1'], { from: 'user' })
+
+    expect(graphql).toHaveBeenCalledWith(
+      expect.stringContaining('deleteNode'),
+      {
+        id: 'proj_1',
+      },
+    )
+  })
+
+  test('delete surfaces CONFLICT with exit code 1', async () => {
+    const { graphql } = await import('../util/client.ts')
+    const { projectCommand } = await import('./project.ts')
+    const mockExit = vi
+      .spyOn(process, 'exit')
+      .mockImplementation(() => undefined as never)
+    const mockStderr = vi.spyOn(console, 'error').mockImplementation(() => {})
+
+    const conflict = Object.assign(new Error('has children'), {
+      code: 'CONFLICT',
+    })
+    vi.mocked(graphql).mockRejectedValueOnce(conflict)
+
+    const deleteCmd = projectCommand.commands.find(
+      (c) => c.name() === 'delete',
+    )!
+    await deleteCmd.parseAsync(['proj_1'], { from: 'user' })
+
+    expect(mockStderr).toHaveBeenCalledWith(expect.stringContaining('CONFLICT'))
+    expect(mockExit).toHaveBeenCalledWith(1)
+  })
+
+  test('delete surfaces NOT_FOUND with exit code 2', async () => {
+    const { graphql } = await import('../util/client.ts')
+    const { projectCommand } = await import('./project.ts')
+    const mockExit = vi
+      .spyOn(process, 'exit')
+      .mockImplementation(() => undefined as never)
+    const mockStderr = vi.spyOn(console, 'error').mockImplementation(() => {})
+
+    const notFound = Object.assign(new Error('Node proj_x not found'), {
+      code: 'NOT_FOUND',
+    })
+    vi.mocked(graphql).mockRejectedValueOnce(notFound)
+
+    const deleteCmd = projectCommand.commands.find(
+      (c) => c.name() === 'delete',
+    )!
+    await deleteCmd.parseAsync(['proj_x'], { from: 'user' })
+
+    expect(mockStderr).toHaveBeenCalledWith(
+      expect.stringContaining('NOT_FOUND'),
+    )
+    expect(mockExit).toHaveBeenCalledWith(2)
+  })
 })

package/src/commands/project.ts

@@ -1,6 +1,7 @@
 import { Command } from 'commander'
 import { graphql } from '../util/client.ts'
 import { loadConfig, requireProject, saveConfig } from '../util/config.ts'
+import { resolveDescription } from '../util/description.ts'
 import { output, outputError } from '../util/format.ts'
 
 export const projectCommand = new Command('project').description(
@@ -102,3 +103,62 @@ projectCommand
   .description('Show project details')
   .argument('[id]', 'Project ID (defaults to active project)')
   .action(async (id?: string) => showProject(id))
+
+projectCommand
+  .command('update')
+  .description('Update a project')
+  .argument('[id]', 'Project ID (defaults to active project)')
+  .option('--title <title>', 'New title')
+  .option(
+    '--description <text>',
+    'New description, used verbatim (never read as a file path)',
+  )
+  .option(
+    '--description-file <path>',
+    'Read the new description from a file, or "-" for stdin',
+  )
+  .option('--metadata <json>', 'New metadata as a JSON string')
+  .action(async (id: string | undefined, opts) => {
+    try {
+      const projectId = id ?? requireProject().id
+      const variables: Record<string, unknown> = { id: projectId }
+      if (opts.title != null) variables.title = opts.title
+      if (opts.description != null || opts.descriptionFile != null) {
+        variables.description = await resolveDescription({
+          description: opts.description,
+          descriptionFile: opts.descriptionFile,
+        })
+      }
+      if (opts.metadata != null) variables.metadata = opts.metadata
+      const data = await graphql<{ updateNode: unknown }>(
+        `mutation UpdateNode($id: String!, $title: String, $description: String, $metadata: String) {
+          updateNode(id: $id, title: $title, description: $description, metadata: $metadata) {
+            id type title description status metadata createdAt updatedAt
+          }
+        }`,
+        variables,
+      )
+      output(data.updateNode)
+    } catch (error) {
+      outputError(error)
+    }
+  })
+
+projectCommand
+  .command('delete')
+  .description('Delete a project')
+  .argument('[id]', 'Project ID (defaults to active project)')
+  .action(async (id?: string) => {
+    try {
+      const projectId = id ?? requireProject().id
+      const data = await graphql<{ deleteNode: boolean }>(
+        `mutation DeleteNode($id: String!) {
+          deleteNode(id: $id)
+        }`,
+        { id: projectId },
+      )
+      output({ deleted: data.deleteNode })
+    } catch (error) {
+      outputError(error)
+    }
+  })

package/src/commands/task.test.ts

@@ -1,4 +1,4 @@
-import { describe, expect, test, vi } from 'vitest'
+import { beforeEach, describe, expect, test, vi } from 'vitest'
 
 vi.mock('../util/config.ts', () => ({
   requireFeature: vi.fn(() => {
@@ -18,10 +18,14 @@ vi.mock('../util/format.ts', () => ({
 }))
 
 describe('task command', () => {
-  test('exports a command group with 5 subcommands', async () => {
+  beforeEach(() => {
+    vi.clearAllMocks()
+  })
+
+  test('exports a command group with 7 subcommands', async () => {
     const { taskCommand } = await import('./task.ts')
     expect(taskCommand.name()).toBe('task')
-    expect(taskCommand.commands).toHaveLength(5)
+    expect(taskCommand.commands).toHaveLength(7)
 
     const names = taskCommand.commands.map((c) => c.name())
     expect(names).toContain('create')
@@ -29,6 +33,8 @@ describe('task command', () => {
     expect(names).toContain('show')
     expect(names).toContain('block')
     expect(names).toContain('unblock')
+    expect(names).toContain('update')
+    expect(names).toContain('delete')
   })
 
   test('create exposes both --description and --description-file options', async () => {
@@ -88,4 +94,165 @@ describe('task command', () => {
       }),
     )
   })
+
+  test('update sends updateNode with only the title when title-only', async () => {
+    const { graphql } = await import('../util/client.ts')
+    const { output } = await import('../util/format.ts')
+    const { taskCommand } = await import('./task.ts')
+
+    vi.mocked(graphql).mockResolvedValueOnce({
+      updateNode: { id: 'task_1', title: 'New' },
+    })
+
+    const updateCmd = taskCommand.commands.find((c) => c.name() === 'update')!
+    await updateCmd.parseAsync(['task_1', '--title', 'New'], { from: 'user' })
+
+    expect(graphql).toHaveBeenCalledWith(
+      expect.stringContaining('updateNode'),
+      { id: 'task_1', title: 'New' },
+    )
+    expect(output).toHaveBeenCalledWith({ id: 'task_1', title: 'New' })
+  })
+
+  test('update sends updateNode with only the description when description-only', async () => {
+    const { graphql } = await import('../util/client.ts')
+    const { taskCommand } = await import('./task.ts')
+
+    vi.mocked(graphql).mockResolvedValueOnce({
+      updateNode: { id: 'task_1' },
+    })
+
+    const updateCmd = taskCommand.commands.find((c) => c.name() === 'update')!
+    await updateCmd.parseAsync(['task_1', '--description', 'Body'], {
+      from: 'user',
+    })
+
+    expect(graphql).toHaveBeenCalledWith(
+      expect.stringContaining('updateNode'),
+      {
+        id: 'task_1',
+        description: 'Body',
+      },
+    )
+  })
+
+  test('update sends updateNode with only the metadata when metadata-only', async () => {
+    const { graphql } = await import('../util/client.ts')
+    const { taskCommand } = await import('./task.ts')
+
+    vi.mocked(graphql).mockResolvedValueOnce({
+      updateNode: { id: 'task_1' },
+    })
+
+    const updateCmd = taskCommand.commands.find((c) => c.name() === 'update')!
+    await updateCmd.parseAsync(['task_1', '--metadata', '{"k":"v"}'], {
+      from: 'user',
+    })
+
+    expect(graphql).toHaveBeenCalledWith(
+      expect.stringContaining('updateNode'),
+      {
+        id: 'task_1',
+        metadata: '{"k":"v"}',
+      },
+    )
+  })
+
+  test('update sends updateNode with combined fields', async () => {
+    const { graphql } = await import('../util/client.ts')
+    const { taskCommand } = await import('./task.ts')
+
+    vi.mocked(graphql).mockResolvedValueOnce({
+      updateNode: { id: 'task_1' },
+    })
+
+    const updateCmd = taskCommand.commands.find((c) => c.name() === 'update')!
+    await updateCmd.parseAsync(
+      ['task_1', '--title', 'New', '--description', 'Body', '--metadata', '{}'],
+      { from: 'user' },
+    )
+
+    expect(graphql).toHaveBeenCalledWith(
+      expect.stringContaining('updateNode'),
+      {
+        id: 'task_1',
+        title: 'New',
+        description: 'Body',
+        metadata: '{}',
+      },
+    )
+  })
+
+  test('update surfaces NOT_FOUND via outputError with its code', async () => {
+    const { graphql } = await import('../util/client.ts')
+    const { outputError } = await import('../util/format.ts')
+    const { taskCommand } = await import('./task.ts')
+
+    const notFound = Object.assign(new Error('Node task_x not found'), {
+      code: 'NOT_FOUND',
+    })
+    vi.mocked(graphql).mockRejectedValueOnce(notFound)
+
+    const updateCmd = taskCommand.commands.find((c) => c.name() === 'update')!
+    await updateCmd.parseAsync(['task_x', '--title', 'New'], { from: 'user' })
+
+    expect(outputError).toHaveBeenCalledWith(
+      expect.objectContaining({ code: 'NOT_FOUND' }),
+    )
+  })
+
+  test('delete sends deleteNode mutation', async () => {
+    const { graphql } = await import('../util/client.ts')
+    const { output } = await import('../util/format.ts')
+    const { taskCommand } = await import('./task.ts')
+
+    vi.mocked(graphql).mockResolvedValueOnce({ deleteNode: true })
+
+    const deleteCmd = taskCommand.commands.find((c) => c.name() === 'delete')!
+    await deleteCmd.parseAsync(['task_1'], { from: 'user' })
+
+    expect(graphql).toHaveBeenCalledWith(
+      expect.stringContaining('deleteNode'),
+      {
+        id: 'task_1',
+      },
+    )
+    expect(output).toHaveBeenCalledWith({ deleted: true })
+  })
+
+  test('delete surfaces CONFLICT via outputError with its code', async () => {
+    const { graphql } = await import('../util/client.ts')
+    const { outputError } = await import('../util/format.ts')
+    const { taskCommand } = await import('./task.ts')
+
+    const conflict = Object.assign(new Error('has children'), {
+      code: 'CONFLICT',
+    })
+    vi.mocked(graphql).mockRejectedValueOnce(conflict)
+
+    const deleteCmd = taskCommand.commands.find((c) => c.name() === 'delete')!
+    await deleteCmd.parseAsync(['task_1'], { from: 'user' })
+
+    expect(outputError).toHaveBeenCalledWith(
+      expect.objectContaining({ code: 'CONFLICT' }),
+    )
+  })
+
+  test('delete surfaces NOT_FOUND via outputError with its code', async () => {
+    const { graphql } = await import('../util/client.ts')
+    const { outputError } = await import('../util/format.ts')
+    const { taskCommand } = await import('./task.ts')
+
+    const notFound = Object.assign(new Error('Node task_x not found'), {
+      code: 'NOT_FOUND',
+    })
+    vi.mocked(graphql).mockRejectedValueOnce(notFound)
+
+    const deleteCmd = taskCommand.commands.find((c) => c.name() === 'delete')!
+    await deleteCmd.parseAsync(['task_x'], { from: 'user' })
+
+    expect(outputError).toHaveBeenCalledWith(
+      expect.objectContaining({ code: 'NOT_FOUND' }),
+    )
+  })
 })

package/src/commands/task.ts

@@ -93,6 +93,63 @@ taskCommand
     }
   })
 
+taskCommand
+  .command('update')
+  .description('Update a task')
+  .argument('<id>', 'Task ID')
+  .option('--title <title>', 'New title')
+  .option(
+    '--description <text>',
+    'New description, used verbatim (never read as a file path)',
+  )
+  .option(
+    '--description-file <path>',
+    'Read the new description from a file, or "-" for stdin',
+  )
+  .option('--metadata <json>', 'New metadata as a JSON string')
+  .action(async (id: string, opts) => {
+    try {
+      const variables: Record<string, unknown> = { id }
+      if (opts.title != null) variables.title = opts.title
+      if (opts.description != null || opts.descriptionFile != null) {
+        variables.description = await resolveDescription({
+          description: opts.description,
+          descriptionFile: opts.descriptionFile,
+        })
+      }
+      if (opts.metadata != null) variables.metadata = opts.metadata
+      const data = await graphql<{ updateNode: unknown }>(
+        `mutation UpdateNode($id: String!, $title: String, $description: String, $metadata: String) {
+          updateNode(id: $id, title: $title, description: $description, metadata: $metadata) {
+            id type title description status metadata createdAt updatedAt
+          }
+        }`,
+        variables,
+      )
+      output(data.updateNode)
+    } catch (error) {
+      outputError(error)
+    }
+  })
+
+taskCommand
+  .command('delete')
+  .description('Delete a task')
+  .argument('<id>', 'Task ID')
+  .action(async (id: string) => {
+    try {
+      const data = await graphql<{ deleteNode: boolean }>(
+        `mutation DeleteNode($id: String!) {
+          deleteNode(id: $id)
+        }`,
+        { id },
+      )
+      output({ deleted: data.deleteNode })
+    } catch (error) {
+      outputError(error)
+    }
+  })
+
 taskCommand
   .command('block')
   .description('Mark a task as blocking another')