@sqaoss/flowy 0.1.0 → 1.0.2

package/src/commands/feature.test.ts

@@ -0,0 +1,71 @@
+import { describe, expect, test, vi } from 'vitest'
+
+const mockUpdateProjectConfig = vi.fn()
+
+vi.mock('../util/config.ts', () => ({
+  requireProject: vi.fn(() => {
+    throw new Error(
+      'No active project. Run "flowy project set <name>" or set FLOWY_PROJECT.',
+    )
+  }),
+  resolveFeature: vi.fn(() => null),
+  updateProjectConfig: (...args: unknown[]) => mockUpdateProjectConfig(...args),
+}))
+
+vi.mock('../util/client.ts', () => ({
+  graphql: vi.fn(),
+}))
+
+vi.mock('../util/format.ts', () => ({
+  output: vi.fn(),
+  outputError: vi.fn(),
+}))
+
+describe('feature command', () => {
+  test('exports a command group named "feature" with subcommands', async () => {
+    const { featureCommand } = await import('./feature.ts')
+    expect(featureCommand.name()).toBe('feature')
+    const subcommandNames = featureCommand.commands.map((c) => c.name())
+    expect(subcommandNames).toContain('create')
+    expect(subcommandNames).toContain('set')
+    expect(subcommandNames).toContain('unset')
+    expect(subcommandNames).toContain('list')
+    expect(subcommandNames).toContain('show')
+  })
+
+  test('create calls outputError when no active project', async () => {
+    const { featureCommand } = await import('./feature.ts')
+    const { outputError } = await import('../util/format.ts')
+
+    const createCmd = featureCommand.commands.find((c) => c.name() === 'create')
+    expect(createCmd).toBeDefined()
+    await createCmd?.parseAsync(['--title', 'Test', '--description', 'Desc'], {
+      from: 'user',
+    })
+
+    expect(outputError).toHaveBeenCalledWith(
+      expect.objectContaining({
+        message: expect.stringContaining('No active project'),
+      }),
+    )
+  })
+
+  test('unset calls updateProjectConfig to delete activeFeature', async () => {
+    const { featureCommand } = await import('./feature.ts')
+    const { output } = await import('../util/format.ts')
+
+    const unsetCmd = featureCommand.commands.find((c) => c.name() === 'unset')
+    expect(unsetCmd).toBeDefined()
+    await unsetCmd?.parseAsync([], { from: 'user' })
+
+    expect(mockUpdateProjectConfig).toHaveBeenCalledWith(expect.any(Function))
+
+    // Verify the updater function deletes activeFeature
+    const updater = mockUpdateProjectConfig.mock.calls[0]?.[0]
+    const fakeProject = { id: 'p1', name: 'Test', activeFeature: 'feat_abc' }
+    updater(fakeProject)
+    expect(fakeProject.activeFeature).toBeUndefined()
+
+    expect(output).toHaveBeenCalledWith({ activeFeature: null })
+  })
+})

package/src/commands/feature.ts

