@sqaoss/flowy 0.1.1 → 1.0.2

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,29 @@
 #!/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 { 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(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)
 

package/src/util/config.test.ts

@@ -0,0 +1,151 @@
+import { existsSync, readFileSync, rmSync, writeFileSync } from 'node:fs'
+import { homedir } from 'node:os'
+import { resolve } from 'node:path'
+import {
+  afterAll,
+  afterEach,
+  beforeAll,
+  beforeEach,
+  describe,
+  expect,
+  test,
+  vi,
+} from 'vitest'
+
+const CONFIG_PATH = resolve(homedir(), '.config', 'flowy', 'config.json')
+
+describe('config', () => {
+  let originalConfig: string | null = null
+
+  beforeAll(() => {
+    originalConfig = existsSync(CONFIG_PATH)
+      ? readFileSync(CONFIG_PATH, 'utf-8')
+      : null
+  })
+
+  afterAll(() => {
+    if (originalConfig !== null) {
+      writeFileSync(CONFIG_PATH, originalConfig)
+    } else if (existsSync(CONFIG_PATH)) {
+      rmSync(CONFIG_PATH)
+    }
+  })
+
+  beforeEach(() => {
+    if (existsSync(CONFIG_PATH)) rmSync(CONFIG_PATH)
+  })
+
+  afterEach(() => {
+    delete process.env.FLOWY_PROJECT
+    delete process.env.FLOWY_FEATURE
+    vi.resetModules()
+  })
+  test('loadConfig returns defaults when no config file exists', async () => {
+    const { loadConfig } = await import('./config.ts')
+    const config = loadConfig()
+    expect(config.mode).toBe('saas')
+    expect(config.apiUrl).toBe('https://flowy-ai.fly.dev/graphql')
+    expect(config.apiKey).toBe('')
+    expect(config.client.name).toBe('')
+    expect(config.projects).toEqual({})
+  })
+
+  test('getConfig uses env var overrides', async () => {
+    process.env.FLOWY_API_URL = 'http://localhost:4000/graphql'
+    process.env.FLOWY_API_KEY = 'test-key'
+    const { getConfig } = await import('./config.ts')
+    const { apiUrl, apiKey } = getConfig()
+    expect(apiUrl).toBe('http://localhost:4000/graphql')
+    expect(apiKey).toBe('test-key')
+    delete process.env.FLOWY_API_URL
+    delete process.env.FLOWY_API_KEY
+  })
+
+  test('saveConfig writes and loadConfig reads from disk', async () => {
+    const { saveConfig, loadConfig } = await import('./config.ts')
+    const config = loadConfig()
+    config.client.name = 'Test Client'
+    saveConfig(config)
+    const reloaded = loadConfig()
+    expect(reloaded.client.name).toBe('Test Client')
+  })
+
+  test('resolveProject returns null when no project configured', async () => {
+    const { resolveProject } = await import('./config.ts')
+    expect(resolveProject()).toBeNull()
+  })
+
+  test('resolveProject matches cwd against project paths', async () => {
+    const { saveConfig, loadConfig, resolveProject } = await import(
+      './config.ts'
+    )
+    const config = loadConfig()
+    const cwd = process.cwd()
+    config.projects[cwd] = { id: 'proj_1', name: 'Test Project' }
+    saveConfig(config)
+    const project = resolveProject()
+    expect(project).not.toBeNull()
+    expect(project?.id).toBe('proj_1')
+    expect(project?.name).toBe('Test Project')
+  })
+
+  test('resolveProject uses FLOWY_PROJECT env var', async () => {
+    const { saveConfig, loadConfig, resolveProject } = await import(
+      './config.ts'
+    )
+    const config = loadConfig()
+    config.projects['/other/path'] = { id: 'proj_2', name: 'Env Project' }
+    saveConfig(config)
+    process.env.FLOWY_PROJECT = 'Env Project'
+    const project = resolveProject()
+    expect(project?.name).toBe('Env Project')
+  })
+
+  test('requireProject throws when no project configured', async () => {
+    const { requireProject } = await import('./config.ts')
+    expect(() => requireProject()).toThrow('No active project')
+  })
+
+  test('resolveFeature returns FLOWY_FEATURE env var', async () => {
+    process.env.FLOWY_FEATURE = 'feat_123'
+    const { resolveFeature } = await import('./config.ts')
+    expect(resolveFeature()).toBe('feat_123')
+  })
+
+  test('resolveFeature falls back to activeFeature from project config', async () => {
+    const { saveConfig, loadConfig, resolveFeature } = await import(
+      './config.ts'
+    )
+    const config = loadConfig()
+    const cwd = process.cwd()
+    config.projects[cwd] = {
+      id: 'proj_1',
+      name: 'Test',
+      activeFeature: 'feat_abc',
+    }
+    saveConfig(config)
+    expect(resolveFeature()).toBe('feat_abc')
+  })
+
+  test('requireFeature throws when no feature set', async () => {
+    const { requireFeature } = await import('./config.ts')
+    expect(() => requireFeature()).toThrow('No active feature')
+  })
+
+  test('updateProjectConfig modifies project entry for cwd', async () => {
+    const { saveConfig, loadConfig, updateProjectConfig } = await import(
+      './config.ts'
+    )
+    const config = loadConfig()
+    const cwd = process.cwd()
+    config.projects[cwd] = { id: 'proj_1', name: 'Test' }
+    saveConfig(config)
+    updateProjectConfig((p) => {
+      p.activeFeature = 'feat_999'
+    })
+    const updated = loadConfig()
+    expect(
+      (updated.projects[cwd] as { activeFeature?: string }).activeFeature,
+    ).toBe('feat_999')
+  })
+})

