@latentforce/shift 1.0.8 → 1.0.10

package/README.md

@@ -2,35 +2,57 @@
 
 AI-powered code intelligence CLI and MCP server for Claude.
 
+Shift indexes your codebase, builds a dependency relationship graph (DRG), and provides AI-powered insights via MCP tools — enabling Claude to understand your project's structure, dependencies, and blast radius of changes.
+
 ## Installation
 
 ```bash
 npm install -g @latentforce/shift
 ```
 
+Requires Node.js >= 18.
+
 ## Quick Start
 
-### 1. Initialize your project
+### Guest mode (zero-config)
 
 ```bash
 cd /path/to/your/project
-shift-cli start    # Configure API key and project
+shift-cli init --guest        # Auto-creates guest key + project, scans, and indexes
+```
+
+### With an API key
+
+```bash
+# Create a new project and index it (prompts for template selection)
+shift-cli init --api-key YOUR_KEY --project-name "My App"
+
+# Fully non-interactive (CI/CD friendly)
+shift-cli init --api-key YOUR_KEY --project-name "My App" --template TEMPLATE_ID
+```
+
+### Interactive (original behavior)
+
+```bash
+shift-cli start    # Configure API key and project interactively
 shift-cli init     # Index project files
 ```
 
-### 2. Add to Claude Code
+## MCP Integration
+
+### Add to Claude Code
 
 ```bash
 claude mcp add-json shift '{"type":"stdio","command":"shift-cli","args":["mcp"],"env":{"SHIFT_PROJECT_ID":"YOUR_PROJECT_ID"}}'
 ```
 
-Or using npx:
+Or using npx (no global install needed):
 
 ```bash
 claude mcp add-json shift '{"type":"stdio","command":"npx","args":["@latentforce/shift","mcp"],"env":{"SHIFT_PROJECT_ID":"YOUR_PROJECT_ID"}}'
 ```
 
-### 3. Add to Claude Desktop
+### Add to Claude Desktop
 
 Add to your config file (`%APPDATA%\Claude\claude_desktop_config.json` on Windows, `~/Library/Application Support/Claude/claude_desktop_config.json` on macOS):
 
@@ -48,39 +70,189 @@ Add to your config file (`%APPDATA%\Claude\claude_desktop_config.json` on Window
 }
 ```
 
-## MCP Tools
-
-| Tool | Description |
-|------|-------------|
-| `blast_radius` | Analyze what would be affected if a file is modified |
-| `dependencies` | Get all dependencies for a file |
-| `file_summary` | Generate a summary of a file |
-
 ## CLI Commands
 
 | Command | Description |
 |---------|-------------|
-| `shift-cli start` | Start daemon and configure project |
-| `shift-cli init` | Index project files |
+| `shift-cli start` | Start the daemon and configure the project |
+| `shift-cli init` | Scan and index project files |
+| `shift-cli update-drg` | Update the dependency relationship graph |
 | `shift-cli stop` | Stop the daemon |
 | `shift-cli status` | Show current status |
 | `shift-cli config` | Manage configuration |
 
-## Custom Backend URLs
+### `shift-cli init`
+
+Performs a full project scan — collects the file tree, categorizes files (source, config, assets), gathers git info, and sends everything to the Shift backend for indexing. Automatically starts the daemon if not running and creates a default `.shiftignore` if one doesn't exist.
 
-**CLI** (set once globally):
+If the project is already indexed, you will be prompted to re-index. Use `--force` to skip the prompt.
+
+| Flag | Description |
+|------|-------------|
+| `--guest` | Use guest authentication (auto-creates a temporary project) |
+| `--api-key <key>` | Provide API key directly |
+| `--project-name <name>` | Create new project or match existing by name |
+| `--project-id <id>` | Use existing project UUID |
+| `--template <id>` | Migration template ID for project creation |
+| `-f, --force` | Force re-indexing even if already indexed |
+| `--no-ignore` | Skip `.shiftignore` rules for this run (send all files) |
 
 ```bash
