@sqaoss/flowy 0.1.1 → 1.1.0

package/src/commands/setup.test.ts

@@ -0,0 +1,135 @@
+import { afterEach, beforeEach, describe, expect, test, vi } from 'vitest'
+
+let mockLoadConfig: ReturnType<typeof vi.fn>
+let mockSaveConfig: ReturnType<typeof vi.fn>
+let mockOutput: ReturnType<typeof vi.fn>
+let mockOutputError: ReturnType<typeof vi.fn>
+let mockSpawnSync: ReturnType<typeof vi.fn>
+
+beforeEach(() => {
+  mockLoadConfig = vi.fn(() => ({
+    mode: 'saas',
+    apiUrl: 'https://flowy-ai.fly.dev/graphql',
+    apiKey: '',
+    client: { name: '' },
+    projects: {},
+  }))
+  mockSaveConfig = vi.fn()
+  mockOutput = vi.fn()
+  mockOutputError = vi.fn()
+  mockSpawnSync = vi.fn()
+
+  vi.doMock('../util/config.ts', () => ({
+    loadConfig: mockLoadConfig,
+    saveConfig: mockSaveConfig,
+  }))
+
+  vi.doMock('../util/format.ts', () => ({
+    output: mockOutput,
+    outputError: mockOutputError,
+  }))
+
+  vi.doMock('node:child_process', () => ({
+    spawnSync: mockSpawnSync,
+  }))
+})
+
+afterEach(() => {
+  vi.resetModules()
+  vi.restoreAllMocks()
+})
+
+describe('setup command', () => {
+  test('exports a command named "setup"', async () => {
+    const { setupCommand } = await import('./setup.ts')
+    expect(setupCommand.name()).toBe('setup')
+  })
+
+  test('has local and remote subcommands', async () => {
+    const { setupCommand } = await import('./setup.ts')
+    const subcommandNames = setupCommand.commands.map((c) => c.name())
+    expect(subcommandNames).toContain('local')
+    expect(subcommandNames).toContain('remote')
+    expect(setupCommand.commands).toHaveLength(2)
+  })
+
+  test('setup local checks for docker and errors if not found', async () => {
+    mockSpawnSync.mockReturnValue({ status: 1 })
+
+    const { setupCommand } = await import('./setup.ts')
+    await setupCommand.parseAsync(['local'], { from: 'user' })
+
+    expect(mockSpawnSync).toHaveBeenCalledWith('docker', ['--version'], {
+      stdio: 'ignore',
+    })
+    expect(mockOutputError).toHaveBeenCalledWith(
+      expect.objectContaining({
+        message: expect.stringContaining('Docker is required'),
+      }),
+    )
+  })
+
+  test('setup local saves config with mode "local" and apiUrl on success', async () => {
+    mockSpawnSync.mockReturnValue({ status: 0 })
+    vi.stubGlobal('fetch', vi.fn().mockResolvedValue({ ok: true }))
+    vi.doMock('node:fs', async () => {
+      const actual = await vi.importActual<typeof import('node:fs')>('node:fs')
+      return { ...actual, existsSync: () => true }
+    })
+
+    const { setupCommand } = await import('./setup.ts')
+    await setupCommand.parseAsync(['local'], { from: 'user' })
+
+    expect(mockSaveConfig).toHaveBeenCalledWith(
+      expect.objectContaining({
+        mode: 'local',
+        apiUrl: 'http://localhost:4000/graphql',
+      }),
+    )
+  })
+
+  test('setup remote requires --email', async () => {
+    const { setupCommand } = await import('./setup.ts')
+    await setupCommand.parseAsync(['remote'], { from: 'user' })
+
+    expect(mockOutputError).toHaveBeenCalledWith(
+      expect.objectContaining({
+        message: expect.stringContaining('--email is required'),
+      }),
+    )
+  })
+
+  test('setup remote registers, saves API key, and outputs result', async () => {
+    const mockGraphql = vi.fn().mockResolvedValue({
+      register: {
+        user: { id: 'user_1', email: 'test@example.com', tier: 'free' },
+        apiKey: 'flowy_test_key_123',
+      },
+    })
+    vi.doMock('../util/client.ts', () => ({
+      graphql: mockGraphql,
+    }))
+    mockSpawnSync.mockReturnValue({
+      status: 0,
+      stdout: Buffer.from(''),
+    })
+
+    const { setupCommand } = await import('./setup.ts')
+    await setupCommand.parseAsync(['remote', '--email', 'test@example.com'], {
+      from: 'user',
+    })
+
+    expect(mockSaveConfig).toHaveBeenCalledWith(
+      expect.objectContaining({
+        mode: 'remote',
+        apiKey: 'flowy_test_key_123',
+      }),
+    )
+    expect(mockOutput).toHaveBeenCalledWith(
+      expect.objectContaining({
+        user: expect.objectContaining({ email: 'test@example.com' }),
+        apiKey: 'flowy_test_key_123',
+      }),
+    )
+  })
+})

