@sqaoss/flowy 1.4.0 → 1.6.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sqaoss/flowy",
-  "version": "1.4.0",
+  "version": "1.6.0",
   "description": "Agentic persistent planning",
   "type": "module",
   "bin": {

package/server/src/resolvers.test.ts

@@ -1099,4 +1099,200 @@ describe('createResolvers', () => {
       expect(results).toEqual([])
     })
   })
+
+  describe('Query.readyTasks', () => {
+    function setStatus(id: string, status: string): void {
+      resolvers.Mutation.updateNode(null, { id, status })
+    }
+    function block(blockerId: string, blockedId: string): void {
+      resolvers.Mutation.createEdge(null, {
+        sourceId: blockerId,
+        targetId: blockedId,
+        relation: 'blocks',
+      })
+    }
+
+    it('returns an unblocked, not-done task', () => {
+      const t = create(resolvers, { type: 'task', title: 'Free' })
+      const ready = resolvers.Query.readyTasks(null, {})
+      expect(ready.map((n) => n.id)).toEqual([t.id])
+    })
+
+    it('excludes done and cancelled tasks', () => {
+      const open = create(resolvers, { type: 'task', title: 'Open' })
+      const done = create(resolvers, { type: 'task', title: 'Done' })
+      const cancelled = create(resolvers, { type: 'task', title: 'Cancelled' })
+      setStatus(done.id, 'done')
+      setStatus(cancelled.id, 'cancelled')
+
+      const ready = resolvers.Query.readyTasks(null, {})
+      const ids = ready.map((n) => n.id)
+      expect(ids).toContain(open.id)
+      expect(ids).not.toContain(done.id)
+      expect(ids).not.toContain(cancelled.id)
+    })
+
+    it('excludes a task blocked by an unfinished blocker', () => {
+      const blocker = create(resolvers, { type: 'task', title: 'Blocker' })
+      const blocked = create(resolvers, { type: 'task', title: 'Blocked' })
+      block(blocker.id, blocked.id)
+
+      const ready = resolvers.Query.readyTasks(null, {})
+      const ids = ready.map((n) => n.id)
+      expect(ids).toContain(blocker.id)
+      expect(ids).not.toContain(blocked.id)
+    })
+
+    it('includes a task once all its blockers are done', () => {
+      const blocker = create(resolvers, { type: 'task', title: 'Blocker' })
+      const blocked = create(resolvers, { type: 'task', title: 'Blocked' })
+      block(blocker.id, blocked.id)
+      setStatus(blocker.id, 'done')
+
+      const ready = resolvers.Query.readyTasks(null, {})
+      const ids = ready.map((n) => n.id)
+      // The done blocker is itself excluded; the formerly-blocked task is ready.
+      expect(ids).not.toContain(blocker.id)
+      expect(ids).toContain(blocked.id)
+    })
+
+    it('treats a cancelled blocker as no longer blocking', () => {
+      const blocker = create(resolvers, { type: 'task', title: 'Blocker' })
+      const blocked = create(resolvers, { type: 'task', title: 'Blocked' })
+      block(blocker.id, blocked.id)
+      setStatus(blocker.id, 'cancelled')
+
+      const ready = resolvers.Query.readyTasks(null, {})
+      expect(ready.map((n) => n.id)).toContain(blocked.id)
+    })
+
+    it('still blocks when any one of several blockers is unfinished', () => {
+      const b1 = create(resolvers, { type: 'task', title: 'B1' })
+      const b2 = create(resolvers, { type: 'task', title: 'B2' })
+      const blocked = create(resolvers, { type: 'task', title: 'Blocked' })
+      block(b1.id, blocked.id)
+      block(b2.id, blocked.id)
+      setStatus(b1.id, 'done')
+      // b2 still open -> blocked stays not-ready
+
+      const ready = resolvers.Query.readyTasks(null, {})
+      expect(ready.map((n) => n.id)).not.toContain(blocked.id)
+    })
+
+    it('returns only tasks, never features or projects', () => {
+      const project = create(resolvers, { type: 'project', title: 'P' })
+      const feature = create(resolvers, { type: 'feature', title: 'F' })
+      const task = create(resolvers, { type: 'task', title: 'T' })
+
+      const ready = resolvers.Query.readyTasks(null, {})
+      const ids = ready.map((n) => n.id)
+      expect(ids).toContain(task.id)
+      expect(ids).not.toContain(project.id)
+      expect(ids).not.toContain(feature.id)
+    })
+
+    it('returns exactly the unblocked not-done tasks across a mixed fixture', () => {
+      // free: ready. blocked-by-open: not ready. blocked-by-done: ready.
+      // done: not ready. in_progress + unblocked: ready.
+      const free = create(resolvers, { type: 'task', title: 'free' })
+      const openBlocker = create(resolvers, { type: 'task', title: 'open-b' })
+      const blockedByOpen = create(resolvers, { type: 'task', title: 'bbo' })
+      const doneBlocker = create(resolvers, { type: 'task', title: 'done-b' })
+      const blockedByDone = create(resolvers, { type: 'task', title: 'bbd' })
+      const finished = create(resolvers, { type: 'task', title: 'finished' })
+      const started = create(resolvers, { type: 'task', title: 'started' })
+
+      block(openBlocker.id, blockedByOpen.id)
+      block(doneBlocker.id, blockedByDone.id)
+      setStatus(doneBlocker.id, 'done')
+      setStatus(finished.id, 'done')
+      setStatus(started.id, 'in_progress')
+
+      const ready = resolvers.Query.readyTasks(null, {})
+      const ids = new Set(ready.map((n) => n.id))
+      expect(ids).toEqual(
+        new Set([free.id, openBlocker.id, blockedByDone.id, started.id]),
+      )
+    })
+
+    it('scopes to a project via part_of when projectId is given', () => {
+      const projA = create(resolvers, { type: 'project', title: 'A' })
+      const featA = create(resolvers, { type: 'feature', title: 'FA' })
+      const taskA = create(resolvers, { type: 'task', title: 'TA' })
+      resolvers.Mutation.createEdge(null, {
+        sourceId: featA.id,
+        targetId: projA.id,
+        relation: 'part_of',
+      })
+      resolvers.Mutation.createEdge(null, {
+        sourceId: taskA.id,
+        targetId: featA.id,
+        relation: 'part_of',
+      })
+
+      const projB = create(resolvers, { type: 'project', title: 'B' })
+      const featB = create(resolvers, { type: 'feature', title: 'FB' })
+      const taskB = create(resolvers, { type: 'task', title: 'TB' })
+      resolvers.Mutation.createEdge(null, {
+        sourceId: featB.id,
+        targetId: projB.id,
+        relation: 'part_of',
+      })
+      resolvers.Mutation.createEdge(null, {
+        sourceId: taskB.id,
+        targetId: featB.id,
+        relation: 'part_of',
+      })
+
+      const ready = resolvers.Query.readyTasks(null, { projectId: projA.id })
+      expect(ready.map((n) => n.id)).toEqual([taskA.id])
+    })
+  })
+
+  describe('Query.edges', () => {
+    function block(blockerId: string, blockedId: string): void {
+      resolvers.Mutation.createEdge(null, {
+        sourceId: blockerId,
+        targetId: blockedId,
+        relation: 'blocks',
+      })
+    }
+
+    it('returns blockedBy: incoming blocks edges (sources that block the node)', () => {
+      const blocker = create(resolvers, { type: 'task', title: 'Blocker' })
+      const blocked = create(resolvers, { type: 'task', title: 'Blocked' })
+      block(blocker.id, blocked.id)
+
+      const blockedBy = resolvers.Query.edges(null, {
+        nodeId: blocked.id,
+        relation: 'blocks',
+        direction: 'incoming',
+      })
+      expect(blockedBy.map((n) => n.id)).toEqual([blocker.id])
+    })
+
+    it('returns blocks: outgoing blocks edges (targets the node blocks)', () => {
+      const blocker = create(resolvers, { type: 'task', title: 'Blocker' })
+      const blocked = create(resolvers, { type: 'task', title: 'Blocked' })
+      block(blocker.id, blocked.id)
+
+      const blocks = resolvers.Query.edges(null, {
+        nodeId: blocker.id,
+        relation: 'blocks',
+        direction: 'outgoing',
+      })
+      expect(blocks.map((n) => n.id)).toEqual([blocked.id])
+    })
+
+    it('returns an empty array for a node with no edges', () => {
+      const lonely = create(resolvers, { type: 'task', title: 'Lonely' })
+      expect(
+        resolvers.Query.edges(null, {
+          nodeId: lonely.id,
+          relation: 'blocks',
+          direction: 'incoming',
+        }),
+      ).toEqual([])
+    })
+  })
 })