-shift-cli config set api-url https://your-api.example.com
-shift-cli config set orch-url https://your-orch.example.com
-shift-cli config set ws-url wss://your-orch.example.com
+shift-cli init                     # Interactive initialization
+shift-cli init --force             # Force re-index without prompt
+shift-cli init --no-ignore         # Index all files, skip .shiftignore
+shift-cli init --guest             # Quick init with guest auth
 ```
 
-**MCP Server** (add to env in Claude config):
+### `shift-cli start`
 
-```json
-"env": {
-  "SHIFT_PROJECT_ID": "YOUR_PROJECT_ID",
-  "SHIFT_BACKEND_URL": "https://your-api.example.com"
-}
+Resolves authentication, configures the project, and launches a background daemon that maintains a WebSocket connection to the Shift backend. Creates a default `.shiftignore` if one doesn't exist.
+
+| Flag | Description |
+|------|-------------|
+| `--guest` | Use guest authentication (auto-creates a temporary project) |
+| `--api-key <key>` | Provide API key directly |
+| `--project-name <name>` | Create new project or match existing by name |
+| `--project-id <id>` | Use existing project UUID |
+| `--template <id>` | Migration template ID for project creation |
+
+```bash
+shift-cli start                                     # Interactive setup
+shift-cli start --guest                              # Quick start without API key
+shift-cli start --api-key <key> --project-name "My App"
+```
+
+### `shift-cli update-drg`
+
+Scans JavaScript/TypeScript files (`.js`, `.jsx`, `.ts`, `.tsx`, `.mjs`, `.cjs`), detects git changes, and sends file contents to the backend for dependency analysis. Respects `.shiftignore` rules.
+
+| Flag | Description |
+|------|-------------|
+| `-m, --mode <mode>` | `baseline` (all files) or `incremental` (git-changed only, default) |
+| `--no-ignore` | Skip `.shiftignore` rules for this run (send all files) |
+
+**Modes:**
+- **incremental** (default) — sends only git-changed files for faster updates
+- **baseline** — sends all JS/TS files for a full re-analysis
+
+```bash
+shift-cli update-drg                       # Incremental update (default)
+shift-cli update-drg -m baseline           # Full re-analysis
+shift-cli update-drg --no-ignore           # Include ignored files
+```
+
+### `shift-cli config`
+
+Manage Shift configuration (URLs, API key).
+
+| Action | Description |
+|--------|-------------|
+| `show` | Display current configuration (default) |
+| `set <key> <value>` | Set a configuration value |
+| `clear [key]` | Clear a specific key or all configuration |
+
+**Configurable keys:** `api-key`, `api-url`, `orch-url`, `ws-url`
+
+URLs can also be set via environment variables: `SHIFT_API_URL`, `SHIFT_ORCH_URL`, `SHIFT_WS_URL`.
+
+```bash
+shift-cli config                                      # Show config
+shift-cli config set api-key sk-abc123                 # Set API key
+shift-cli config set api-url https://api.shift.ai      # Set API URL
+shift-cli config clear api-key                         # Clear API key
+shift-cli config clear                                 # Clear all config
+```
+
+## `.shiftignore`
+
+Shift uses a `.shiftignore` file to control which files and directories are excluded from indexing and dependency analysis. It follows the same syntax as `.gitignore`.
+
+A default `.shiftignore` is **automatically created** the first time you run `shift-cli init` or `shift-cli start`. You can edit it to customize which files are excluded.
+
+### Syntax
+
+- Blank lines are ignored
+- Lines starting with `#` are comments
+- Standard glob patterns (`*`, `**`, `?`)
+- Trailing `/` matches directories only
+- Leading `/` anchors to the project root
+- `!` negates a pattern (re-includes a previously ignored path)
+
+### Default `.shiftignore`
+
+The auto-generated file excludes common non-source directories and files:
+
+```gitignore
+# Dependencies
+node_modules/
+vendor/
+bower_components/
+
+# Build output
+dist/
+build/
+out/
+.next/
+
+# Test & coverage
+coverage/
+.nyc_output/
+
+# Environment & secrets
+.env
+.env.*
+*.pem
+*.key
+
+# Logs
+*.log
+logs/
+
+# OS files
+.DS_Store
+Thumbs.db
+
+# IDE
+.vscode/
+.idea/
+*.swp
+*.swo
+
+# Python
+__pycache__/
+*.pyc
+venv/
+.venv/
+
+# Misc
+*.min.js
+*.min.css
+*.map
+```
+
+### Bypassing `.shiftignore`
+
+Use the `--no-ignore` flag to skip `.shiftignore` rules for a single run:
+
+```bash
+shift-cli init --no-ignore         # Index all files
+shift-cli update-drg --no-ignore   # Include ignored files in DRG update
 ```
