@sqaoss/flowy 0.1.1 → 1.1.0

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)
-    }
-  })

package/src/commands/node.ts

@@ -1,134 +0,0 @@
-import { Command } from 'commander'
-import { graphql } from '../util/client.ts'
-import { output, outputError } from '../util/format.ts'
-
-export const nodeCommand = new Command('node').description('Manage work nodes')
-
-nodeCommand
-  .command('create')
-  .description('Create a new node')
-  .requiredOption(
-    '--type <type>',
-    'Node type (client, project, feature, epic, task)',
-  )
-  .requiredOption('--title <title>', 'Node title')
-  .option('--description <desc>', 'Node description')
-  .option('--status <status>', 'Initial status')
-  .option('--metadata <json>', 'Metadata as JSON string')
-  .action(async (opts) => {
-    try {
-      const data = await graphql<{ createNode: unknown }>(
-        `mutation CreateNode($type: String!, $title: String!, $description: String, $status: String, $metadata: String) {
-          createNode(type: $type, title: $title, description: $description, status: $status, metadata: $metadata) {
-            id type title description status metadata createdAt updatedAt
-          }
-        }`,
-        {
-          type: opts.type,
-          title: opts.title,
-          description: opts.description,
-          status: opts.status,
-          metadata: opts.metadata,
-        },
-      )
-      output(data.createNode)
-    } catch (error) {
-      outputError(error)
-    }
-  })
-
-nodeCommand
-  .command('get')
-  .description('Get a node by ID')
-  .requiredOption('--id <id>', 'Node ID')
-  .action(async (opts) => {
-    try {
-      const data = await graphql<{ node: unknown }>(
-        `query GetNode($id: String!) {
-          node(id: $id) {
-            id type title description status metadata createdAt updatedAt
-          }
-        }`,
-        { id: opts.id },
-      )
-      output(data.node)
-    } catch (error) {
-      outputError(error)
-    }
-  })
-
-nodeCommand
-  .command('list')
-  .description('List nodes')
-  .option('--type <type>', 'Filter by type')
-  .option('--status <status>', 'Filter by status')
-  .option('--limit <n>', 'Limit results', '50')
-  .option('--offset <n>', 'Offset results', '0')
-  .action(async (opts) => {
-    try {
-      const data = await graphql<{ nodes: unknown[] }>(
-        `query ListNodes($type: String, $status: String, $limit: Int, $offset: Int) {
-          nodes(type: $type, status: $status, limit: $limit, offset: $offset) {
-            id type title description status metadata createdAt updatedAt
-          }
-        }`,
-        {
-          type: opts.type,
-          status: opts.status,
-          limit: Number.parseInt(opts.limit, 10),
-          offset: Number.parseInt(opts.offset, 10),
-        },
-      )
-      output(data.nodes)
-    } catch (error) {
-      outputError(error)
-    }
-  })
-
-nodeCommand
-  .command('update')
-  .description('Update a node')
-  .requiredOption('--id <id>', 'Node ID')
-  .option('--title <title>', 'New title')
-  .option('--description <desc>', 'New description')
-  .option('--status <status>', 'New status')
-  .option('--metadata <json>', 'New metadata as JSON string')
-  .action(async (opts) => {
-    try {
-      const data = await graphql<{ updateNode: unknown }>(
-        `mutation UpdateNode($id: String!, $title: String, $description: String, $status: String, $metadata: String) {
-          updateNode(id: $id, title: $title, description: $description, status: $status, metadata: $metadata) {
-            id type title description status metadata createdAt updatedAt
-          }
-        }`,
-        {
-          id: opts.id,
-          title: opts.title,
-          description: opts.description,
-          status: opts.status,
-          metadata: opts.metadata,
-        },
-      )
-      output(data.updateNode)
-    } catch (error) {
-      outputError(error)
-    }
-  })
-
-nodeCommand
-  .command('delete')
-  .description('Delete a node')
-  .requiredOption('--id <id>', 'Node ID')
-  .action(async (opts) => {
-    try {
-      const data = await graphql<{ deleteNode: boolean }>(
-        `mutation DeleteNode($id: String!) {
-          deleteNode(id: $id)
-        }`,
-        { id: opts.id },
-      )
-      output({ deleted: data.deleteNode })
-    } catch (error) {
-      outputError(error)
-    }
-  })

package/src/commands/register.ts

@@ -1,25 +0,0 @@
-import { Command } from 'commander'
-import { graphql } from '../util/client.ts'
-import { output, outputError } from '../util/format.ts'
-
-export const registerCommand = new Command('register')
-  .description('Register a new account')
-  .requiredOption('--email <email>', 'Your email address')
-  .action(async (opts) => {
-    try {
-      const data = await graphql<{
-        register: { user: { id: string; email: string }; apiKey: string }
-      }>(
-        `mutation Register($email: String!) {
-          register(email: $email) {
-            user { id email tier createdAt }
-            apiKey
-          }
-        }`,
-        { email: opts.email },
-      )
-      output(data.register)
-    } catch (error) {
-      outputError(error)
-    }
-  })