@sqaoss/flowy 0.1.1 → 1.1.0

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/init.test.ts

@@ -0,0 +1,174 @@
+import { afterEach, beforeEach, describe, expect, test, vi } from 'vitest'
+
+let mockGraphql: ReturnType<typeof vi.fn>
+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(() => {
+  mockGraphql = vi.fn()
+  mockLoadConfig = vi.fn(() => ({
+    mode: 'saas',
+    apiUrl: 'https://flowy-ai.fly.dev/graphql',
+    apiKey: 'test-key',
+    client: { name: '' },
+    projects: {},
+  }))
+  mockSaveConfig = vi.fn()
+  mockOutput = vi.fn()
+  mockOutputError = vi.fn()
+  mockSpawnSync = vi.fn()
+
+  vi.doMock('../util/client.ts', () => ({
+    graphql: mockGraphql,
+  }))
+
+  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('init command', () => {
+  test('exports a command named "init" with no subcommands', async () => {
+    const { initCommand } = await import('./init.ts')
+    expect(initCommand.name()).toBe('init')
+    expect(initCommand.commands).toHaveLength(0)
+  })
+
+  test('detects repo name from SSH git remote URL', async () => {
+    mockSpawnSync
+      .mockReturnValueOnce({
+        status: 0,
+        stdout: '/home/user/my-repo\n',
+      })
+      .mockReturnValueOnce({
+        status: 0,
+        stdout: 'git@github.com:sqaoss/flowy.git\n',
+      })
+    mockGraphql.mockResolvedValue({
+      createNode: { id: 'proj_123', title: 'flowy' },
+    })
+
+    const { initCommand } = await import('./init.ts')
+    await initCommand.parseAsync([], { from: 'user' })
+
+    expect(mockGraphql).toHaveBeenCalledWith(
+      expect.stringContaining('createNode'),
+      expect.objectContaining({ type: 'project', title: 'flowy' }),
+    )
+  })
+
+  test('detects repo name from HTTPS git remote URL', async () => {
+    mockSpawnSync
+      .mockReturnValueOnce({
+        status: 0,
+        stdout: '/home/user/my-repo\n',
+      })
+      .mockReturnValueOnce({
+        status: 0,
+        stdout: 'https://github.com/sqaoss/flowy.git\n',
+      })
+    mockGraphql.mockResolvedValue({
+      createNode: { id: 'proj_123', title: 'flowy' },
+    })
+
+    const { initCommand } = await import('./init.ts')
+    await initCommand.parseAsync([], { from: 'user' })
+
+    expect(mockGraphql).toHaveBeenCalledWith(
+      expect.stringContaining('createNode'),
+      expect.objectContaining({ type: 'project', title: 'flowy' }),
+    )
+  })
+
+  test('falls back to directory name when no remote', async () => {
+    mockSpawnSync
+      .mockReturnValueOnce({
+        status: 0,
+        stdout: '/home/user/my-cool-project\n',
+      })
+      .mockReturnValueOnce({
+        status: 1,
+        stdout: '',
+      })
+    mockGraphql.mockResolvedValue({
+      createNode: { id: 'proj_456', title: 'my-cool-project' },
+    })
+
+    const { initCommand } = await import('./init.ts')
+    await initCommand.parseAsync([], { from: 'user' })
+
+    expect(mockGraphql).toHaveBeenCalledWith(
+      expect.stringContaining('createNode'),
+      expect.objectContaining({
+        type: 'project',
+        title: 'my-cool-project',
+      }),
+    )
+  })
+
+  test('calls graphql to create project and maps directory via config', async () => {
+    mockSpawnSync
+      .mockReturnValueOnce({
+        status: 0,
+        stdout: '/home/user/flowy\n',
+      })
+      .mockReturnValueOnce({
+        status: 0,
+        stdout: 'git@github.com:sqaoss/flowy.git\n',
+      })
+    mockGraphql.mockResolvedValue({
+      createNode: { id: 'proj_789', title: 'flowy' },
+    })
+
+    const { initCommand } = await import('./init.ts')
+    await initCommand.parseAsync([], { from: 'user' })
+
+    expect(mockGraphql).toHaveBeenCalledOnce()
+    expect(mockSaveConfig).toHaveBeenCalledWith(
+      expect.objectContaining({
+        projects: expect.objectContaining({
+          [process.cwd()]: { id: 'proj_789', name: 'flowy' },
+        }),
+      }),
+    )
+    expect(mockOutput).toHaveBeenCalledWith({
+      id: 'proj_789',
+      name: 'flowy',
+      directory: process.cwd(),
+    })
+  })
+
+  test('throws when not in a git repo', async () => {
+    mockSpawnSync.mockReturnValueOnce({
+      status: 128,
+      stdout: '',
+    })
+
+    const { initCommand } = await import('./init.ts')
+    await initCommand.parseAsync([], { from: 'user' })
+
+    expect(mockOutputError).toHaveBeenCalledWith(
+      expect.objectContaining({
+        message: expect.stringContaining('Not a git repository'),
+      }),
+    )
+  })
+})

package/src/commands/init.ts

@@ -0,0 +1,50 @@
+import { spawnSync } from 'node:child_process'
+import { basename } from 'node:path'
+import { Command } from 'commander'
+import { graphql } from '../util/client.ts'
+import { loadConfig, saveConfig } from '../util/config.ts'
+import { output, outputError } from '../util/format.ts'
+
+export const initCommand = new Command('init')
+  .description('Initialize Flowy for the current git repository')
+  .action(async () => {
+    try {
+      const toplevel = spawnSync('git', ['rev-parse', '--show-toplevel'])
+      if (toplevel.status !== 0) {
+        throw new Error(
+          'Not a git repository. Run flowy init from inside a git project.',
+        )
+      }
+
+      let repoName: string
+      const remote = spawnSync('git', ['remote', 'get-url', 'origin'])
+      if (remote.status === 0) {
+        const url = String(remote.stdout).trim()
+        repoName =
+          url
+            .split('/')
+            .pop()
+            ?.replace(/\.git$/, '') ?? ''
+      } else {
+        repoName = basename(String(toplevel.stdout).trim())
+      }
+
+      const data = await graphql<{ createNode: { id: string; title: string } }>(
+        `mutation CreateProject($type: String!, $title: String!) {
+          createNode(type: $type, title: $title) {
+            id type title description status metadata createdAt updatedAt
+          }
+        }`,
+        { type: 'project', title: repoName },
+      )
+
+      const { id, title } = data.createNode
+      const config = loadConfig()
+      const cwd = process.cwd()
+      config.projects[cwd] = { id, name: title }
+      saveConfig(config)
+      output({ id, name: title, directory: cwd })
+    } 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))