@sqaoss/flowy 1.7.0 → 1.8.0

package/src/commands/task.ts

@@ -3,6 +3,19 @@ import { graphql } from '../util/client.ts'
 import { requireFeature, resolveProject } from '../util/config.ts'
 import { resolveDescription } from '../util/description.ts'
 import { output, outputError } from '../util/format.ts'
+import {
+  ALL_TASKS,
+  BLOCK_TASK,
+  CREATE_TASK,
+  DELETE_NODE,
+  LINK_TASK,
+  LIST_TASKS,
+  READY_TASKS,
+  SHOW_TASK,
+  TASK_DEPS,
+  UNBLOCK_TASK,
+  UPDATE_NODE,
+} from '../util/operations.ts'
 
 export const taskCommand = new Command('task').description(
   'Manage tasks in the active feature',
@@ -27,23 +40,17 @@ taskCommand
         description: opts.description,
         descriptionFile: opts.descriptionFile,
       })
-      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 data = await graphql<{ createNode: { id: string } }>(CREATE_TASK, {
+        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' },
-      )
+      await graphql(LINK_TASK, {
+        sourceId: taskId,
+        targetId: featureId,
+        relation: 'part_of',
+      })
       output(data.createNode)
     } catch (error) {
       outputError(error)
@@ -67,40 +74,27 @@ taskCommand
       if (opts.ready) {
         const projectId =
           opts.project ?? (opts.all ? undefined : resolveProject()?.id)
-        const data = await graphql<{ readyTasks: unknown[] }>(
-          `query ReadyTasks($projectId: String) {
-            readyTasks(projectId: $projectId) {
-              id type title status createdAt
-            }
-          }`,
-          { projectId: projectId ?? null },
-        )
+        const data = await graphql<{ readyTasks: unknown[] }>(READY_TASKS, {
+          projectId: projectId ?? null,
+        })
         output(data.readyTasks)
         return
       }
 
       if (opts.all) {
-        const data = await graphql<{ nodes: unknown[] }>(
-          `query AllTasks($type: String!) {
-            nodes(type: $type) {
-              id type title status createdAt
-            }
-          }`,
-          { type: 'task' },
-        )
+        const data = await graphql<{ nodes: unknown[] }>(ALL_TASKS, {
+          type: 'task',
+        })
         output(data.nodes)
         return
       }
 
       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 data = await graphql<{ descendants: unknown[] }>(LIST_TASKS, {
+        nodeId: featureId,
+        relation: 'part_of',
+        maxDepth: 1,
+      })
       const tasks = data.descendants.filter(
         (n: unknown) => (n as { type: string }).type === 'task',
       )
@@ -120,20 +114,7 @@ taskCommand
         node: Record<string, unknown>
         blockedBy: unknown[]
         blocks: unknown[]
-      }>(
-        `query ShowTask($id: String!) {
-          node(id: $id) {
-            id type title description status metadata createdAt updatedAt
-          }
-          blockedBy: edges(nodeId: $id, relation: "blocks", direction: "incoming") {
-            id type title status
-          }
-          blocks: edges(nodeId: $id, relation: "blocks", direction: "outgoing") {
-            id type title status
-          }
-        }`,
-        { id },
-      )
+      }>(SHOW_TASK, { id })
       output({
         ...data.node,
         blockedBy: data.blockedBy,
@@ -170,11 +151,7 @@ taskCommand
       }
       if (opts.metadata != null) variables.metadata = opts.metadata
       const data = await graphql<{ updateNode: unknown }>(
-        `mutation UpdateNode($id: String!, $title: String, $description: String, $metadata: String) {
-          updateNode(id: $id, title: $title, description: $description, metadata: $metadata) {
-            id type title description status metadata createdAt updatedAt
-          }
-        }`,
+        UPDATE_NODE,
         variables,
       )
       output(data.updateNode)
@@ -189,12 +166,7 @@ taskCommand
   .argument('<id>', 'Task ID')
   .action(async (id: string) => {
     try {
-      const data = await graphql<{ deleteNode: boolean }>(
-        `mutation DeleteNode($id: String!) {
-          deleteNode(id: $id)
-        }`,
-        { id },
-      )
+      const data = await graphql<{ deleteNode: boolean }>(DELETE_NODE, { id })
       output({ deleted: data.deleteNode })
     } catch (error) {
       outputError(error)
@@ -208,14 +180,11 @@ taskCommand
   .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' },
-      )
+      const data = await graphql<{ createEdge: unknown }>(BLOCK_TASK, {
+        sourceId: id1,
+        targetId: id2,
+        relation: 'blocks',
+      })
       output(data.createEdge)
     } catch (error) {
       outputError(error)
@@ -229,12 +198,11 @@ taskCommand
   .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' },
-      )
+      const data = await graphql<{ removeEdge: boolean }>(UNBLOCK_TASK, {
+        sourceId: id1,
+        targetId: id2,
+        relation: 'blocks',
+      })
       output({ removed: data.removeEdge })
     } catch (error) {
       outputError(error)
@@ -248,14 +216,7 @@ taskCommand
   .action(async (id: string) => {
     try {
       const data = await graphql<{ blockedBy: unknown[]; blocks: unknown[] }>(
-        `query TaskDeps($id: String!) {
-          blockedBy: edges(nodeId: $id, relation: "blocks", direction: "incoming") {
-            id type title status
-          }
-          blocks: edges(nodeId: $id, relation: "blocks", direction: "outgoing") {
-            id type title status
-          }
-        }`,
+        TASK_DEPS,
         { id },
       )
       output({ id, blockedBy: data.blockedBy, blocks: data.blocks })

package/src/commands/tree.ts

@@ -1,6 +1,7 @@
 import { Command } from 'commander'
 import { graphql } from '../util/client.ts'
 import { output, outputError } from '../util/format.ts'
+import { SUBTREE } from '../util/operations.ts'
 
 export const treeCommand = new Command('tree')
   .description('Show subtree from any entity')
@@ -8,14 +9,10 @@ export const treeCommand = new Command('tree')
   .option('--depth <n>', 'Max depth', '10')
   .action(async (id: string, opts) => {
     try {
-      const data = await graphql<{ subtree: unknown[] }>(
-        `query Subtree($nodeId: String!, $maxDepth: Int) {
-          subtree(nodeId: $nodeId, maxDepth: $maxDepth) {
-            id type title status
-          }
-        }`,
-        { nodeId: id, maxDepth: Number.parseInt(opts.depth, 10) },
-      )
+      const data = await graphql<{ subtree: unknown[] }>(SUBTREE, {
+        nodeId: id,
+        maxDepth: Number.parseInt(opts.depth, 10),
+      })
       output(data.subtree)
     } catch (error) {
       outputError(error)

package/src/commands/whoami.test.ts

@@ -9,7 +9,7 @@ beforeEach(() => {
   mockOutput = vi.fn()
   mockOutputError = vi.fn()
   mockLoadConfig = vi.fn(() => ({
-    mode: 'saas',
+    mode: 'remote',
     apiUrl: 'https://flowy-ai.fly.dev/graphql',
     apiKey: 'flowy_secret_abcdef0123456789',
     client: { name: '' },
@@ -42,6 +42,16 @@ beforeEach(() => {
     return {
       loadConfig: mockLoadConfig,
       fingerprintKey: actual.fingerprintKey,
+      requireRemoteMode: (commandName: string) => {
+        const cfg = (mockLoadConfig as unknown as () => { mode: string })()
+        if (cfg.mode === 'local') {
+          const err = new Error(
+            `"flowy ${commandName}" is only available in remote mode. The active mode is local mode.`,
+          ) as Error & { code?: string }
+          err.code = 'LOCAL_MODE'
+          throw err
+        }
+      },
     }
   })
 })
@@ -100,4 +110,27 @@ describe('whoami command', () => {
     const query = mockGraphql.mock.calls[0]?.[0] as string
     expect(query).toContain('graceEndsAt')
   })
+
+  test('whoami errors cleanly in local mode without hitting the server', async () => {
+    mockLoadConfig.mockReturnValue({
+      mode: 'local',
+      apiUrl: 'http://localhost:4000/graphql',
+      apiKey: '',
+      client: { name: '' },
+      projects: {},
+    })
+
+    const { whoamiCommand } = await import('./whoami.ts')
+    await whoamiCommand.parseAsync([], { from: 'user' })
+
+    // No GraphQL call against the local server.
+    expect(mockGraphql).not.toHaveBeenCalled()
+    expect(mockOutput).not.toHaveBeenCalled()
+    expect(mockOutputError).toHaveBeenCalledWith(
+      expect.objectContaining({
+        message: expect.stringMatching(/local mode/i),
+        code: 'LOCAL_MODE',
+      }),
+    )
+  })
 })

package/src/commands/whoami.ts

@@ -1,19 +1,19 @@
 import { Command } from 'commander'
 import { graphql } from '../util/client.ts'
-import { fingerprintKey, loadConfig } from '../util/config.ts'
+import {
+  fingerprintKey,
+  loadConfig,
+  requireRemoteMode,
+} from '../util/config.ts'
 import { output, outputError } from '../util/format.ts'
+import { WHOAMI } from '../util/operations.ts'
 
 export const whoamiCommand = new Command('whoami')
   .description('Show current user info')
   .action(async () => {
     try {
-      const data = await graphql<{ whoami: Record<string, unknown> }>(
-        `query Whoami {
-          whoami {
-            id email tier createdAt graceEndsAt
-          }
-        }`,
-      )
+      requireRemoteMode('whoami')
+      const data = await graphql<{ whoami: Record<string, unknown> }>(WHOAMI)
       // Surface a non-reversible fingerprint of the configured key so a human
       // can confirm *which* credential is active without exposing it (F35).
       output({

package/src/util/config.test.ts

@@ -52,7 +52,9 @@ describe('config', () => {
   test('loadConfig returns defaults when no config file exists', async () => {
     const { loadConfig } = await import('./config.ts')
     const config = loadConfig()
-    expect(config.mode).toBe('saas')
+    // Canonical default mode is "remote" (was "saas" — kept as a back-compat
+    // alias on read only).
+    expect(config.mode).toBe('remote')
     expect(config.apiUrl).toBe('https://flowy-ai.fly.dev/graphql')
     expect(config.apiKey).toBe('')
     expect(config.client.name).toBe('')
@@ -196,4 +198,169 @@ describe('config', () => {
       (updated.projects[cwd] as { activeFeature?: string }).activeFeature,
     ).toBe('feat_999')
   })
+
+  describe('per-mode profiles (F25)', () => {
+    test('default config canonicalizes mode to "remote"', async () => {
+      const { loadConfig } = await import('./config.ts')
+      const config = loadConfig()
+      // Canonical vocab is "remote"; "saas" is only a back-compat alias.
+      expect(config.mode).toBe('remote')
+    })
+
+    test('local apiKey/projects do not bleed into remote mode', async () => {
+      const { saveConfig, loadConfig } = await import('./config.ts')
+
+      // Configure the local profile with a key + a project mapping.
+      const local = loadConfig()
+      local.mode = 'local'
+      local.apiKey = 'local-secret'
+      local.apiUrl = 'http://localhost:4000/graphql'
+      local.projects['/work/local'] = { id: 'proj_local', name: 'LocalProj' }
+      saveConfig(local)
+
+      // Switch to remote: the local key/projects must NOT be visible.
+      const remote = loadConfig()
+      remote.mode = 'remote'
+      expect(remote.apiKey).toBe('')
+      expect(remote.apiUrl).toBe('https://flowy-ai.fly.dev/graphql')
+      expect(remote.projects['/work/local']).toBeUndefined()
+
+      // Set a different key/project in remote mode and persist.
+      remote.apiKey = 'remote-secret'
+      remote.projects['/work/remote'] = {
+        id: 'proj_remote',
+        name: 'RemoteProj',
+      }
+      saveConfig(remote)
+
+      // Back to local: local data intact, remote data not visible.
+      const reloadLocal = loadConfig()
+      reloadLocal.mode = 'local'
+      expect(reloadLocal.apiKey).toBe('local-secret')
+      expect(reloadLocal.projects['/work/local']?.name).toBe('LocalProj')
+      expect(reloadLocal.projects['/work/remote']).toBeUndefined()
+    })
+
+    test('getConfig reads from the active mode profile, not the other', async () => {
+      const { saveConfig, loadConfig, getConfig } = await import('./config.ts')
+
+      const local = loadConfig()
+      local.mode = 'local'
+      local.apiKey = 'local-secret'
+      local.apiUrl = 'http://localhost:4000/graphql'
+      saveConfig(local)
+
+      const remote = loadConfig()
+      remote.mode = 'remote'
+      remote.apiKey = 'remote-secret'
+      saveConfig(remote)
+
+      // Active mode is now remote (last saved). getConfig sees remote creds.
+      const cfg = getConfig()
+      expect(cfg.apiKey).toBe('remote-secret')
+      expect(cfg.apiUrl).toBe('https://flowy-ai.fly.dev/graphql')
+    })
+
+    test('client name is shared across modes', async () => {
+      const { saveConfig, loadConfig } = await import('./config.ts')
+      const config = loadConfig()
+      config.client.name = 'Acme'
+      saveConfig(config)
+      const reloaded = loadConfig()
+      reloaded.mode = reloaded.mode === 'local' ? 'remote' : 'local'
+      expect(reloaded.client.name).toBe('Acme')
+    })
+
+    test('migrates a legacy flat config into the active-mode profile', async () => {
+      const { loadConfig } = await import('./config.ts')
+      // Legacy shape written by an older CLI: flat apiKey/apiUrl/projects,
+      // mode="saas" (the old vocab).
+      writeFileSync(
+        CONFIG_PATH,
+        JSON.stringify({
+          mode: 'saas',
+          apiUrl: 'https://flowy-ai.fly.dev/graphql',
+          apiKey: 'legacy-key',
+          client: { name: 'Legacy Co' },
+          projects: { '/legacy/path': { id: 'p1', name: 'Legacy' } },
+        }),
+      )
+
+      const config = loadConfig()
+      // "saas" canonicalizes to "remote".
+      expect(config.mode).toBe('remote')
+      // Flat fields land in the (remote) active profile.
+      expect(config.apiKey).toBe('legacy-key')
+      expect(config.projects['/legacy/path']?.name).toBe('Legacy')
+      expect(config.client.name).toBe('Legacy Co')
+    })
+
+    test('resolveProject/resolveFeature use the active mode profile only', async () => {
+      const { saveConfig, loadConfig, resolveProject, resolveFeature } =
+        await import('./config.ts')
+      const cwd = process.cwd()
+
+      const local = loadConfig()
+      local.mode = 'local'
+      local.projects[cwd] = {
+        id: 'proj_local',
+        name: 'Local',
+        activeFeature: 'feat_local',
+      }
+      saveConfig(local)
+
+      const remote = loadConfig()
+      remote.mode = 'remote'
+      remote.projects[cwd] = {
+        id: 'proj_remote',
+        name: 'Remote',
+        activeFeature: 'feat_remote',
+      }
+      saveConfig(remote)
+
+      // Active mode is remote → resolution returns the remote project.
+      expect(resolveProject()?.id).toBe('proj_remote')
+      expect(resolveFeature()).toBe('feat_remote')
+    })
+
+    test('requireRemoteMode throws a coded error in local mode', async () => {
+      const { saveConfig, loadConfig, requireRemoteMode } = await import(
+        './config.ts'
+      )
+      const config = loadConfig()
+      config.mode = 'local'
+      saveConfig(config)
+
+      expect(() => requireRemoteMode('whoami')).toThrow(/local mode/i)
+      try {
+        requireRemoteMode('whoami')
+      } catch (error) {
+        expect((error as { code?: string }).code).toBe('LOCAL_MODE')
+      }
+    })
+
+    test('requireRemoteMode is a no-op in remote mode', async () => {
+      const { saveConfig, loadConfig, requireRemoteMode } = await import(
+        './config.ts'
+      )
+      const config = loadConfig()
+      config.mode = 'remote'
+      saveConfig(config)
+      expect(() => requireRemoteMode('whoami')).not.toThrow()
+    })
+
+    test('a half-written config (mode set, key not yet) still loads cleanly', async () => {
+      const { saveConfig, loadConfig } = await import('./config.ts')
+      // Simulate save-after-mode-switch but before the key arrives.
+      const config = loadConfig()
+      config.mode = 'remote'
+      saveConfig(config)
+
+      const reloaded = loadConfig()
+      expect(reloaded.mode).toBe('remote')
+      expect(reloaded.apiKey).toBe('')
+      expect(reloaded.apiUrl).toBe('https://flowy-ai.fly.dev/graphql')
+      expect(reloaded.projects).toEqual({})
+    })
+  })
 })