package/src/commands/setup.ts

@@ -0,0 +1,109 @@
+import { spawnSync } from 'node:child_process'
+import { existsSync } from 'node:fs'
+import { dirname, resolve } from 'node:path'
+import { fileURLToPath } from 'node:url'
+import { Command } from 'commander'
+import { loadConfig, saveConfig } from '../util/config.ts'
+import { output, outputError } from '../util/format.ts'
+
+function findComposeFile(): string {
+  let dir = dirname(fileURLToPath(import.meta.url))
+  while (dir !== dirname(dir)) {
+    const candidate = resolve(dir, 'docker-compose.yml')
+    if (existsSync(candidate)) return candidate
+    dir = dirname(dir)
+  }
+  throw new Error('docker-compose.yml not found in any parent directory.')
+}
+
+async function pollHealth(url: string, timeoutMs = 30_000): Promise<void> {
+  const start = Date.now()
+  while (Date.now() - start < timeoutMs) {
+    try {
+      const res = await fetch(url)
+      if (res.ok) return
+    } catch {}
+    await new Promise((r) => setTimeout(r, 1_000))
+  }
+  throw new Error(
+    `Health check at ${url} did not respond within ${timeoutMs / 1_000}s.`,
+  )
+}
+
+export const setupCommand = new Command('setup').description(
+  'Configure the Flowy CLI — use "flowy setup local" or "flowy setup remote"',
+)
+
+setupCommand
+  .command('local')
+  .description('Set up Flowy with a local Docker server')
+  .action(async () => {
+    try {
+      const dockerCheck = spawnSync('docker', ['--version'], {
+        stdio: 'ignore',
+      })
+      if (dockerCheck.status !== 0) {
+        throw new Error('Docker is required but was not found.')
+      }
+
+      const composePath = findComposeFile()
+      spawnSync(
+        'docker',
+        ['compose', '-f', composePath, 'up', '-d', '--build'],
+        {
+          stdio: 'inherit',
+        },
+      )
+
+      const apiUrl = 'http://localhost:4000/graphql'
+      await pollHealth('http://localhost:4000/health')
+
+      const config = loadConfig()
+      config.mode = 'local'
+      config.apiUrl = apiUrl
+      saveConfig(config)
+      output({ mode: 'local', apiUrl })
+    } catch (error) {
+      outputError(error)
+    }
+  })
+
+setupCommand
+  .command('remote')
+  .description('Connect to the hosted Flowy service')
+  .option('--email <email>', 'Email address for registration')
+  .action(async (opts) => {
+    try {
+      if (!opts.email) {
+        throw new Error('--email is required for registration')
+      }
+
+      const { graphql } = await import('../util/client.ts')
+
+      const config = loadConfig()
+      config.mode = 'remote'
+      config.apiUrl = 'https://flowy-ai.fly.dev/graphql'
+      saveConfig(config)
+
+      const data = await graphql(
+        `mutation Register($email: String!) {
+          register(email: $email) {
+            user { id email tier }
+            apiKey
+          }
+        }`,
+        { email: opts.email },
+      )
+
+      config.apiKey = data.register.apiKey
+      saveConfig(config)
+
+      spawnSync('npx', ['skills', 'add', 'sqaoss/flowy', '--yes'], {
+        stdio: 'inherit',
+      })
+
+      output(data.register)
+    } catch (error) {
+      outputError(error)
+    }
+  })

