@latentforce/shift 1.0.1 → 1.0.3

package/README.md

@@ -1,103 +1,171 @@
-# shift-mcp
+# @latentforce/shift
 
-A minimal utility server built for the Model Context Protocol (MCP). It exposes tools that call the Shift Lite webapp backend for file summary, dependencies, and blast radius (using the project's knowledge graph).
+A CLI and MCP server for AI-powered code intelligence. It provides:
 
-## Environment variables
+1. **CLI commands** - Index and manage your project
+2. **MCP server** - Expose tools (blast_radius, dependencies, file_summary) to Claude Desktop/Code
 
-- **`SHIFT_PROJECT_ID`** (optional if you pass per call): The default Shift Lite project UUID. If set, all tools use this project unless overridden by the `project_id` parameter in a tool call.
-  - Example: `export SHIFT_PROJECT_ID=9af16a19-d073-4134-a0cd-272b0baf912e`
-- **`SHIFT_BACKEND_URL`** (optional): Webapp backend base URL. Default: `http://127.0.0.1:9000`.
+## Installation
 
-## Project ID: env vs per-call
+```bash
+npm install -g @latentforce/shift
+```
 
-- **Default:** Set `SHIFT_PROJECT_ID` in the MCP config (or env). All tools use that project.
-- **Override per call:** Each tool (`blast_radius`, `dependencies`, `file_summary`) accepts an optional **`project_id`** parameter. If you pass it, that call uses that project; otherwise the tool uses `SHIFT_PROJECT_ID`. So you can use one MCP for multiple projects by passing `project_id` in the call (e.g. "blast radius for project abc-123").
+## Quick Start
 
-## Installation
+### Step 1: Configure backend URLs (if using hosted service)
 
-### Option 1: Install globally (simple, persistent)
+If you're connecting to a hosted Shift backend (not localhost), configure the URLs first:
 
 ```bash
-npm install -g @latentforce/shift
+shift config set api-url https://api.latentforce.ai
+shift config set orch-url https://orch.latentforce.ai
+shift config set ws-url wss://ws.latentforce.ai
 ```
 
-Verify it works:
+### Step 2: Start and configure your project
+
 ```bash
-shift
+cd /path/to/your/project
+shift start
 ```
 
-You should see:
+This will:
+- Prompt for your Shift API key or let you continue as guest
+- Let you select or enter your project ID
+- Start a background daemon that connects to the backend
+
+### Step 3: Index your project
+
 ```bash
-Shift-lite MCP Server running on stdio
+shift init
 ```
 
+This scans your project files and sends the structure to the backend for indexing.
 
-## Claude Code setup
+### Step 4: Configure MCP for Claude
 
-Claude Code does not auto-discover MCP servers. You must register it manually.
+Now Claude can use the MCP tools. See [Claude Desktop setup](#claude-desktop-setup) or [Claude Code setup](#claude-code-setup) below.
 
-### Install the Package (if not already)
-You can use this package without installing it globally by using npx, or install it globally for faster access.
+## CLI Commands
 
-```bash
-npm install -g @latentforce/shift
-```
+| Command | Description |
+|---------|-------------|
+| `shift start` | Start the daemon and configure the project |
+| `shift init` | Scan and index project files to backend |
+| `shift stop` | Stop the running daemon |
+| `shift status` | Show current status (API key, project, daemon, connection) |
+| `shift config` | Show/set configuration (URLs, API key) |
+| `shift` or `shift mcp` | Start MCP server on stdio (used by Claude) |
 
-### Add to Claude Code
-- Replace SHIFT_BACKEND_URL and SHIFT_PROJECT_ID with correct values.
-- SHIFT_PROJECT_ID may be ignored as every tool accepts an optional **`project_id`** parameter.
-For Windows Users
-```bash
-claude mcp add --scope user --transport stdio --env SHIFT_BACKEND_URL=BACKEND_URL --env SHIFT_PROJECT_ID=9af16a19-d073-4134-a0cd-272b0baf912e shift -- cmd /c npx -y @latentforce/shift
-```
+## Authentication
 
-For macOS/Linux Users
-```bash
-claude mcp add --scope user --transport stdio --env SHIFT_BACKEND_URL=BACKEND_URL --env SHIFT_PROJECT_ID=9af16a19-d073-4134-a0cd-272b0baf912e shift -- npx -y @latentforce/shift
-```
+When running `shift start` or `shift init`, you'll be prompted to choose:
 
-### Verify Installation
-```bash
-claude mcp list
-```
+1. **API Key** - Enter your Shift API key for full access
+2. **Guest Mode** - Continue without an API key (limited features)
+
+Both options work with all CLI commands. Your choice is saved to `~/.shift/config.json`.
+
+## MCP Tools
+
+The MCP server exposes these tools to Claude:
+
+| Tool | Description |
+|------|-------------|
+| `blast_radius` | Analyze what would be affected if a file is modified |
+| `dependencies` | Get all dependencies for a file (direct and transitive) |
+| `file_summary` | Generate a summary of a file with optional parent context |
+
+## Configuration
+
+### Using the Config Command (Recommended for Global Install)
+
+The easiest way to configure Shift after installing globally with `npm i -g @latentforce/shift`:
 
-### Use It
-Start a Claude Code session:
 ```bash
-claude
+# Show current configuration
+shift config
+
+# Set backend URLs
+shift config set api-url https://api.latentforce.ai
+shift config set orch-url https://orch.latentforce.ai
+shift config set ws-url wss://ws.latentforce.ai
+
+# Set API key directly (alternative to interactive prompt)
+shift config set api-key your-api-key-here
+
+# Clear configuration
+shift config clear urls    # Reset URLs to defaults
+shift config clear         # Clear all config (prompts for confirmation)
 ```
 
-## Claude Desktop setup
+Configuration is saved to `~/.shift/config.json`.
+
+### Using Environment Variables
+
+You can also set environment variables (they take priority over config file):
 
-Claude Desktop does not auto-discover MCP servers. You must register it manually.
+| Variable | Description | Default |
+|----------|-------------|---------|
+| `SHIFT_PROJECT_ID` | Default project UUID (MCP only) | - |
+| `SHIFT_BACKEND_URL` | Backend API URL (MCP only) | `http://127.0.0.1:9000` |
 
-### Config file location
+Example using environment variables:
 
-**macOS (Claude Desktop app):**
 ```bash
-~/Library/Application Support/Claude/claude_desktop_config.json
+# Set for current session
+export SHIFT_API_URL=https://api.latentforce.ai
+export SHIFT_ORCH_URL=https://orch.latentforce.ai
+export SHIFT_WS_URL=wss://ws.latentforce.ai
+
+# Or inline when running commands
+SHIFT_API_URL=https://api.latentforce.ai shift start
 ```
-*(In Claude Desktop: Claude menu → Settings… → Developer → Edit Config)*
 
-**Linux (if different):**
+### Priority Order
+
+URLs are resolved in this order:
+1. Environment variables (highest priority)
+2. Config file (`~/.shift/config.json`)
+3. Defaults (localhost)
+
+## Claude Code Setup
+
+### Add MCP Server
+
 ```bash
-~/.config/claude-desktop/claude_desktop_config.json
+claude mcp add-json shift '{"type":"stdio","command":"shift","args":[],"env":{"SHIFT_PROJECT_ID":"YOUR_PROJECT_ID_HERE","SHIFT_BACKEND_URL":"https://dev-shift-lite.latentforce.ai"}}'
 ```
 
-**Windows:**
+### Verify
+
 ```bash
-%APPDATA%\Claude\claude_desktop_config.json
+claude mcp list
 ```
 
-Add this (replace `YOUR_PROJECT_UUID` with your Shift Lite project ID):
+## Claude Desktop Setup
+
+### Config File Location
+
+| OS | Path |
+|----|------|
+| macOS | `~/Library/Application Support/Claude/claude_desktop_config.json` |
+| Linux | `~/.config/claude-desktop/claude_desktop_config.json` |
+| Windows | `%APPDATA%\Claude\claude_desktop_config.json` |
+
+### Configuration
+
+Add to your config file:
+
 ```json
 {
   "mcpServers": {
     "shift": {
       "command": "shift",
       "env": {
-        "SHIFT_BACKEND_URL": "BACKEND URL",
-        "SHIFT_PROJECT_ID": "YOUR_PROJECT_UUID"
+        "SHIFT_BACKEND_URL": "https://dev-shift-lite.latentforce.ai",
+        "SHIFT_PROJECT_ID": "YOUR_PROJECT_ID_HERE"
       }
     }
   }
@@ -106,16 +174,55 @@ Add this (replace `YOUR_PROJECT_UUID` with your Shift Lite project ID):
 
 Restart Claude Desktop after saving.
 
+## Project ID
+
+You can set the project ID in two ways:
+
+1. **Environment variable**: Set `SHIFT_PROJECT_ID` in MCP config
+2. **Per-call override**: Pass `project_id` parameter in each tool call
+
+This allows one MCP server to work with multiple projects.
+
 ## Development
 
-Clone and build:
 ```bash
+# Clone and install
 npm install
+
+# Build
 npm run build
-```
 
-Run locally:
-```bash
+# Run locally
 node build/index.js
+
+# Test CLI commands
+node build/index.js start
+node build/index.js init
+node build/index.js status
+node build/index.js stop
 ```
 
+## How It All Works Together
+
+```
+┌─────────────────────────────────────────────────────────────────┐
+│                        User's Machine                           │
+│                                                                 │
+│  ┌─────────────┐     ┌─────────────┐     ┌─────────────────┐   │
+│  │ shift start │────▶│   Daemon    │────▶│ Backend (WS)    │   │
+│  │ shift init  │     │ (background)│     │                 │   │
+│  │ shift stop  │     └─────────────┘     │                 │   │
+│  │ shift status│                         │                 │   │
+│  └─────────────┘                         │   Shift Lite    │   │
+│                                          │   Backend       │   │
+│  ┌─────────────┐     ┌─────────────┐     │                 │   │
+│  │   Claude    │────▶│ shift (MCP) │────▶│ (REST API)      │   │
+│  │ Desktop/Code│     │   Server    │     │                 │   │
+│  └─────────────┘     └─────────────┘     └─────────────────┘   │
+│                                                                 │
+└─────────────────────────────────────────────────────────────────┘
+
+1. `shift start` - Starts daemon, connects to backend via WebSocket
+2. `shift init`  - Indexes project files to backend
+3. Claude calls MCP tools - MCP server queries backend REST API
+```

package/build/cli/commands/config.js

@@ -0,0 +1,136 @@
+import { readGlobalConfig, setApiKey, setApiUrl, setOrchUrl, setWsUrl, clearUrls, clearApiKey, getConfiguredUrls, isGuestKey, } from '../../utils/config.js';
+import { prompt } from '../../utils/prompts.js';
+export async function configCommand(action, key, value) {
+    const parsedAction = (action || 'show');
+    switch (parsedAction) {
+        case 'show':
+            showConfig();
+            break;
+        case 'set':
+            await setConfigValue(key, value);
+            break;
+        case 'clear':
+            await clearConfig(key);
+            break;
+        default:
+            console.log('Usage: shift config [show|set|clear] [key] [value]');
+            console.log('');
+            console.log('Commands:');
+            console.log('  show                    Show current configuration');
+            console.log('  set <key> <value>       Set a configuration value');
+            console.log('  clear [key]             Clear configuration (all or specific key)');
+            console.log('');
+            console.log('Keys:');
+            console.log('  api-key                 Your Shift API key');
+            console.log('  api-url                 SHIFT_API_URL (default: http://localhost:9000)');
+            console.log('  orch-url                SHIFT_ORCH_URL (default: http://localhost:9999)');
+            console.log('  ws-url                  SHIFT_WS_URL (default: ws://localhost:9999)');
+            console.log('');
+            console.log('Examples:');
+            console.log('  shift config');
+            console.log('  shift config set api-url https://api.latentforce.ai');
+            console.log('  shift config set orch-url https://orch.latentforce.ai');
+            console.log('  shift config set ws-url wss://ws.latentforce.ai');
+            console.log('  shift config clear urls');
+            break;
+    }
+}
+function showConfig() {
+    console.log('╔════════════════════════════════════════════╗');
+    console.log('║         Shift Configuration                ║');
+    console.log('╚════════════════════════════════════════════╝\n');
+    const globalConfig = readGlobalConfig();
+    const urls = getConfiguredUrls();
+    // API Key
+    console.log('API Key:');
+    if (globalConfig?.api_key) {
+        const keyType = isGuestKey() ? '(guest)' : '(paid)';
+        const maskedKey = globalConfig.api_key.substring(0, 8) + '...' + globalConfig.api_key.slice(-4);
+        console.log(`  ${maskedKey} ${keyType}`);
+    }
+    else {
+        console.log('  Not configured');
+    }
+    console.log('');
+    // URLs
+    console.log('URLs:');
+    console.log(`  API URL:  ${urls.api_url}`);
+    console.log(`  Orch URL: ${urls.orch_url}`);
+    console.log(`  WS URL:   ${urls.ws_url}`);
+    console.log('');
+    // Source info
+    console.log('Config file: ~/.shift/config.json');
+    console.log('');
+    console.log('Tip: URLs can also be set via environment variables:');
+    console.log('  SHIFT_API_URL, SHIFT_ORCH_URL, SHIFT_WS_URL');
+}
+async function setConfigValue(key, value) {
+    if (!key) {
+        console.error('Error: Key is required. Run "shift config" to see available keys.');
+        process.exit(1);
+    }
+    // If no value provided, prompt for it
+    if (!value) {
+        value = await prompt(`Enter value for ${key}: `);
+        if (!value) {
+            console.error('Error: Value is required.');
+            process.exit(1);
+        }
+    }
+    switch (key) {
+        case 'api-key':
+            setApiKey(value);
+            console.log('✓ API key saved');
+            break;
+        case 'api-url':
+            setApiUrl(value);
+            console.log(`✓ API URL set to: ${value}`);
+            break;
+        case 'orch-url':
+            setOrchUrl(value);
+            console.log(`✓ Orch URL set to: ${value}`);
+            break;
+        case 'ws-url':
+            setWsUrl(value);
+            console.log(`✓ WS URL set to: ${value}`);
+            break;
+        default:
+            console.error(`Unknown key: ${key}`);
+            console.log('Available keys: api-key, api-url, orch-url, ws-url');
+            process.exit(1);
+    }
+    console.log('\nNote: Restart any running daemon for URL changes to take effect.');
+}
+async function clearConfig(key) {
+    if (!key) {
+        // Clear everything
+        const answer = await prompt('Clear all configuration? (y/N): ');
+        if (answer.toLowerCase() !== 'y') {
+            console.log('Cancelled.');
+            return;
+        }
+        clearApiKey();
+        clearUrls();
+        console.log('✓ All configuration cleared');
+        return;
+    }
+    switch (key) {
+        case 'api-key':
+            clearApiKey();
+            console.log('✓ API key cleared');
+            break;
+        case 'urls':
+            clearUrls();
+            console.log('✓ URLs cleared (will use defaults)');
+            break;
+        case 'api-url':
+        case 'orch-url':
+        case 'ws-url':
+            console.log('Use "shift config clear urls" to clear all URLs');
+            break;
+        default:
+            console.error(`Unknown key: ${key}`);
+            console.log('Available keys: api-key, urls');
+            process.exit(1);
+    }
+}

package/build/cli/commands/init.js

@@ -0,0 +1,156 @@
+import { exec } from 'child_process';
+import { promisify } from 'util';
+import { getApiKey, setApiKey, setGuestKey, isGuestKey, readProjectConfig, writeProjectConfig } from '../../utils/config.js';
+import { promptApiKey, promptKeyChoice } from '../../utils/prompts.js';
+import { requestGuestKey } from '../../utils/api-client.js';
+import { getDaemonStatus } from '../../daemon/daemon-manager.js';
+import { getProjectTree, extractAllFilePaths, categorizeFiles } from '../../utils/tree-scanner.js';
+import { sendInitScan } from '../../utils/api-client.js';
+const execAsync = promisify(exec);
+export async function initCommand() {
+    const projectRoot = process.cwd();
+    console.log('╔═══════════════════════════════════════════════╗');
+    console.log('║         Initializing Shift Project            ║');
+    console.log('╚═══════════════════════════════════════════════╝\n');
+    // Step 1: Check API key (with guest flow support)
+    console.log('[Init] Step 1/5: Checking API key...');
+    let apiKey = getApiKey();
+    if (!apiKey) {
+        const choice = await promptKeyChoice();
+        if (choice === 'paid') {
+            apiKey = await promptApiKey();
+            setApiKey(apiKey);
+            console.log('[Init] ✓ API key saved to ~/.shift/config.json\n');
+        }
+        else {
+            console.log('\n[Init] Requesting guest session...');
+            try {
+                const guestResponse = await requestGuestKey();
+                setGuestKey(guestResponse.api_key);
+                apiKey = guestResponse.api_key;
+                console.log('[Init] ✓ Guest session started\n');
+            }
+            catch (error) {
+                console.error(`\n❌ Failed to get guest key: ${error.message}`);
+                process.exit(1);
+            }
+        }
+    }
+    else if (isGuestKey()) {
+        console.log('[Init] ✓ Guest key found\n');
+    }
+    else {
+        console.log('[Init] ✓ API key found\n');
+    }
+    // Step 2: Check project config
+    console.log('[Init] Step 2/5: Checking project configuration...');
+    const projectConfig = readProjectConfig(projectRoot);
+    if (!projectConfig) {
+        console.error('\n❌ No project configured for this directory.');
+        console.log('Run "shift start" first to configure the project.\n');
+        process.exit(1);
+    }
+    console.log(`[Init] ✓ Project: ${projectConfig.project_name} (${projectConfig.project_id})\n`);
+    // Step 3: Check daemon status (warn if not running)
+    console.log('[Init] Step 3/5: Checking daemon status...');
+    const status = getDaemonStatus(projectRoot);
+    if (!status.running) {
+        console.log('[Init] ⚠️  Warning: Daemon is not running. Run "shift start" to start it.\n');
+    }
+    else {
+        console.log(`[Init] ✓ Daemon running (PID: ${status.pid}, Connected: ${status.connected})\n`);
+    }
+    // Step 4: Scan project structure (matching extension's Step 6)
+    console.log('[Init] Step 4/5: Scanning project structure...');
+    // Get project tree (matching extension's getProjectTree)
+    const treeData = getProjectTree(projectRoot, {
+        depth: 0, // Unlimited depth
+        exclude_patterns: [
+            '.git',
+            'node_modules',
+            '__pycache__',
+            '.vscode',
+            'dist',
+            'build',
+            '.shift',
+            '.next',
+            'coverage',
+            'venv',
+            'env',
+        ],
+    });
+    console.log(`[Init]   Files: ${treeData.file_count}`);
+    console.log(`[Init]   Directories: ${treeData.dir_count}`);
+    console.log(`[Init]   Total size: ${treeData.total_size_mb} MB\n`);
+    // Get git info (matching extension)
+    let gitInfo = {
+        current_branch: '',
+        original_branch: 'shift_original',
+        migrate_branch: 'shift_migrated',
+        has_uncommitted_changes: false,
+    };
+    try {
+        const { stdout: currentBranch } = await execAsync('git branch --show-current', { cwd: projectRoot });
+        const { stdout: statusOutput } = await execAsync('git status --porcelain', { cwd: projectRoot });
+        gitInfo.current_branch = currentBranch.trim();
+        gitInfo.has_uncommitted_changes = statusOutput.trim().length > 0;
+        console.log(`[Init] ✓ Git info: branch=${gitInfo.current_branch}, uncommitted=${gitInfo.has_uncommitted_changes}\n`);
+    }
+    catch {
+        console.log('[Init] ⚠️  Not a git repository or git not available\n');
+    }
+    // Extract file paths and categorize (matching extension)
+    const allFiles = extractAllFilePaths(treeData.tree);
+    const categorized = categorizeFiles(treeData.tree);
+    console.log(`[Init]   Source files: ${categorized.source_files.length}`);
+    console.log(`[Init]   Config files: ${categorized.config_files.length}`);
+    console.log(`[Init]   Asset files: ${categorized.asset_files.length}\n`);
+    // Step 5: Send scan to backend (matching extension's Step 9)
+    console.log('[Init] Step 5/5: Sending scan to backend...');
+    const payload = {
+        project_id: projectConfig.project_id,
+        project_tree: treeData,
+        git_info: gitInfo,
+        file_manifest: {
+            all_files: allFiles,
+            categorized: categorized,
+        },
+        metadata: {
+            extension_version: '1.0.2-cli', // CLI version
+            scan_timestamp: new Date().toISOString(),
+            project_name: projectConfig.project_name,
+        },
+    };
+    try {
+        const response = await sendInitScan(apiKey, projectConfig.project_id, payload);
+        console.log('[Init] ✓ Backend initialization completed');
+        console.log(`[Init]   Files read: ${response.files_read}`);
+        console.log(`[Init]   Files failed: ${response.files_failed}`);
+        // Update local config with agent info (matching extension)
+        if (response.agents_created?.theme_planner) {
+            const agentInfo = {
+                agent_id: response.agents_created.theme_planner.agent_id,
+                agent_name: response.agents_created.theme_planner.agent_name,
+                agent_type: 'theme_planner',
+                created_at: new Date().toISOString(),
+            };
+            projectConfig.agents = projectConfig.agents || [];
+            projectConfig.agents.push(agentInfo);
+            writeProjectConfig(projectConfig, projectRoot);
+            console.log(`[Init] ✓ Agent info saved: ${agentInfo.agent_id}`);
+        }
+        console.log('\n╔═══════════════════════════════════════════════╗');
+        console.log('║       ✓ Project Initialization Complete       ║');
+        console.log('╚═══════════════════════════════════════════════╝');
+        if (response.next_steps) {
+            console.log('\nNext steps:');
+            response.next_steps.forEach((step) => console.log(`  - ${step}`));
+        }
+        console.log('\nFile indexing has been triggered. This may take a few moments.');
+        console.log('Use "shift status" to check the daemon connection.\n');
+    }
+    catch (error) {
+        console.error(`\n❌ Failed to initialize project: ${error.message}`);
+        process.exit(1);
+    }
+}

package/build/cli/commands/start.js

@@ -0,0 +1,100 @@
+import { getApiKey, setApiKey, setGuestKey, isGuestKey, setProject, readProjectConfig } from '../../utils/config.js';
+import { promptApiKey, promptProjectId, promptSelectProject, promptKeyChoice } from '../../utils/prompts.js';
+import { startDaemon, getDaemonStatus } from '../../daemon/daemon-manager.js';
+import { fetchProjects, requestGuestKey } from '../../utils/api-client.js';
+export async function startCommand() {
+    const projectRoot = process.cwd();
+    console.log('╔════════════════════════════════════════════╗');
+    console.log('║         Starting Shift                     ║');
+    console.log('╚════════════════════════════════════════════╝\n');
+    // Step 1: Ensure API key exists
+    console.log('[Start] Step 1/4: Checking API key...');
+    let apiKey = getApiKey();
+    if (!apiKey) {
+        const choice = await promptKeyChoice();
+        if (choice === 'paid') {
+            apiKey = await promptApiKey();
+            setApiKey(apiKey);
+            console.log('[Start] ✓ API key saved to ~/.shift/config.json\n');
+        }
+        else {
+            console.log('\n[Start] Requesting guest session...');
+            try {
+                const guestResponse = await requestGuestKey();
+                setGuestKey(guestResponse.api_key);
+                apiKey = guestResponse.api_key;
+                console.log('[Start] ✓ Guest session started\n');
+            }
+            catch (error) {
+                console.error(`\n❌ Failed to get guest key: ${error.message}`);
+                process.exit(1);
+            }
+        }
+    }
+    else if (isGuestKey()) {
+        console.log('[Start] ✓ Guest key found\n');
+    }
+    else {
+        console.log('[Start] ✓ API key found\n');
+    }
+    // Step 2: Check/create project config
+    console.log('[Start] Step 2/4: Checking project configuration...');
+    let projectConfig = readProjectConfig(projectRoot);
+    if (!projectConfig) {
+        // Fetch available projects
+        console.log('[Start] Fetching your projects...');
+        try {
+            const projects = await fetchProjects(apiKey);
+            if (!projects || projects.length === 0) {
+                console.error('\n❌ No projects found. Create one in the Shift dashboard first.');
+                process.exit(1);
+            }
+            console.log(`[Start] Found ${projects.length} project(s)\n`);
+            // Let user select a project
+            const selected = await promptSelectProject(projects);
+            // Save project config (matching extension's .shift/config.json structure)
+            setProject(selected.project_id, selected.project_name, projectRoot);
+            console.log(`[Start] ✓ Project "${selected.project_name}" saved to .shift/config.json\n`);
+            projectConfig = readProjectConfig(projectRoot);
+        }
+        catch (error) {
+            // If fetching fails, fall back to manual entry
+            console.error(`\n⚠️  Could not fetch projects: ${error.message}`);
+            console.log('Falling back to manual project ID entry...\n');
+            const projectId = await promptProjectId();
+            setProject(projectId, 'Unknown Project', projectRoot);
+            console.log(`[Start] ✓ Project ID saved to .shift/config.json\n`);
+            projectConfig = readProjectConfig(projectRoot);
+        }
+    }
+    else {
+        console.log(`[Start] ✓ Project found: ${projectConfig.project_name} (${projectConfig.project_id})\n`);
+    }
+    if (!projectConfig) {
+        console.error('❌ Failed to configure project');
+        process.exit(1);
+    }
+    // Step 3: Check if daemon is already running
+    console.log('[Start] Step 3/4: Checking daemon status...');
+    const status = getDaemonStatus(projectRoot);
+    if (status.running) {
+        console.log(`[Start] ✓ Daemon is already running (PID: ${status.pid})`);
+        console.log(`[Start]   WebSocket: ${status.connected ? 'Connected' : 'Connecting...'}\n`);
+        return;
+    }
+    console.log('[Start] Daemon not running\n');
+    // Step 4: Start daemon
+    console.log('[Start] Step 4/4: Starting daemon...');
+    const result = await startDaemon(projectRoot, projectConfig.project_id, apiKey);
+    if (!result.success) {
+        console.error(`\n❌ Failed to start daemon: ${result.error}`);
+        process.exit(1);
+    }
+    console.log(`[Start] ✓ Daemon started (PID: ${result.pid})`);
+    console.log('\n╔════════════════════════════════════════════╗');
+    console.log('║         Shift is now running!              ║');
+    console.log('╚════════════════════════════════════════════╝');
+    console.log('\nUse "shift status" to check connection status.');
+    console.log('Use "shift init" to scan and index the project.');
+    console.log('Use "shift stop" to stop the daemon.\n');
+}