package/server/src/resolvers.ts

@@ -194,6 +194,74 @@ export function createResolvers(db: Db) {
         return selectNodes(rows)
       },
 
+      // Nodes connected to `nodeId` by `relation`, following edges in the given
+      // direction. 'incoming' returns the *sources* of edges that point at the
+      // node (e.g. for relation 'blocks', the tasks that block it — blockedBy);
+      // 'outgoing' returns the *targets* of edges originating at the node (the
+      // tasks it blocks). Default direction is 'outgoing'.
+      edges: (
+        _: unknown,
+        args: {
+          nodeId: string
+          relation: string
+          direction?: string
+        },
+      ) => {
+        const incoming = args.direction === 'incoming'
+        const sql = incoming
+          ? `SELECT ${prefixedCols()} FROM nodes n
+             JOIN edges e ON n.id = e.source_id
+             WHERE e.target_id = ? AND e.relation = ?`
+          : `SELECT ${prefixedCols()} FROM nodes n
+             JOIN edges e ON n.id = e.target_id
+             WHERE e.source_id = ? AND e.relation = ?`
+        const rows = db.raw
+          .query(sql)
+          .all(args.nodeId, args.relation) as NodeRow[]
+        return selectNodes(rows)
+      },
+
+      // Tasks that are actionable now: type 'task', status not done/cancelled,
+      // and not blocked by any incomplete blocker. A blocker is an incoming
+      // `blocks` edge whose source task is itself not done/cancelled. Optionally
+      // scoped to a project via the `part_of` hierarchy (task -> feature ->
+      // project).
+      readyTasks: (_: unknown, args: { projectId?: string }) => {
+        const params: string[] = []
+        let scope = ''
+        if (args.projectId) {
+          // Restrict to tasks reachable from the project through part_of edges
+          // (any depth). Edges point child -> parent, so we walk upward from
+          // each candidate task to see if the project is an ancestor.
+          scope = `AND n.id IN (
+            WITH RECURSIVE up(id) AS (
+              SELECT source_id FROM edges
+                WHERE target_id = ?1 AND relation = 'part_of'
+              UNION
+              SELECT e.source_id FROM edges e
+                JOIN up ON e.target_id = up.id AND e.relation = 'part_of'
+            )
+            SELECT id FROM up
+          )`
+          params.push(args.projectId)
+        }
+        const rows = db.raw
+          .query(
+            `SELECT ${prefixedCols()} FROM nodes n
+             WHERE n.type = 'task'
+               AND n.status NOT IN ('done', 'cancelled')
+               ${scope}
+               AND NOT EXISTS (
+                 SELECT 1 FROM edges b
+                 JOIN nodes src ON src.id = b.source_id
+                 WHERE b.target_id = n.id AND b.relation = 'blocks'
+                   AND src.status NOT IN ('done', 'cancelled')
+               )`,
+          )
+          .all(...params) as NodeRow[]
+        return selectNodes(rows)
+      },
+
       search: (
         _: unknown,
         args: {

package/server/src/schema.ts

@@ -24,6 +24,8 @@ export const typeDefs = /* GraphQL */ `
     nodes(type: String): [Node!]!
     descendants(nodeId: String!, relation: String, maxDepth: Int): [Node!]!
     subtree(nodeId: String!, maxDepth: Int): [Node!]!
+    edges(nodeId: String!, relation: String!, direction: String): [Node!]!
+    readyTasks(projectId: String): [Node!]!
     search(query: String!, type: String, status: String, limit: Int): [Node!]!
   }
 

package/src/commands/export.test.ts

@@ -0,0 +1,242 @@
+import { beforeEach, describe, expect, test, vi } from 'vitest'
+
+vi.mock('../util/client.ts', () => ({
+  graphql: vi.fn(),
+}))
+
+vi.mock('../util/config.ts', () => ({
+  requireProject: vi.fn(() => ({ id: 'srv_proj', name: 'Demo' })),
+}))
+
+vi.mock('../util/format.ts', () => ({
+  output: vi.fn(),
+  outputError: vi.fn(),
+}))
+
+vi.mock('node:fs', () => ({
+  writeFileSync: vi.fn(),
+}))
+
+const FLOWY_KEY_FIELD = '__flowyKey'
+
+/** A server node row stamped with its client-key only (no edges in metadata). */
+function srv(
+  id: string,
+  type: string,
+  title: string,
+  key: string,
+  extraMeta: Record<string, unknown> = {},
+): Record<string, unknown> {
+  return {
+    id,
+    type,
+    title,
+    description: null,
+    status: 'draft',
+    metadata: JSON.stringify({ ...extraMeta, [FLOWY_KEY_FIELD]: key }),
+  }
+}
+
+/**
+ * Build a graphql mock backed by a node set and a real-edge-model edge set.
+ * `edges` are SERVER-id triples; the `edges()` query returns connected nodes
+ * (with metadata) so export can resolve their client-keys.
+ */
+function mockServer(
+  graphql: ReturnType<typeof vi.fn>,
+  project: Record<string, unknown>,
+  descendants: Array<Record<string, unknown>>,
+  edges: Array<{ source: string; target: string; relation: string }> = [],
+) {
+  const byId = new Map<string, Record<string, unknown>>()
+  for (const n of [project, ...descendants]) byId.set(n.id as string, n)
+  graphql.mockImplementation(
+    async (query: string, variables?: Record<string, unknown>) => {
+      if (query.includes('descendants')) return { descendants }
+      if (query.includes('node(')) return { node: project }
+      if (query.includes('edges(')) {
+        const out = edges
+          .filter(
+            (e) =>
+              e.source === variables?.nodeId &&
+              e.relation === variables?.relation,
+          )
+          .map((e) => {
+            const n = byId.get(e.target)
+            return { id: e.target, metadata: n?.metadata ?? null }
+          })
+        return { edges: out }
+      }
+      return {}
+    },
+  )
+}
+
+describe('export command', () => {
+  beforeEach(() => {
+    vi.clearAllMocks()
+  })
+
+  test('exports a no-argument export command (optional output path)', async () => {
+    const { exportCommand } = await import('./export.ts')
+    expect(exportCommand.name()).toBe('export')
+  })
+
+  test('emits a manifest with client-keys and edges read from the edge model', async () => {
+    const { graphql } = await import('../util/client.ts')
+    const { output } = await import('../util/format.ts')
+    const { exportCommand } = await import('./export.ts')
+
+    const project = srv('srv_proj', 'project', 'Demo', 'proj')
+    const feature = srv('srv_feat-1', 'feature', 'Auth', 'feat-1')
+    const task1 = srv('srv_task-1', 'task', 'Login', 'task-1', {
+      priority: 'high',
+    })
+    const task2 = srv('srv_task-2', 'task', 'Logout', 'task-2')
+
+    mockServer(
+      vi.mocked(graphql),
+      project,
+      [feature, task1, task2],
+      [
+        { source: 'srv_feat-1', target: 'srv_proj', relation: 'part_of' },
+        { source: 'srv_task-1', target: 'srv_feat-1', relation: 'part_of' },
+        { source: 'srv_task-2', target: 'srv_feat-1', relation: 'part_of' },
+        { source: 'srv_task-2', target: 'srv_task-1', relation: 'blocks' },
+      ],
+    )
+
+    await exportCommand.parseAsync([], { from: 'user' })
+
+    const manifest = vi.mocked(output).mock.calls.at(-1)?.[0] as {
+      version: number
+      nodes: Array<Record<string, unknown>>
+      edges: Array<Record<string, unknown>>
+    }
+
+    expect(manifest.version).toBe(1)
+    expect(manifest.nodes).toHaveLength(4)
+
+    const byKey = Object.fromEntries(manifest.nodes.map((n) => [n.key, n]))
+    expect(byKey.proj).toMatchObject({ type: 'project', title: 'Demo' })
+    // The reserved client-key field is stripped from exported user metadata.
+    expect(byKey['task-1']).toMatchObject({
+      type: 'task',
+      parent: 'feat-1',
+      metadata: { priority: 'high' },
+    })
+    expect(
+      (byKey['task-1'] as { metadata: Record<string, unknown> }).metadata
+        .__flowyKey,
+    ).toBeUndefined()
+
+    // 3 part_of edges + 1 blocks edge, expressed in client-keys.
+    expect(manifest.edges).toHaveLength(4)
+    expect(manifest.edges).toContainEqual({
+      source: 'task-2',
+      target: 'task-1',
+      relation: 'blocks',
+    })
+    expect(manifest.edges).toContainEqual({
+      source: 'feat-1',
+      target: 'proj',
+      relation: 'part_of',
+    })
+  })
+
+  test('captures an externally-created (task block) edge, not just import edges', async () => {
+    const { graphql } = await import('../util/client.ts')
+    const { output } = await import('../util/format.ts')
+    const { exportCommand } = await import('./export.ts')
+
+    const project = srv('srv_proj', 'project', 'Demo', 'proj')
+    const task1 = srv('srv_task-1', 'task', 'A', 'task-1')
+    const task2 = srv('srv_task-2', 'task', 'B', 'task-2')
+
+    mockServer(
+      vi.mocked(graphql),
+      project,
+      [task1, task2],
+      [
+        { source: 'srv_task-1', target: 'srv_proj', relation: 'part_of' },
+        { source: 'srv_task-2', target: 'srv_proj', relation: 'part_of' },
+        // This edge exists only in the edge model (e.g. created by `task block`),
+        // never recorded in any node metadata — export must still capture it.
+        { source: 'srv_task-1', target: 'srv_task-2', relation: 'blocks' },
+      ],
+    )
+
+    await exportCommand.parseAsync([], { from: 'user' })
+
+    const manifest = vi.mocked(output).mock.calls.at(-1)?.[0] as {
+      edges: Array<Record<string, unknown>>
+    }
+    expect(manifest.edges).toContainEqual({
+      source: 'task-1',
+      target: 'task-2',
+      relation: 'blocks',
+    })
+  })
+
+  test('writes to a file when an output path is given', async () => {
+    const { graphql } = await import('../util/client.ts')
+    const { writeFileSync } = await import('node:fs')
+    const { exportCommand } = await import('./export.ts')
+
+    const project = srv('srv_proj', 'project', 'Demo', 'proj')
+    mockServer(vi.mocked(graphql), project, [])
+
+    await exportCommand.parseAsync(['out.json'], { from: 'user' })
+
+    expect(writeFileSync).toHaveBeenCalledWith(
+      'out.json',
+      expect.stringContaining('"version": 1'),
+    )
+  })
+
+  test('export output round-trips: it is a valid import manifest', async () => {
+    const { graphql } = await import('../util/client.ts')
+    const { output } = await import('../util/format.ts')
+    const { parseManifest, serializeManifest } = await import(
+      '../util/manifest.ts'
+    )
+    const { exportCommand } = await import('./export.ts')
+
+    const project = srv('srv_proj', 'project', 'Demo', 'proj')
+    const feature = srv('srv_feat-1', 'feature', 'Auth', 'feat-1')
+    const task = srv('srv_task-1', 'task', 'Login', 'task-1')
+
+    mockServer(
+      vi.mocked(graphql),
+      project,
+      [feature, task],
+      [
+        { source: 'srv_feat-1', target: 'srv_proj', relation: 'part_of' },
+        { source: 'srv_task-1', target: 'srv_feat-1', relation: 'part_of' },
+        { source: 'srv_task-1', target: 'srv_feat-1', relation: 'blocks' },
+      ],
+    )
+
+    await exportCommand.parseAsync([], { from: 'user' })
+
+    const manifest = vi.mocked(output).mock.calls.at(-1)?.[0]
+    // Re-parsing the exported manifest through the import parser must succeed
+    // and preserve structure — the export→import contract.
+    const reparsed = parseManifest(serializeManifest(manifest as never))
+    expect(reparsed).toEqual(manifest)
+  })
+
+  test('reports errors via outputError', async () => {
+    const { graphql } = await import('../util/client.ts')
+    const { outputError } = await import('../util/format.ts')
+    const { exportCommand } = await import('./export.ts')
+
+    vi.mocked(graphql).mockRejectedValueOnce(new Error('boom'))
+
+    await exportCommand.parseAsync([], { from: 'user' })
+
+    expect(outputError).toHaveBeenCalledWith(
+      expect.objectContaining({ message: 'boom' }),
+    )
+  })
+})

package/src/commands/export.ts

@@ -0,0 +1,130 @@
+import { writeFileSync } from 'node:fs'
+import { Command } from 'commander'
+import { graphql } from '../util/client.ts'
+import { requireProject } from '../util/config.ts'
+import { output, outputError } from '../util/format.ts'
+import {
+  MANIFEST_VERSION,
+  type Manifest,
+  type ManifestEdge,
+  type ManifestNode,
+  readClientKey,
+  serializeManifest,
+  stripClientKey,
+} from '../util/manifest.ts'
+
+/** Relations export captures from the real edge model. */
+const RELATIONS = ['part_of', 'blocks'] as const
+
+interface ServerNode {
+  id: string
+  type: string
+  title: string
+  description: string | null
+  status: string
+  metadata: string | null
+}
+
+const PROJECT_QUERY = `query ExportProject($id: String!) {
+  node(id: $id) { id type title description status metadata }
+}`
+
+const DESCENDANTS_QUERY = `query ExportDescendants($nodeId: String!, $relation: String, $maxDepth: Int) {
+  descendants(nodeId: $nodeId, relation: $relation, maxDepth: $maxDepth) {
+    id type title description status metadata
+  }
+}`
+
+const EDGES_QUERY = `query ExportEdges($nodeId: String!, $relation: String!) {
+  edges(nodeId: $nodeId, relation: $relation, direction: "outgoing") {
+    id metadata
+  }
+}`
+
+export const exportCommand = new Command('export')
+  .description(
+    'Dump the active project (nodes + edges, with client-keys) as a manifest',
+  )
+  .argument('[output]', 'Write to this file instead of stdout')
+  .action(async (outputPath: string | undefined) => {
+    try {
+      const project = requireProject()
+      const root = await graphql<{ node: ServerNode | null }>(PROJECT_QUERY, {
+        id: project.id,
+      })
+      if (!root.node) {
+        throw new Error(`Active project ${project.id} not found.`)
+      }
+      const descendants = await graphql<{ descendants: ServerNode[] }>(
+        DESCENDANTS_QUERY,
+        { nodeId: project.id, relation: 'part_of', maxDepth: 100 },
+      )
+
+      const serverNodes = [root.node, ...descendants.descendants]
+
+      // Map server id -> client-key so edges (which the server returns by id)
+      // can be expressed in the manifest's client-key space. A node without a
+      // recorded key falls back to its server id so it still round-trips.
+      const keyOf = (id: string, metadata: string | null) =>
+        readClientKey(metadata) ?? id
+      const keyById = new Map<string, string>()
+      for (const sn of serverNodes)
+        keyById.set(sn.id, keyOf(sn.id, sn.metadata))
+
+      const nodes: ManifestNode[] = serverNodes.map((sn) => {
+        const node: ManifestNode = {
+          key: keyById.get(sn.id) ?? sn.id,
+          type: sn.type,
+          title: sn.title,
+        }
+        if (sn.description != null) node.description = sn.description
+        if (sn.status != null) node.status = sn.status
+        const userMeta = stripClientKey(sn.metadata)
+        if (userMeta) node.metadata = userMeta
+        return node
+      })
+
+      // Read edges back through the real edge model, so we capture ALL edges,
+      // including ones created outside import (e.g. `task block`), not just
+      // those import created.
+      const edges: ManifestEdge[] = []
+      const seen = new Set<string>()
+      for (const sn of serverNodes) {
+        const sourceKey = keyById.get(sn.id) ?? sn.id
+        for (const relation of RELATIONS) {
+          const data = await graphql<{
+            edges: Array<{ id: string; metadata: string | null }>
+          }>(EDGES_QUERY, { nodeId: sn.id, relation })
+          for (const target of data.edges) {
+            const targetKey =
+              keyById.get(target.id) ?? keyOf(target.id, target.metadata)
+            const k = `${sourceKey}|${targetKey}|${relation}`
+            if (seen.has(k)) continue
+            seen.add(k)
+            // part_of is surfaced as the node's `parent` so import re-derives it,
+            // and is also kept in the edge list for a complete dependency graph.
+            if (relation === 'part_of') {
+              const node = nodes.find((n) => n.key === sourceKey)
+              if (node) node.parent = targetKey
+            }
+            edges.push({ source: sourceKey, target: targetKey, relation })
+          }
+        }
+      }
+
+      const manifest: Manifest = { version: MANIFEST_VERSION, nodes, edges }
+
+      if (outputPath) {
+        writeFileSync(outputPath, serializeManifest(manifest))
+        output({
+          exported: nodes.length,
+          edges: edges.length,
+          file: outputPath,
+        })
+      } else {
+        output(manifest)
+      }
+    } catch (error) {
+      outputError(error)
+    }
+  })