package/src/commands/task.test.ts

@@ -0,0 +1,83 @@
+import { describe, expect, test, vi } from 'vitest'
+
+vi.mock('../util/config.ts', () => ({
+  requireFeature: vi.fn(() => {
+    throw new Error(
+      'No active feature. Run "flowy feature set <name-or-id>" or set FLOWY_FEATURE.',
+    )
+  }),
+}))
+
+vi.mock('../util/client.ts', () => ({
+  graphql: vi.fn(),
+}))
+
+vi.mock('../util/format.ts', () => ({
+  output: vi.fn(),
+  outputError: vi.fn(),
+}))
+
+describe('task command', () => {
+  test('exports a command group with 5 subcommands', async () => {
+    const { taskCommand } = await import('./task.ts')
+    expect(taskCommand.name()).toBe('task')
+    expect(taskCommand.commands).toHaveLength(5)
+
+    const names = taskCommand.commands.map((c) => c.name())
+    expect(names).toContain('create')
+    expect(names).toContain('list')
+    expect(names).toContain('show')
+    expect(names).toContain('block')
+    expect(names).toContain('unblock')
+  })
+
+  test('create calls outputError when no active feature', async () => {
+    const { taskCommand } = await import('./task.ts')
+    const { outputError } = await import('../util/format.ts')
+
+    const createCmd = taskCommand.commands.find((c) => c.name() === 'create')!
+    await createCmd.parseAsync(['--title', 'Test', '--description', 'desc'], {
+      from: 'user',
+    })
+
+    expect(outputError).toHaveBeenCalledWith(
+      expect.objectContaining({
+        message: expect.stringContaining('No active feature'),
+      }),
+    )
+  })
+
+  test('show calls outputError when graphql throws network error', async () => {
+    const { graphql } = await import('../util/client.ts')
+    const { outputError } = await import('../util/format.ts')
+    const { taskCommand } = await import('./task.ts')
+
+    vi.mocked(graphql).mockRejectedValueOnce(new TypeError('fetch failed'))
+
+    const showCmd = taskCommand.commands.find((c) => c.name() === 'show')!
+    await showCmd.parseAsync(['task_abc123'], { from: 'user' })
+
+    expect(outputError).toHaveBeenCalledWith(
+      expect.objectContaining({
+        message: 'fetch failed',
+      }),
+    )
+  })
+
+  test('show calls outputError when graphql returns error response', async () => {
+    const { graphql } = await import('../util/client.ts')
+    const { outputError } = await import('../util/format.ts')
+    const { taskCommand } = await import('./task.ts')
+
+    vi.mocked(graphql).mockRejectedValueOnce(new Error('Node not found'))
+
+    const showCmd = taskCommand.commands.find((c) => c.name() === 'show')!
+    await showCmd.parseAsync(['task_nonexistent'], { from: 'user' })
+
+    expect(outputError).toHaveBeenCalledWith(
+      expect.objectContaining({
+        message: 'Node not found',
+      }),
+    )
+  })
+})

package/src/commands/task.ts