@@ -0,0 +1,143 @@
+import { Command } from 'commander'
+import { graphql } from '../util/client.ts'
+import {
+  requireProject,
+  resolveFeature,
+  updateProjectConfig,
+} from '../util/config.ts'
+import { resolveDescription } from '../util/description.ts'
+import { output, outputError } from '../util/format.ts'
+
+export const featureCommand = new Command('feature').description(
+  'Manage features in the active project',
+)
+
+featureCommand
+  .command('create')
+  .description('Create a feature in the active project')
+  .requiredOption('--title <title>', 'Feature title')
+  .requiredOption('--description <description>', 'Feature description')
+  .action(async (opts) => {
+    try {
+      const project = requireProject()
+      const description = await resolveDescription(opts.description)
+      const nodeData = await graphql<{ createNode: { id: string } }>(
+        `mutation CreateNode($type: String!, $title: String!, $description: String) {
+          createNode(type: $type, title: $title, description: $description) {
+            id type title description status createdAt updatedAt
+          }
+        }`,
+        { type: 'feature', title: opts.title, description },
+      )
+      const featureId = nodeData.createNode.id
+      await graphql(
+        `mutation CreateEdge($sourceId: String!, $targetId: String!, $relation: String!) {
+          createEdge(sourceId: $sourceId, targetId: $targetId, relation: $relation) {
+            sourceId targetId relation createdAt
+          }
+        }`,
+        { sourceId: featureId, targetId: project.id, relation: 'part_of' },
+      )
+      output(nodeData.createNode)
+    } catch (error) {
+      outputError(error)
+    }
+  })
+
+featureCommand
+  .command('set')
+  .description('Set the active feature')
+  .argument('<name-or-id>', 'Feature name or ID')
+  .action(async (nameOrId: string) => {
+    try {
+      const project = requireProject()
+      const data = await graphql<{
+        descendants: Array<{ id: string; type: string; title: string }>
+      }>(
+        `query Descendants($nodeId: String!, $relation: String, $maxDepth: Int) {
+          descendants(nodeId: $nodeId, relation: $relation, maxDepth: $maxDepth) {
+            id type title status
+          }
+        }`,
+        { nodeId: project.id, relation: 'part_of', maxDepth: 1 },
+      )
+      const features = data.descendants.filter((n) => n.type === 'feature')
+      const match = features.find(
+        (f) => f.id === nameOrId || f.title === nameOrId,
+      )
+      if (!match) {
+        throw new Error(
+          `Feature "${nameOrId}" not found in project "${project.name}".`,
+        )
+      }
+      updateProjectConfig((p) => {
+        p.activeFeature = match.id
+      })
+      output(match)
+    } catch (error) {
+      outputError(error)
+    }
+  })
+
+featureCommand
+  .command('unset')
+  .description('Clear the active feature')
+  .action(async () => {
+    try {
+      updateProjectConfig((p) => {
+        delete p.activeFeature
+      })
+      output({ activeFeature: null })
+    } catch (error) {
+      outputError(error)
+    }
+  })
+
+featureCommand
+  .command('list')
+  .description('List features in the active project')
+  .action(async () => {
+    try {
+      const project = requireProject()
+      const data = await graphql<{
+        descendants: Array<{ id: string; type: string }>
+      }>(
+        `query Descendants($nodeId: String!, $relation: String, $maxDepth: Int) {
+          descendants(nodeId: $nodeId, relation: $relation, maxDepth: $maxDepth) {
+            id type title description status createdAt updatedAt
+          }
+        }`,
+        { nodeId: project.id, relation: 'part_of', maxDepth: 1 },
+      )
+      const features = data.descendants.filter((n) => n.type === 'feature')
+      output(features)
+    } catch (error) {
+      outputError(error)
+    }
+  })
+
+featureCommand
+  .command('show')
+  .description('Show feature details')
+  .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<{ node: unknown }>(
+        `query GetNode($id: String!) {
+          node(id: $id) {
+            id type title description status metadata createdAt updatedAt
+          }
+        }`,
+        { id: featureId },
+      )
+      output(data.node)
+    } catch (error) {
+      outputError(error)
+    }
+  })

package/src/commands/project.test.ts

@@ -0,0 +1,83 @@
+import { existsSync, readFileSync, rmSync } from 'node:fs'
+import { homedir } from 'node:os'
+import { resolve } from 'node:path'
+import { afterEach, beforeEach, describe, expect, test, vi } from 'vitest'
+
+const CONFIG_PATH = resolve(homedir(), '.config', 'flowy', 'config.json')
+
+describe('project command', () => {
+  let originalConfig: string | null = null
+
+  beforeEach(() => {
+    originalConfig = existsSync(CONFIG_PATH)
+      ? readFileSync(CONFIG_PATH, 'utf-8')
+      : null
+  })
+
+  afterEach(async () => {
+    if (originalConfig !== null) {
+      const { writeFileSync } = await import('node:fs')
+      writeFileSync(CONFIG_PATH, originalConfig)
+    } else if (existsSync(CONFIG_PATH)) {
+      rmSync(CONFIG_PATH)
+    }
+    vi.restoreAllMocks()
+  })
+
+  test('exports a command group named "project" with create, set, list, show subcommands', async () => {
+    const { projectCommand } = await import('./project.ts')
+    expect(projectCommand.name()).toBe('project')
+    const subcommandNames = projectCommand.commands.map((c) => c.name())
+    expect(subcommandNames).toContain('create')
+    expect(subcommandNames).toContain('set')
+    expect(subcommandNames).toContain('list')
+    expect(subcommandNames).toContain('show')
+    expect(projectCommand.commands).toHaveLength(4)
+  })
+
+  test('show without id calls requireProject which throws when no project configured', async () => {
+    const mockExit = vi
+      .spyOn(process, 'exit')
+      .mockImplementation(() => undefined as never)
+    const mockStderr = vi.spyOn(console, 'error').mockImplementation(() => {})
+
+    const { showProject } = await import('./project.ts')
+    await showProject(undefined)
+
+    expect(mockStderr).toHaveBeenCalledWith(
+      expect.stringContaining('No active project'),
+    )
+    expect(mockExit).toHaveBeenCalledWith(1)
+  })
+
+  test('setProject saves cwd-to-project mapping in config', async () => {
+    const { setProject } = await import('./project.ts')
+    const { loadConfig } = await import('../util/config.ts')
+    vi.spyOn(console, 'log').mockImplementation(() => {})
+
+    await setProject('proj_42', 'My Project')
+
+    const config = loadConfig()
+    const cwd = process.cwd()
+    expect(config.projects[cwd]).toEqual({
+      id: 'proj_42',
+      name: 'My Project',
+    })
+  })
+
+  test('setProject overwrites existing mapping for same directory', async () => {
+    const { setProject } = await import('./project.ts')
+    const { loadConfig } = await import('../util/config.ts')
+    vi.spyOn(console, 'log').mockImplementation(() => {})
+
+    await setProject('proj_1', 'First')
+    await setProject('proj_2', 'Second')
+
+    const config = loadConfig()
+    const cwd = process.cwd()
+    expect(config.projects[cwd]).toEqual({
+      id: 'proj_2',
+      name: 'Second',
+    })
+  })
+})