+
+## MCP Tools
+
+| Tool | Description |
+|------|-------------|
+| `blast_radius` | Analyze what files would be affected if a file is modified or deleted |
+| `dependencies` | Get all dependencies for a file with relationship summaries |
+| `file_summary` | Get a summary of a file with optional parent directory context |
+
+Each tool accepts an optional `project_id` parameter. If not provided, it falls back to the `SHIFT_PROJECT_ID` environment variable.
+
+## Configuration Files
+
+| File | Location | Description |
+|------|----------|-------------|
+| Global config | `~/.shift/config.json` | API key and server URLs |
+| Project config | `.shift/config.json` | Project ID, name, and agent info |
+| Ignore rules | `.shiftignore` | Files/directories to exclude (auto-created) |

package/build/cli/commands/init.js

@@ -1,12 +1,15 @@
 import { exec } from 'child_process';
 import { promisify } from 'util';
 import { createInterface } from 'readline';
-import { getApiKey, setApiKey, setGuestKey, isGuestKey, readProjectConfig, writeProjectConfig } from '../../utils/config.js';
-import { promptApiKey, promptKeyChoice } from '../../utils/prompts.js';
-import { requestGuestKey, fetchProjectStatus } from '../../utils/api-client.js';
-import { getDaemonStatus } from '../../daemon/daemon-manager.js';
+import { createRequire } from 'module';
+import { readProjectConfig, writeProjectConfig } from '../../utils/config.js';
+import { fetchProjectStatus, sendInitScan } from '../../utils/api-client.js';
+import { resolveApiKey, resolveProject } from '../../utils/auth-resolver.js';
+import { getDaemonStatus, startDaemon } from '../../daemon/daemon-manager.js';
 import { getProjectTree, extractAllFilePaths, categorizeFiles } from '../../utils/tree-scanner.js';