package/src/util/config.ts

@@ -1,5 +1,110 @@
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs'
+import { homedir } from 'node:os'
+import { resolve } from 'node:path'
+
+const CONFIG_DIR = resolve(homedir(), '.config', 'flowy')
+const CONFIG_PATH = resolve(CONFIG_DIR, 'config.json')
+
+export function loadConfig() {
+  if (!existsSync(CONFIG_PATH)) {
+    return {
+      mode: 'saas' as const,
+      apiUrl: 'https://flowy-ai.fly.dev/graphql',
+      apiKey: '',
+      client: { name: '' },
+      projects: {} as Record<string, unknown>,
+    }
+  }
+  return JSON.parse(readFileSync(CONFIG_PATH, 'utf-8'))
+}
+
+export function saveConfig(config: ReturnType<typeof loadConfig>): void {
+  mkdirSync(CONFIG_DIR, { recursive: true })
+  writeFileSync(CONFIG_PATH, JSON.stringify(config, null, 2))
+}
+
+export interface ProjectConfig {
+  id: string
+  name: string
+  activeFeature?: string
+}
+
+export function resolveProject(): ProjectConfig | null {
+  const envProject = process.env.FLOWY_PROJECT
+  const config = loadConfig()
+
+  if (envProject) {
+    return (
+      (Object.values(config.projects).find(
+        (p) => (p as ProjectConfig).name === envProject,
+      ) as ProjectConfig) ?? null
+    )
+  }
+
+  const cwd = process.cwd()
+  let bestMatch: ProjectConfig | null = null
+  let bestLength = 0
+
+  for (const [path, project] of Object.entries(config.projects)) {
+    if (
+      (cwd === path || cwd.startsWith(`${path}/`)) &&
+      path.length > bestLength
+    ) {
+      bestMatch = project as ProjectConfig
+      bestLength = path.length
+    }
+  }
+
+  return bestMatch
+}
+
+export function resolveFeature(): string | null {
+  const envFeature = process.env.FLOWY_FEATURE
+  if (envFeature) return envFeature
+  const project = resolveProject()
+  return project?.activeFeature ?? null
+}
+
+export function requireFeature(): string {
+  const feature = resolveFeature()
+  if (!feature) {
+    throw new Error(
+      'No active feature. Run "flowy feature set <name-or-id>" or set FLOWY_FEATURE.',
+    )
+  }
+  return feature
+}
+
+export function requireProject(): ProjectConfig {
+  const project = resolveProject()
+  if (!project) {
+    throw new Error(
+      'No active project. Run "flowy project set <name>" or set FLOWY_PROJECT.',
+    )
+  }
+  return project
+}
+
+export function updateProjectConfig(
+  updater: (project: ProjectConfig) => void,
+): void {
+  const config = loadConfig()
+  const cwd = process.cwd()
+
+  for (const [path, project] of Object.entries(config.projects)) {
+    if (cwd === path || cwd.startsWith(`${path}/`)) {
+      updater(project as ProjectConfig)
+      saveConfig(config)
+      return
+    }
+  }
+
+  throw new Error('No directory mapping. Run "flowy project set <name>" first.')
+}
+
 export function getConfig() {
-  const apiUrl = process.env.FLOWY_API_URL ?? 'https://flowy-ai.fly.dev/graphql'
-  const apiKey = process.env.FLOWY_API_KEY ?? ''
+  const config = loadConfig()
+  const apiUrl = process.env.FLOWY_API_URL ?? config.apiUrl
+  const apiKey = process.env.FLOWY_API_KEY ?? config.apiKey
   return { apiUrl, apiKey }
 }