package/src/commands/project.ts

@@ -0,0 +1,104 @@
+import { Command } from 'commander'
+import { graphql } from '../util/client.ts'
+import { loadConfig, requireProject, saveConfig } from '../util/config.ts'
+import { output, outputError } from '../util/format.ts'
+
+export const projectCommand = new Command('project').description(
+  'Manage projects',
+)
+
+projectCommand
+  .command('create')
+  .description('Create a new project')
+  .argument('<name>', 'Project name')
+  .action(async (name: string) => {
+    try {
+      const data = await graphql<{ createNode: unknown }>(
+        `mutation CreateProject($type: String!, $title: String!) {
+          createNode(type: $type, title: $title) {
+            id type title description status metadata createdAt updatedAt
+          }
+        }`,
+        { type: 'project', title: name },
+      )
+      output(data.createNode)
+    } catch (error) {
+      outputError(error)
+    }
+  })
+
+export async function setProject(id: string, name: string): Promise<void> {
+  const config = loadConfig()
+  const cwd = process.cwd()
+  config.projects[cwd] = { id, name }
+  saveConfig(config)
+  output({ id, name, directory: cwd })
+}
+
+projectCommand
+  .command('set')
+  .description('Map current directory to a project')
+  .argument('<name>', 'Project name')
+  .action(async (name: string) => {
+    try {
+      const data = await graphql<{
+        nodes: Array<{ id: string; title: string }>
+      }>(
+        `query ListProjects($type: String) {
+          nodes(type: $type) {
+            id title
+          }
+        }`,
+        { type: 'project' },
+      )
+      const project = data.nodes.find((n) => n.title === name)
+      if (!project) {
+        throw new Error(`Project "${name}" not found`)
+      }
+      await setProject(project.id, project.title)
+    } catch (error) {
+      outputError(error)
+    }
+  })
+
+projectCommand
+  .command('list')
+  .description('List all projects')
+  .action(async () => {
+    try {
+      const data = await graphql<{ nodes: unknown[] }>(
+        `query ListProjects($type: String) {
+          nodes(type: $type) {
+            id type title description status createdAt updatedAt
+          }
+        }`,
+        { type: 'project' },
+      )
+      output(data.nodes)
+    } catch (error) {
+      outputError(error)
+    }
+  })
+
+export async function showProject(id?: string): Promise<void> {
+  try {
+    const projectId = id ?? requireProject().id
+    const data = await graphql<{ node: unknown }>(
+      `query GetProject($id: String!) {
+        node(id: $id) {
+          id type title description status metadata createdAt updatedAt
+        }
+      }`,
+      { id: projectId },
+    )
+    output(data.node)
+  } catch (error) {
+    outputError(error)
+  }
+}
+
+projectCommand
+  .command('show')
+  .description('Show project details')
+  .argument('[id]', 'Project ID (defaults to active project)')
+  .action(async (id?: string) => showProject(id))

package/src/commands/setup.test.ts

@@ -0,0 +1,101 @@
+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 prints not-yet-implemented message', async () => {
+    const { setupCommand } = await import('./setup.ts')
+    await setupCommand.parseAsync(['remote'], { from: 'user' })
+
+    expect(mockOutput).toHaveBeenCalledWith(
+      expect.objectContaining({
+        message: expect.stringContaining('not yet implemented'),
+      }),
+    )
+  })
+})

package/src/commands/setup.ts

@@ -0,0 +1,83 @@
+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('Set up Flowy with the remote SaaS server')
+  .action(async () => {
+    try {
+      output({
+        message:
+          'Remote mode is not yet implemented. It will support registration and API key setup via this CLI.',
+      })
+    } 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',
+      }),
+    )
+  })
+})