-import { sendInitScan } from '../../utils/api-client.js';
+import { loadShiftIgnore, scaffoldShiftIgnore } from '../../utils/shiftignore.js';
+const require = createRequire(import.meta.url);
+const { version } = require('../../../package.json');
 const execAsync = promisify(exec);
 /**
  * Prompt user to confirm re-indexing an already indexed project
@@ -25,64 +28,64 @@ async function promptForReindex() {
 }
 export async function initCommand(options = {}) {
     const projectRoot = process.cwd();
+    const isAuthInteractive = !options.guest && !options.apiKey;
+    const isProjectInteractive = !!(process.stdin.isTTY);
     console.log('╔═══════════════════════════════════════════════╗');
     console.log('║         Initializing Shift Project            ║');
     console.log('╚═══════════════════════════════════════════════╝\n');
-    // Step 1: Check API key (with guest flow support)
+    // Step 1: Resolve API key
     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
+    const authResult = await resolveApiKey({
+        guest: options.guest,
+        apiKey: options.apiKey,
+        interactive: isAuthInteractive,
+        commandLabel: 'Init',
+    });
+    const apiKey = authResult.apiKey;
+    // Step 2: Resolve project
     console.log('[Init] Step 2/5: Checking project configuration...');
+    // If guest flow returned a project_id, save it before resolving
+    if (authResult.projectId && !readProjectConfig(projectRoot)) {
+        const { setProject } = await import('../../utils/config.js');
+        setProject(authResult.projectId, options.projectName || 'Guest Project', projectRoot);
+    }
+    const project = await resolveProject({
+        apiKey,
+        projectId: options.projectId,
+        projectName: options.projectName,
+        template: options.template,
+        interactive: isProjectInteractive,
+        commandLabel: 'Init',
+        projectRoot,
+    });
+    // Re-read project config (may have been written by resolveProject)
     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');
+        console.error('\n❌ Failed to configure project.');
         process.exit(1);
     }
-    console.log(`[Init] ✓ Project: ${projectConfig.project_name} (${projectConfig.project_id})\n`);
     // Check if project is already indexed (skip check if --force flag is used)
     if (!options.force) {
         try {
-            const projectStatus = await fetchProjectStatus(apiKey, projectConfig.project_id);
+            const projectStatus = await fetchProjectStatus(apiKey, project.projectId);
             if (projectStatus.indexed) {
                 console.log(`[Init] ✓ Project already indexed (${projectStatus.file_count} files)\n`);
-                const shouldReindex = await promptForReindex();
-                if (!shouldReindex) {
-                    console.log('\n╔═══════════════════════════════════════════════╗');
-                    console.log('║         Project Already Initialized           ║');
-                    console.log('╚═══════════════════════════════════════════════╝');
-                    console.log('\nUse "shift status" to check the current status.');
-                    console.log('Use "shift init --force" to force re-indexing.\n');
+                if (isProjectInteractive) {
+                    const shouldReindex = await promptForReindex();
+                    if (!shouldReindex) {
+                        console.log('\n╔═══════════════════════════════════════════════╗');
+                        console.log('║         Project Already Initialized           ║');
+                        console.log('╚═══════════════════════════════════════════════╝');
+                        console.log('\nUse "shift-cli status" to check the current status.');
+                        console.log('Use "shift-cli init --force" to force re-indexing.\n');
+                        return;
+                    }
+                    console.log('\n[Init] Proceeding with re-indexing...\n');
+                }
+                else {
+                    console.log('[Init] Already indexed. Use --force to re-index.\n');
                     return;
                 }
-                console.log('\n[Init] Proceeding with re-indexing...\n');
             }
         }
         catch {
@@ -93,17 +96,43 @@ export async function initCommand(options = {}) {
     else {
         console.log('[Init] Force flag detected, skipping indexing status check...\n');
     }
-    // Step 3: Check daemon status (warn if not running)
+    // Step 3: Check daemon status — start it automatically 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');
+    const daemonStatus = getDaemonStatus(projectRoot);
+    if (!daemonStatus.running) {
+        console.log('[Init] Daemon not running. Starting it...');
+        try {
+            const daemonResult = await startDaemon(projectRoot, project.projectId, apiKey);
+            if (daemonResult.success) {
+                console.log(`[Init] ✓ Daemon started (PID: ${daemonResult.pid})\n`);
+            }
+            else {
+                console.log(`[Init] ⚠️  Could not start daemon: ${daemonResult.error}`);
+                console.log('[Init] Continuing without daemon — run "shift-cli start" later.\n');
+            }
+        }
+        catch (err) {
+            console.log(`[Init] ⚠️  Could not start daemon: ${err.message}`);
+            console.log('[Init] Continuing without daemon — run "shift-cli start" later.\n');
+        }
     }
     else {
-        console.log(`[Init] ✓ Daemon running (PID: ${status.pid}, Connected: ${status.connected})\n`);
+        console.log(`[Init] ✓ Daemon running (PID: ${daemonStatus.pid}, Connected: ${daemonStatus.connected})\n`);
     }
     // Step 4: Scan project structure (matching extension's Step 6)
     console.log('[Init] Step 4/5: Scanning project structure...');
+    // Scaffold .shiftignore if it doesn't exist
+    if (scaffoldShiftIgnore(projectRoot)) {
+        console.log('[Init] ✓ Created default .shiftignore (edit it to customize ignored files)\n');
+    }
+    // Load .shiftignore (skip if --no-ignore)
+    const shiftIgnore = options.noIgnore ? null : loadShiftIgnore(projectRoot);
+    if (options.noIgnore) {
+        console.log('[Init] ⚠️  --no-ignore flag set — skipping .shiftignore rules\n');
+    }
+    else if (shiftIgnore) {
+        console.log('[Init] ✓ Applying .shiftignore rules\n');
+    }
     // Get project tree (matching extension's getProjectTree)
     const treeData = getProjectTree(projectRoot, {
         depth: 0, // Unlimited depth
@@ -120,6 +149,7 @@ export async function initCommand(options = {}) {
             'venv',
             'env',
         ],
+        shiftIgnore,
     });
     console.log(`[Init]   Files: ${treeData.file_count}`);
     console.log(`[Init]   Directories: ${treeData.dir_count}`);
@@ -150,7 +180,7 @@ export async function initCommand(options = {}) {
     // 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_id: project.projectId,
         project_tree: treeData,
         git_info: gitInfo,
         file_manifest: {
@@ -158,13 +188,13 @@ export async function initCommand(options = {}) {
             categorized: categorized,
         },
         metadata: {
-            extension_version: '1.0.2-cli', // CLI version
+            extension_version: `${version}-cli`,
             scan_timestamp: new Date().toISOString(),
-            project_name: projectConfig.project_name,
+            project_name: project.projectName,
         },
     };
     try {
-        const response = await sendInitScan(apiKey, projectConfig.project_id, payload);
+        const response = await sendInitScan(apiKey, project.projectId, payload);
         console.log('[Init] ✓ Backend initialization completed');
         console.log(`[Init]   Files read: ${response.files_read}`);
         console.log(`[Init]   Files failed: ${response.files_failed}`);
@@ -181,15 +211,17 @@ export async function initCommand(options = {}) {
             writeProjectConfig(projectConfig, projectRoot);
             console.log(`[Init] ✓ Agent info saved: ${agentInfo.agent_id}`);
         }
+        if (response.files_read === 0 && response.files_failed > 0) {
+            console.log(`\n[Init] ⚠️  No files were read (${response.files_failed} failed).`);
+        }
         console.log('\n╔═══════════════════════════════════════════════╗');
         console.log('║       ✓ Project Initialization Complete       ║');
         console.log('╚═══════════════════════════════════════════════╝');
+        console.log('\nIndexing is running in the background. Use "shift-cli status" to check progress.');
         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}`);

package/build/cli/commands/start.js

@@ -1,79 +1,47 @@
-import { getApiKey, setApiKey, setGuestKey, isGuestKey, setProject, readProjectConfig } from '../../utils/config.js';
-import { promptApiKey, promptProjectId, promptSelectProject, promptKeyChoice } from '../../utils/prompts.js';
+import { readProjectConfig, setProject } from '../../utils/config.js';
 import { startDaemon, getDaemonStatus } from '../../daemon/daemon-manager.js';
-import { fetchProjects, requestGuestKey } from '../../utils/api-client.js';
-export async function startCommand() {
+import { resolveApiKey, resolveProject } from '../../utils/auth-resolver.js';
+import { scaffoldShiftIgnore } from '../../utils/shiftignore.js';
+export async function startCommand(options = {}) {
     const projectRoot = process.cwd();
+    const isAuthInteractive = !options.guest && !options.apiKey;
+    const isProjectInteractive = !!(process.stdin.isTTY);
     console.log('╔════════════════════════════════════════════╗');
     console.log('║         Starting Shift                     ║');
     console.log('╚════════════════════════════════════════════╝\n');
-    // Step 1: Ensure API key exists
+    // Step 1: Resolve API key
     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
+    const authResult = await resolveApiKey({
+        guest: options.guest,
+        apiKey: options.apiKey,
+        interactive: isAuthInteractive,
+        commandLabel: 'Start',
+    });
+    const apiKey = authResult.apiKey;
+    // Step 2: Resolve project
     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 guest flow returned a project_id, save it before resolving
+    if (authResult.projectId && !readProjectConfig(projectRoot)) {
+        setProject(authResult.projectId, options.projectName || 'Guest Project', projectRoot);
     }
+    const project = await resolveProject({
+        apiKey,
+        projectId: options.projectId,
+        projectName: options.projectName,
+        template: options.template,
+        interactive: isProjectInteractive,
+        commandLabel: 'Start',
+        projectRoot,
+    });
+    const projectConfig = readProjectConfig(projectRoot);
     if (!projectConfig) {
         console.error('❌ Failed to configure project');
         process.exit(1);
     }
+    // Scaffold .shiftignore if it doesn't exist
+    if (scaffoldShiftIgnore(projectRoot)) {
+        console.log('[Start] ✓ Created default .shiftignore (edit it to customize ignored files)\n');
+    }
     // Step 3: Check if daemon is already running
     console.log('[Start] Step 3/4: Checking daemon status...');
     const status = getDaemonStatus(projectRoot);
@@ -85,7 +53,7 @@ export async function startCommand() {
     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);
+    const result = await startDaemon(projectRoot, project.projectId, apiKey);
     if (!result.success) {
         console.error(`\n❌ Failed to start daemon: ${result.error}`);
         process.exit(1);
@@ -94,7 +62,7 @@ export async function startCommand() {
     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');
+    console.log('\nUse "shift-cli status" to check connection status.');
+    console.log('Use "shift-cli init" to scan and index the project.');
+    console.log('Use "shift-cli stop" to stop the daemon.\n');
 }