@sqaoss/flowy 1.0.2 → 1.1.0

package/README.md

@@ -1,62 +1,89 @@
 # Flowy
 
-Project management for AI coding agents.
+Agentic persistent planning
 
 [![npm](https://img.shields.io/npm/v/@sqaoss/flowy)](https://www.npmjs.com/package/@sqaoss/flowy)
 [![License: Apache-2.0](https://img.shields.io/badge/License-Apache--2.0-blue.svg)](LICENSE)
 [![CI](https://github.com/sqaoss/flowy/actions/workflows/ci.yml/badge.svg)](https://github.com/sqaoss/flowy/actions/workflows/ci.yml)
 
-## What is Flowy
+Jira, Linear, Trello are built for humans clicking boards. AI agents don't click boards. When your agent needs to plan work, track progress, and close tickets, those tools add friction, load context, and get in the way.
 
-Flowy is a backend + CLI that gives AI coding agents structured project management. It enforces a strict hierarchy -- **client -> project -> feature -> task** -- so agents always have clear context about what they're working on.
+Flowy is where agents store plans and flow through execution. Features are master plans. Tasks are execution steps. Everything persists in a database, not as files cluttering your git history. Your agent flows through work without friction.
 
-Run it locally with SQLite and Docker, or connect to the hosted SaaS for multi-agent team collaboration.
+You get full observability on what every agent planned, built, and shipped.
 
-## Quick Start (Local Mode)
+## Get Started
 
-Local mode runs a Flowy server on your machine using Docker. No account needed.
+### Install (once)
 
 ```bash
-# Install
-bun add -g @sqaoss/flowy    # or: npm i -g @sqaoss/flowy
+npm i -g @sqaoss/flowy
+flowy setup remote --email you@example.com
+```
 
-# Start the local server (requires Docker)
-flowy setup local
+### Initialize a project
 
-# Set your client name
-flowy client set name "Acme Corp"
+```bash
+cd my-project
+flowy init           # auto-detects repo, creates project
+```
 
-# Create a project and map it to the current directory
-flowy project create "Auth System"
-flowy project set "Auth System"
+### Start planning
 
-# Plan a feature
-flowy feature create --title "SSO Support" --description sso-spec.md
-flowy feature set "SSO Support"
+```bash
+flowy feature create --title "User Auth" --description auth-spec.md
+flowy feature set "User Auth"
 
-# Create tasks
 flowy task create --title "Implement OAuth" --description oauth.md
-flowy task create --title "Write auth tests" --description "Unit + integration tests"
+flowy task create --title "Write tests" --description "Unit + integration"
 
-# Track progress
 flowy status <task-id> in_progress
 flowy status <task-id> done
+```
+
+Every command outputs JSON. Your agent reads it, acts on it, moves to the next task.
+
+## Agent Skill
+
+Flowy installs an agent skill during setup. Your AI agent automatically knows every command. No manual configuration needed.
+
+Or install the skill manually: `npx skills add sqaoss/flowy`
+
+See [skills/using-flowy/SKILL.md](skills/using-flowy/SKILL.md) for the full skill reference.
+
+## Data Model
 
-# Search and explore
-flowy search "OAuth" --type task
-flowy tree <project-id> --depth 3
 ```
+project -> feature -> task
+  1:many     1:many
+```
+
+Every task belongs to a feature. Every feature belongs to a project. No orphans.
 
-## Remote Mode (Coming Soon)
+### Status Flow
 
-Remote mode connects to the hosted Flowy SaaS for multi-agent collaboration, shared project state across teams, and persistent history. Registration and API key setup will happen directly through the CLI -- no website needed. This is currently a work in progress.
+```
+draft -> pending_review -> approved -> in_progress -> done
+```
+
+Also: `blocked`, `cancelled`. Only `pending_review` entities can be approved.
+
+## Self-Hosted
+
+Run Flowy on your own machine with SQLite and Docker. Same CLI, same commands.
+
+```bash
+flowy setup local    # starts a local server via Docker
+flowy init           # auto-detects repo
+```
 
 ## Command Reference
 
 | Command | Description |
 |---------|-------------|
+| `setup remote --email <email>` | Register and connect to the hosted server |
 | `setup local` | Start a local Docker server and configure the CLI |
-| `setup remote` | Connect to the hosted SaaS (coming soon) |
+| `init` | Auto-detect repo and create/map project |
 | `whoami` | Show current user |
 | `client set name <name>` | Set client display name |
 | `project create <name>` | Create project |
@@ -80,63 +107,27 @@ Remote mode connects to the hosted Flowy SaaS for multi-agent collaboration, sha
 
 All commands output JSON to stdout.
 
-## Data Model
-
-### Entity Hierarchy
-
-```
-client -> project -> feature -> task
-           1:many    1:many    1:many
-```
-
-Every entity belongs to its parent. No orphans.
-
-### Status Flow
-
-```
-draft -> pending_review -> approved -> in_progress -> done
-```
-
-Also: `blocked`, `cancelled`
-
-### Description Field
-
-`--description` accepts a file path or an inline string:
-- `--description spec.md` -- reads file content
-- `--description "Do the thing"` -- sends string as-is
-
 ## Configuration
 
 Config is stored at `~/.config/flowy/config.json`.
 
 | Variable | Description | Default |
 |----------|-------------|---------|
-| `FLOWY_API_URL` | GraphQL endpoint | `http://localhost:4000/graphql` |
-| `FLOWY_API_KEY` | API key (remote mode only) | -- |
+| `FLOWY_API_URL` | GraphQL endpoint | `https://flowy-ai.fly.dev/graphql` |
+| `FLOWY_API_KEY` | API key (remote mode) | -- |
 | `FLOWY_PROJECT` | Override active project by name | -- |
 | `FLOWY_FEATURE` | Override active feature by ID | -- |
 
-## For AI Agents
-
-Flowy integrates with [TanStack Intent](https://github.com/TanStack/intent) for automatic tool discovery. Run:
-
-```bash
-npx @tanstack/intent install
-```
-
-This auto-discovers the Flowy skill and makes it available to your agent. See [`skills/using-flowy/SKILL.md`](skills/using-flowy/SKILL.md) for the full skill reference.
-
 ## Development
 
 ```bash
-bun run test          # Run CLI tests (Vitest)
-bun run check         # Biome lint + format
-bun run typecheck     # TypeScript type checking
+bun run test          # CLI tests
+bun run check         # Lint + format
+bun run typecheck     # TypeScript
 
-# Server tests
-cd server && bunx --bun vitest run
+cd server && bunx --bun vitest run   # Server tests
 ```
 
 ## License
 
-Apache-2.0 -- Copyright 2026 SQA & Automation SRL
+Apache-2.0. Copyright 2026 SQA & Automation SRL.

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@sqaoss/flowy",
-  "version": "1.0.2",
-  "description": "CLI for Flowy — project management for AI coding agents",
+  "version": "1.1.0",
+  "description": "Agentic persistent planning",
   "type": "module",
   "bin": {
     "flowy": "./src/index.ts"
@@ -42,7 +42,8 @@
     "ai-agents",
     "graphql",
     "bun",
-    "tanstack-intent"
+    "agentic",
+    "planning"
   ],
   "scripts": {
     "cli": "bun src/index.ts",
@@ -60,7 +61,6 @@
   },
   "devDependencies": {
     "@biomejs/biome": "2.4.4",
-    "@tanstack/intent": "^0.0.23",
     "@commitlint/cli": "^20.4.2",
     "@commitlint/config-conventional": "^20.4.2",
     "husky": "^9.1.7",

package/skills/using-flowy/SKILL.md

@@ -1,153 +1,128 @@
 ---
-name: using-flowy
-description: Project management CLI for AI coding agents — create projects, features, tasks, track status and approvals
-metadata:
-  sources:
-    - src/commands/project.ts
-    - src/commands/feature.ts
-    - src/commands/task.ts
-    - src/commands/status.ts
-    - src/commands/approve.ts
-    - src/commands/search.ts
-    - src/commands/tree.ts
-    - src/commands/setup.ts
-    - src/util/config.ts
+name: flowy
+description: Store plans and track execution with Flowy CLI. Use when you need to create features, break work into tasks, track progress, or manage project structure. Trigger on any planning, task tracking, or work organization request.
 ---
 
-# Flowy — Project Management for AI Agents
+# Flowy — Agentic Persistent Planning
 
-Flowy is a hosted project management backend. You interact with it via the `flowy` CLI.
+Flowy gives you a persistent store for plans and execution tracking. Features are your master plans. Tasks are your execution steps. Everything persists across sessions, no files in git, no context lost.
 
-## Setup
+## Why Use Flowy
 
-```bash
-# Install globally
-bun add -g @sqaoss/flowy    # or: npm i -g @sqaoss/flowy
+Without Flowy, your plans live in markdown files that clutter git history, get deleted when done, and leave no record of what you accomplished. With Flowy, plans persist in a database. You flow through work without friction. Your human gets full observability.
 
-# SaaS mode (hosted)
-flowy setup --mode saas --email you@example.com
-export FLOWY_API_KEY=flowy_xxx_yyy
+## First Time in a Project
 
-# Self-hosted mode
-flowy setup --mode local --api-url http://localhost:4000/graphql
+```bash
+flowy init           # auto-detects the git repo, creates a project, maps this directory
 ```
 
-## Hierarchy
+If Flowy isn't set up yet, the human needs to run:
+```bash
+npm i -g @sqaoss/flowy
+flowy setup remote --email their@email.com
+```
 
-Strict top-down: **client → project → feature → task**. No orphans at any level.
+## Core Workflow
 
-- A client has many projects
-- A project has many features
-- A feature has many tasks
+```bash
+# 1. Plan a feature (master plan)
+flowy feature create --title "User Auth" --description auth-spec.md
+flowy feature set "User Auth"
 
-## Context
+# 2. Break into tasks (execution steps)
+flowy task create --title "Implement OAuth" --description oauth.md
+flowy task create --title "Write tests" --description "Unit + integration tests"
 
-Flowy uses context to know which project and feature you're working in:
+# 3. Execute and track
+flowy status <task-id> in_progress
+# ... do the work ...
+flowy status <task-id> done
 
-- **Project**: mapped to a directory via `flowy project set <name>`, or `FLOWY_PROJECT` env var
-- **Feature**: set via `flowy feature set <name-or-id>`, or `FLOWY_FEATURE` env var
+# 4. Move to next task or feature
+flowy feature create --title "API Rate Limiting" --description rate-limit.md
+flowy feature set "API Rate Limiting"
+```
 
-Features and tasks cannot be created without active project/feature context.
+## Entity Hierarchy
 
-## Commands
-
-### Identity
-```bash
-flowy whoami                          # Show current user
+```
+project -> feature -> task
+  1:many     1:many
 ```
 
-### Client
-```bash
-flowy client set name "Acme Corp"     # Set client display name
+Every task belongs to a feature. Every feature belongs to a project. No orphans. The project is set automatically by `flowy init`.
+
+## Status Flow
+
+```
+draft -> pending_review -> approved -> in_progress -> done
 ```
 
-### Projects
+Also: `blocked`, `cancelled`
+
+Only `pending_review` entities can be approved via `flowy approve <id>`.
+
+## Commands
+
+### Project Context
 ```bash
-flowy project create "Auth System"    # Create a project
-flowy project set "Auth System"       # Map current dir to project
+flowy init                            # Auto-detect repo, create + set project
 flowy project list                    # List all projects
-flowy project show                    # Show active project details
-flowy project show <id>               # Show specific project
+flowy project show [<id>]             # Show project details
 ```
 
 ### Features (requires active project)
 ```bash
-flowy feature create --title "SSO Support" --description sso-spec.md
-flowy feature create --title "Stability" --description "Improve error handling"
-flowy feature set "SSO Support"       # Set active feature
+flowy feature create --title "Title" --description "description or file.md"
+flowy feature set "Title or ID"       # Set active feature
 flowy feature unset                   # Clear active feature
 flowy feature list                    # List features in project
-flowy feature show                    # Show active feature
+flowy feature show [<id>]             # Show feature details
 ```
 
 ### Tasks (requires active feature)
 ```bash
-flowy task create --title "Implement OAuth" --description oauth.md
-flowy task create --title "Write tests" --description "Unit tests for auth"
+flowy task create --title "Title" --description "description or file.md"
 flowy task list                       # List tasks in feature
 flowy task show <id>                  # Show task details
-flowy task block <id1> <id2>          # Mark id1 blocks id2
-flowy task unblock <id1> <id2>        # Remove block
+flowy task block <blocker> <blocked>  # Mark dependency
+flowy task unblock <blocker> <blocked>
 ```
 
-### Status & Approval
+### Status and Approval
 ```bash
 flowy status <id> in_progress
-flowy status <id> done
 flowy status <id> pending_review
-flowy approve <id>                    # Must be pending_review
+flowy approve <id>                    # Only works on pending_review
+flowy status <id> done
 ```
 
-### Search & Explore
+### Search and Explore
 ```bash
-flowy search "OAuth" --type task
-flowy search "auth" --status draft --limit 5
-flowy tree <id> --depth 3             # Show subtree
+flowy search "query" --type task --status draft --limit 10
+flowy tree <project-id> --depth 3     # Show full subtree
 ```
 
-## Entity Types
-- `client` — a client or company
-- `project` — a codebase or product
-- `feature` — a unit of work (replaces epic)
-- `task` — an individual work item
-
-## Status Flow
-`draft` → `pending_review` → `approved` → `in_progress` → `done`
-
-Also: `blocked`, `cancelled`
-
-## Description Field
-`--description` accepts a file path or an inline string:
-- `--description spec.md` — reads file, sends raw content
-- `--description "Do the thing"` — sends string as-is
-
-## Workflow Example
+## Validation Rules
 
-```bash
-# One-time setup
-flowy setup --mode saas --email you@example.com
-flowy client set name "Acme Corp"
-
-# Create and activate project
-flowy project create "Auth System"
-flowy project set "Auth System"
+- **Title is required** and cannot be empty
+- **Description** is optional, but if provided cannot be empty
+- **--description** accepts a file path (reads content) or an inline string
+- **Search** requires at least 3 characters
+- **Status** must be one of: draft, pending_review, approved, in_progress, done, blocked, cancelled
+- **Blocking**: a task cannot block itself
+- **Edges**: both source and target nodes must exist
 
-# Plan a feature
-flowy feature create --title "SSO Support" --description sso-spec.md
-flowy feature set "SSO Support"
+## Output Format
 
-# Break into tasks
-flowy task create --title "Implement OAuth" --description oauth.md
-flowy task create --title "Write auth tests" --description tests.md
+All commands output JSON to stdout. Errors go to stderr as `{ "error": "message" }`.
 
-# Track progress
-flowy status <task-id> in_progress
-flowy status <task-id> done
+## Environment Variables
 
-# Move to next feature
-flowy feature create --title "API Rate Limiting" --description rate-limit.md
-flowy feature set "API Rate Limiting"
-```
-
-## Output Format
-All commands output JSON. Parse with `jq` or directly in your agent code.
+| Variable | Description |
+|----------|-------------|
+| `FLOWY_PROJECT` | Override active project by name |
+| `FLOWY_FEATURE` | Override active feature by ID |
+| `FLOWY_API_URL` | GraphQL endpoint |
+| `FLOWY_API_KEY` | API key (from setup) |

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

@@ -88,13 +88,47 @@ describe('setup command', () => {
     )
   })
 
-  test('setup remote prints not-yet-implemented message', async () => {
+  test('setup remote requires --email', async () => {
     const { setupCommand } = await import('./setup.ts')
     await setupCommand.parseAsync(['remote'], { from: 'user' })
 
+    expect(mockOutputError).toHaveBeenCalledWith(
+      expect.objectContaining({
+        message: expect.stringContaining('--email is required'),
+      }),
+    )
+  })
+
+  test('setup remote registers, saves API key, and outputs result', async () => {
+    const mockGraphql = vi.fn().mockResolvedValue({
+      register: {
+        user: { id: 'user_1', email: 'test@example.com', tier: 'free' },
+        apiKey: 'flowy_test_key_123',
+      },
+    })
+    vi.doMock('../util/client.ts', () => ({
+      graphql: mockGraphql,
+    }))
+    mockSpawnSync.mockReturnValue({
+      status: 0,
+      stdout: Buffer.from(''),
+    })
+
+    const { setupCommand } = await import('./setup.ts')
+    await setupCommand.parseAsync(['remote', '--email', 'test@example.com'], {
+      from: 'user',
+    })
+
+    expect(mockSaveConfig).toHaveBeenCalledWith(
+      expect.objectContaining({
+        mode: 'remote',
+        apiKey: 'flowy_test_key_123',
+      }),
+    )
     expect(mockOutput).toHaveBeenCalledWith(
       expect.objectContaining({
-        message: expect.stringContaining('not yet implemented'),
+        user: expect.objectContaining({ email: 'test@example.com' }),
+        apiKey: 'flowy_test_key_123',
       }),
     )
   })

package/src/commands/setup.ts

@@ -70,13 +70,39 @@ setupCommand
 
 setupCommand
   .command('remote')
-  .description('Set up Flowy with the remote SaaS server')
-  .action(async () => {
+  .description('Connect to the hosted Flowy service')
+  .option('--email <email>', 'Email address for registration')
+  .action(async (opts) => {
     try {
-      output({
-        message:
-          'Remote mode is not yet implemented. It will support registration and API key setup via this CLI.',
+      if (!opts.email) {
+        throw new Error('--email is required for registration')
+      }
+
+      const { graphql } = await import('../util/client.ts')
+
+      const config = loadConfig()
+      config.mode = 'remote'
+      config.apiUrl = 'https://flowy-ai.fly.dev/graphql'
+      saveConfig(config)
+
+      const data = await graphql(
+        `mutation Register($email: String!) {
+          register(email: $email) {
+            user { id email tier }
+            apiKey
+          }
+        }`,
+        { email: opts.email },
+      )
+
+      config.apiKey = data.register.apiKey
+      saveConfig(config)
+
+      spawnSync('npx', ['skills', 'add', 'sqaoss/flowy', '--yes'], {
+        stdio: 'inherit',
       })
+
+      output(data.register)
     } catch (error) {
       outputError(error)
     }

package/src/index.ts

@@ -3,6 +3,7 @@ import { Command } from 'commander'
 import { approveCommand } from './commands/approve.ts'
 import { clientCommand } from './commands/client.ts'
 import { featureCommand } from './commands/feature.ts'
+import { initCommand } from './commands/init.ts'
 import { projectCommand } from './commands/project.ts'
 import { searchCommand } from './commands/search.ts'
 import { setupCommand } from './commands/setup.ts'
@@ -16,6 +17,7 @@ const program = new Command()
   .description('Project management for AI coding agents')
   .version('0.2.0')
 
+program.addCommand(initCommand)
 program.addCommand(setupCommand)
 program.addCommand(clientCommand)
 program.addCommand(projectCommand)