@@ -0,0 +1,127 @@
+import { Command } from 'commander'
+import { graphql } from '../util/client.ts'
+import { requireFeature } from '../util/config.ts'
+import { resolveDescription } from '../util/description.ts'
+import { output, outputError } from '../util/format.ts'
+
+export const taskCommand = new Command('task').description(
+  'Manage tasks in the active feature',
+)
+
+taskCommand
+  .command('create')
+  .description('Create a task in the active feature')
+  .requiredOption('--title <title>', 'Task title')
+  .requiredOption(
+    '--description <desc>',
+    'Task description (text or file path)',
+  )
+  .action(async (opts) => {
+    try {
+      const featureId = requireFeature()
+      const description = await resolveDescription(opts.description)
+      const data = await graphql<{ createNode: { id: string } }>(
+        `mutation CreateTask($type: String!, $title: String!, $description: String) {
+          createNode(type: $type, title: $title, description: $description) {
+            id type title description status createdAt
+          }
+        }`,
+        { type: 'task', title: opts.title, description },
+      )
+      const taskId = data.createNode.id
+      await graphql(
+        `mutation LinkTask($sourceId: String!, $targetId: String!, $relation: String!) {
+          createEdge(sourceId: $sourceId, targetId: $targetId, relation: $relation) {
+            sourceId targetId relation
+          }
+        }`,
+        { sourceId: taskId, targetId: featureId, relation: 'part_of' },
+      )
+      output(data.createNode)
+    } catch (error) {
+      outputError(error)
+    }
+  })
+
+taskCommand
+  .command('list')
+  .description('List tasks in the active feature')
+  .action(async () => {
+    try {
+      const featureId = requireFeature()
+      const data = await graphql<{ descendants: unknown[] }>(
+        `query ListTasks($nodeId: String!, $relation: String!, $maxDepth: Int) {
+          descendants(nodeId: $nodeId, relation: $relation, maxDepth: $maxDepth) {
+            id type title status createdAt
+          }
+        }`,
+        { nodeId: featureId, relation: 'part_of', maxDepth: 1 },
+      )
+      const tasks = data.descendants.filter(
+        (n: unknown) => (n as { type: string }).type === 'task',
+      )
+      output(tasks)
+    } catch (error) {
+      outputError(error)
+    }
+  })
+
+taskCommand
+  .command('show')
+  .description('Show task details')
+  .argument('<id>', 'Task ID')
+  .action(async (id: string) => {
+    try {
+      const data = await graphql<{ node: unknown }>(
+        `query ShowTask($id: String!) {
+          node(id: $id) {
+            id type title description status metadata createdAt updatedAt
+          }
+        }`,
+        { id },
+      )
+      output(data.node)
+    } catch (error) {
+      outputError(error)
+    }
+  })
+
+taskCommand
+  .command('block')
+  .description('Mark a task as blocking another')
+  .argument('<id1>', 'Blocking task ID')
+  .argument('<id2>', 'Blocked task ID')
+  .action(async (id1: string, id2: string) => {
+    try {
+      const data = await graphql<{ createEdge: unknown }>(
+        `mutation BlockTask($sourceId: String!, $targetId: String!, $relation: String!) {
+          createEdge(sourceId: $sourceId, targetId: $targetId, relation: $relation) {
+            sourceId targetId relation createdAt
+          }
+        }`,
+        { sourceId: id1, targetId: id2, relation: 'blocks' },
+      )
+      output(data.createEdge)
+    } catch (error) {
+      outputError(error)
+    }
+  })
+
+taskCommand
+  .command('unblock')
+  .description('Remove a blocking relationship')
+  .argument('<id1>', 'Blocking task ID')
+  .argument('<id2>', 'Blocked task ID')
+  .action(async (id1: string, id2: string) => {
+    try {
+      const data = await graphql<{ removeEdge: boolean }>(
+        `mutation UnblockTask($sourceId: String!, $targetId: String!, $relation: String!) {
+          removeEdge(sourceId: $sourceId, targetId: $targetId, relation: $relation)
+        }`,
+        { sourceId: id1, targetId: id2, relation: 'blocks' },
+      )
+      output({ removed: data.removeEdge })
+    } catch (error) {
+      outputError(error)
+    }
+  })

package/src/commands/tree.test.ts

@@ -0,0 +1,9 @@
+import { describe, expect, test } from 'vitest'
+
+describe('tree command', () => {
+  test('exports a flat command with id argument and depth option', async () => {
+    const { treeCommand } = await import('./tree.ts')
+    expect(treeCommand.name()).toBe('tree')
+    expect(treeCommand.commands).toHaveLength(0)
+  })
+})