package/src/util/description.test.ts

@@ -0,0 +1,29 @@
+import { rmSync, writeFileSync } from 'node:fs'
+import { dirname, resolve } from 'node:path'
+import { fileURLToPath } from 'node:url'
+import { afterEach, describe, expect, test } from 'vitest'
+
+const __dirname = dirname(fileURLToPath(import.meta.url))
+
+describe('resolveDescription', () => {
+  const TEST_FILE = resolve(__dirname, '../../.test-desc.md')
+
+  afterEach(() => {
+    try {
+      rmSync(TEST_FILE)
+    } catch {}
+  })
+
+  test('returns file content when path exists', async () => {
+    writeFileSync(TEST_FILE, '# Test\nSome content')
+    const { resolveDescription } = await import('./description.ts')
+    const result = await resolveDescription(TEST_FILE)
+    expect(result).toBe('# Test\nSome content')
+  })
+
+  test('returns value as-is when path does not exist', async () => {
+    const { resolveDescription } = await import('./description.ts')
+    const result = await resolveDescription('Just a plain description')
+    expect(result).toBe('Just a plain description')
+  })
+})

package/src/util/description.ts

@@ -0,0 +1,8 @@
+import { existsSync, readFileSync } from 'node:fs'
+
+export async function resolveDescription(value: string): Promise<string> {
+  if (existsSync(value)) {
+    return readFileSync(value, 'utf-8')
+  }
+  return value
+}

package/src/commands/edge.ts

@@ -1,84 +0,0 @@
-import { Command } from 'commander'
-import { graphql } from '../util/client.ts'
-import { output, outputError } from '../util/format.ts'
-
-export const edgeCommand = new Command('edge').description(
-  'Manage edges between nodes',
-)
-
-edgeCommand
-  .command('create')
-  .description('Create an edge between two nodes')
-  .requiredOption('--source <id>', 'Source node ID')
-  .requiredOption('--target <id>', 'Target node ID')
-  .requiredOption(
-    '--relation <rel>',
-    'Relation type (part_of, depends_on, blocks, informs)',
-  )
-  .action(async (opts) => {
-    try {
-      const data = await graphql<{ createEdge: unknown }>(
-        `mutation CreateEdge($sourceId: String!, $targetId: String!, $relation: String!) {
-          createEdge(sourceId: $sourceId, targetId: $targetId, relation: $relation) {
-            sourceId targetId relation createdAt
-          }
-        }`,
-        {
-          sourceId: opts.source,
-          targetId: opts.target,
-          relation: opts.relation,
-        },
-      )
-      output(data.createEdge)
-    } catch (error) {
-      outputError(error)
-    }
-  })
-
-edgeCommand
-  .command('remove')
-  .description('Remove an edge')
-  .requiredOption('--source <id>', 'Source node ID')
-  .requiredOption('--target <id>', 'Target node ID')
-  .requiredOption('--relation <rel>', 'Relation type')
-  .action(async (opts) => {
-    try {
-      const data = await graphql<{ removeEdge: boolean }>(
-        `mutation RemoveEdge($sourceId: String!, $targetId: String!, $relation: String!) {
-          removeEdge(sourceId: $sourceId, targetId: $targetId, relation: $relation)
-        }`,
-        {
-          sourceId: opts.source,
-          targetId: opts.target,
-          relation: opts.relation,
-        },
-      )
-      output({ removed: data.removeEdge })
-    } catch (error) {
-      outputError(error)
-    }
-  })
-
-edgeCommand
-  .command('list')
-  .description('List edges')
-  .option('--node <id>', 'Filter by node ID')
-  .option('--relation <rel>', 'Filter by relation type')
-  .action(async (opts) => {
-    try {
-      const data = await graphql<{ edges: unknown[] }>(
-        `query ListEdges($nodeId: String, $relation: String) {
-          edges(nodeId: $nodeId, relation: $relation) {
-            sourceId targetId relation createdAt
-          }
-        }`,
-        {
-          nodeId: opts.node,
-          relation: opts.relation,
-        },
-      )
-      output(data.edges)
-    } catch (error) {
-      outputError(error)
-    }
-  })