package/src/commands/tree.ts

@@ -2,13 +2,8 @@ import { Command } from 'commander'
 import { graphql } from '../util/client.ts'
 import { output, outputError } from '../util/format.ts'
 
-export const treeCommand = new Command('tree').description(
-  'Graph traversal commands',
-)
-
-treeCommand
-  .command('subtree')
-  .description('Show node subtree (node + all descendants)')
+export const treeCommand = new Command('tree')
+  .description('Show subtree from any entity')
   .argument('<id>', 'Root node ID')
   .option('--depth <n>', 'Max depth', '10')
   .action(async (id: string, opts) => {
@@ -26,55 +21,3 @@ treeCommand
       outputError(error)
     }
   })
-
-treeCommand
-  .command('ancestors')
-  .description('Show ancestors of a node')
-  .argument('<id>', 'Node ID')
-  .option('--depth <n>', 'Max depth', '10')
-  .option('--relation <type>', 'Edge relation filter', 'part_of')
-  .action(async (id: string, opts) => {
-    try {
-      const data = await graphql<{ ancestors: unknown[] }>(
-        `query Ancestors($nodeId: String!, $relation: String, $maxDepth: Int) {
-          ancestors(nodeId: $nodeId, relation: $relation, maxDepth: $maxDepth) {
-            id type title status
-          }
-        }`,
-        {
-          nodeId: id,
-          relation: opts.relation,
-          maxDepth: Number.parseInt(opts.depth, 10),
-        },
-      )
-      output(data.ancestors)
-    } catch (error) {
-      outputError(error)
-    }
-  })
-
-treeCommand
-  .command('descendants')
-  .description('Show descendants of a node')
-  .argument('<id>', 'Node ID')
-  .option('--depth <n>', 'Max depth', '10')
-  .option('--relation <type>', 'Edge relation filter', 'part_of')
-  .action(async (id: string, opts) => {
-    try {
-      const data = await graphql<{ descendants: unknown[] }>(
-        `query Descendants($nodeId: String!, $relation: String, $maxDepth: Int) {
-          descendants(nodeId: $nodeId, relation: $relation, maxDepth: $maxDepth) {
-            id type title status
-          }
-        }`,
-        {
-          nodeId: id,
-          relation: opts.relation,
-          maxDepth: Number.parseInt(opts.depth, 10),
-        },
-      )
-      output(data.descendants)
-    } catch (error) {
-      outputError(error)
-    }
-  })

package/src/index.ts

@@ -1,25 +1,31 @@
 #!/usr/bin/env bun
 import { Command } from 'commander'
 import { approveCommand } from './commands/approve.ts'
-import { edgeCommand } from './commands/edge.ts'
-import { nodeCommand } from './commands/node.ts'
-import { registerCommand } from './commands/register.ts'
+import { clientCommand } from './commands/client.ts'
+import { featureCommand } from './commands/feature.ts'
+import { initCommand } from './commands/init.ts'
+import { projectCommand } from './commands/project.ts'
 import { searchCommand } from './commands/search.ts'
+import { setupCommand } from './commands/setup.ts'
 import { statusCommand } from './commands/status.ts'
+import { taskCommand } from './commands/task.ts'
 import { treeCommand } from './commands/tree.ts'
 import { whoamiCommand } from './commands/whoami.ts'
 
 const program = new Command()
   .name('flowy')
   .description('Project management for AI coding agents')
-  .version('0.1.0')
+  .version('0.2.0')
 
+program.addCommand(initCommand)
+program.addCommand(setupCommand)
+program.addCommand(clientCommand)
+program.addCommand(projectCommand)
+program.addCommand(featureCommand)
+program.addCommand(taskCommand)
+program.addCommand(statusCommand)
 program.addCommand(approveCommand)
-program.addCommand(registerCommand)
-program.addCommand(nodeCommand)
-program.addCommand(edgeCommand)
 program.addCommand(searchCommand)
-program.addCommand(statusCommand)
 program.addCommand(treeCommand)
 program.addCommand(whoamiCommand)