@latentforce/shift 1.0.10 → 1.0.12

package/README.md

@@ -10,65 +10,45 @@ Shift indexes your codebase, builds a dependency relationship graph (DRG), and p
 npm install -g @latentforce/shift
 ```
 
-Requires Node.js >= 18.
+## Getting an API Key
 
-## Quick Start
+1. Go to **https://dev-shift-lite.latentforce.ai/auth**
+2. **Sign up** for an account
+3. **Sign in** to your dashboard
+4. Copy your **API key** from the dashboard
 
-### Guest mode (zero-config)
+From the dashboard you can also **create a project** and **select a migration template** — or you can do both directly from the CLI (see below).
 
-```bash
-cd /path/to/your/project
-shift-cli init --guest        # Auto-creates guest key + project, scans, and indexes
-```
+## Quick Start
 
-### With an API key
+All commands **must be run** from your project's root directory:
 
 ```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
+cd /path/to/your/project
 ```
 
-### Interactive (original behavior)
+### Option A: Interactive (recommended)
 
 ```bash
-shift-cli start    # Configure API key and project interactively
-shift-cli init     # Index project files
+shift-cli start    # Step 1: Configure API key and project, launch daemon
+shift-cli init     # Step 2: Scan and index project files
+shift-cli status   # Step 3: Verify everything is connected
 ```
 
-## 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"}}'
-```
+When you run `shift-cli start` interactively, it will:
+1. **Ask for your API key** — paste the key from your dashboard (or choose guest mode)
+2. **Ask to create or select a project** — you can either:
+   - **Select an existing project** from your account (if you created one on the dashboard)
+   - **Create a new project** from the CLI — it will prompt for a name (defaults to your directory name) and let you select a migration template
 
-Or using npx (no global install needed):
+### Option B: Non-interactive (CI/CD friendly)
 
 ```bash
-claude mcp add-json shift '{"type":"stdio","command":"npx","args":["@latentforce/shift","mcp"],"env":{"SHIFT_PROJECT_ID":"YOUR_PROJECT_ID"}}'
+shift-cli init --api-key YOUR_KEY --project-name "My App"
 ```
 
-### 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):
+If a project named "My App" already exists in your account, it will be reused. Otherwise a new one is created with the specified template.
 
-```json
-{
-  "mcpServers": {
-    "shift": {
-      "command": "shift-cli",
-      "args": ["mcp"],
-      "env": {
-        "SHIFT_PROJECT_ID": "YOUR_PROJECT_ID"
-      }
-    }
-  }
-}
-```
 
 ## CLI Commands
 
@@ -76,37 +56,44 @@ Add to your config file (`%APPDATA%\Claude\claude_desktop_config.json` on Window
 |---------|-------------|
 | `shift-cli start` | Start the daemon and configure the project |
 | `shift-cli init` | Scan and index project files |
+| `shift-cli status` | Show current status |
 | `shift-cli update-drg` | Update the dependency relationship graph |
 | `shift-cli stop` | Stop the daemon |
-| `shift-cli status` | Show current status |
+| `shift-cli add <tool>` | Add Shift MCP server to an AI coding tool |
 | `shift-cli config` | Manage configuration |
 
-### `shift-cli init`
+### `shift-cli start`
 
-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.
+Resolves authentication, configures the project, and launches a background daemon that maintains a WebSocket connection to the Shift backend.
 
-If the project is already indexed, you will be prompted to re-index. Use `--force` to skip the prompt.
+**When run interactively (no flags):**
+1. Prompts you to enter your API key or choose guest mode
+2. Prompts you to **select an existing project** or **create a new one**
+   - If creating: asks for a project name and lets you pick a migration template
+3. Saves config to `.shift/config.json`
+4. Launches the background daemon
+
+If you already created a project on the dashboard (https://dev-shift-lite.latentforce.ai), you can select it from the list. Otherwise, create one directly from the CLI.
 
 | 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 |
+| `--api-key <key>` | Provide API key directly (skips the key prompt) |
+| `--project-name <name>` | Create new project or match existing by name (skips project prompt) |
+| `--project-id <id>` | Use existing project UUID (skips project prompt) |
 | `--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 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
+shift-cli start                                     # Interactive setup (prompts for key + project)
+shift-cli start --guest                              # Quick start without API key
+shift-cli start --api-key <key> --project-name "My App"  # Non-interactive
 ```
 
-### `shift-cli start`
+### `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.
 
-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.
+If the project is already indexed, you will be prompted to re-index. Use `--force` to skip the prompt.
 
 | Flag | Description |
 |------|-------------|
@@ -115,30 +102,53 @@ Resolves authentication, configures the project, and launches a background daemo
 | `--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 |
 
 ```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 init                     # Interactive initialization
+shift-cli init --force             # Force re-index without prompt
+```
+
+### `shift-cli status`
+
+Displays comprehensive information about the current Shift setup — API key status, project details, backend indexing state, and daemon health.
+
+```bash
+shift-cli status
 ```
 
 ### `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.
+Scans source files across all supported languages, detects git changes, and sends file contents to the backend for dependency analysis.
+
+**Supported languages and extensions:**
+
+| Language | Extensions |
+|----------|------------|
+| JavaScript / TypeScript | `.js`, `.jsx`, `.ts`, `.tsx`, `.mjs`, `.cjs` |
+| Python | `.py` |
+| C# | `.cs` |
+| C/C++ | `.cpp`, `.cc`, `.cxx`, `.h`, `.hpp`, `.c` |
 
 | 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
+- **baseline** — sends all source 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 stop`
+
+Stops the background daemon process.
+
+```bash
+shift-cli stop
 ```
 
 ### `shift-cli config`
@@ -151,92 +161,141 @@ Manage Shift configuration (URLs, API key).
 | `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`.
+**Configurable key:** `api-key`
 
 ```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
 ```
+## MCP Integration
+
+After initializing your project, use `shift-cli add` to configure Shift's MCP server in your AI coding tool:
+
+```bash
+shift-cli add <tool>
+```
+
+### Supported tools
+
+| Tool | Command | Config method |
+|------|---------|---------------|
+| Claude Code | `shift-cli add claude-code` | Runs `claude mcp add-json` |
+| Opencode | `shift-cli add opencode` | Writes `opencode.json` |
+| Codex | `shift-cli add codex` | Runs `codex mcp add` |
+| GitHub Copilot | `shift-cli add copilot` | Writes `.vscode/mcp.json` |
+| Factory Droid | `shift-cli add droid` | Runs `droid mcp add` |
+
+For CLI-based tools, if the CLI is not installed, the command will print manual setup instructions.
+
+### Claude Desktop (manual)
 
-## `.shiftignore`
+Add to your config file (`%APPDATA%\Claude\claude_desktop_config.json` on Windows, `~/Library/Application Support/Claude/claude_desktop_config.json` on macOS):
+
+```json
+{
+  "mcpServers": {
+    "shift": {
+      "command": "shift-cli",
+      "args": ["mcp"],
+      "env": {
+        "SHIFT_PROJECT_ID": "YOUR_PROJECT_ID"
+      }
+    }
+  }
+}
+```
+## `.shift/scan_target.json`
 
-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`.
+Shift uses a `scan_target.json` file inside the `.shift/` directory to let you specify which parts of your codebase to scan and in which language. This is especially useful for monorepos or projects with multiple languages.
 
-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.
+A default template is **automatically created** the first time you run `shift-cli init` or `shift-cli start`. By default, it is unconfigured and the server will auto-detect scan targets. Edit the file to manually specify targets.
 
-### Syntax
+### Valid Languages
 
-- 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)
+```
+javascript, typescript, python, cpp, csharp
+```
 
-### Default `.shiftignore`
+### Format
 
-The auto-generated file excludes common non-source directories and files:
+The file is a JSON array of objects, each with:
 
-```gitignore
-# Dependencies
-node_modules/
-vendor/
-bower_components/
+| Field | Type | Description |
+|-------|------|-------------|
+| `language` | `string \| null` | One of the valid languages above, or `null` for auto-detect |
+| `path` | `string` | Relative path from project root (empty string `""` for root) |
 
-# Build output
-dist/
-build/
-out/
-.next/
+### Default Template (auto-generated)
 
-# Test & coverage
-coverage/
-.nyc_output/
+```json
+[
+  {
+    "language": null,
+    "path": ""
+  }
+]
+```
 
-# Environment & secrets
-.env
-.env.*
-*.pem
-*.key
+When left as-is (single entry with `language: null` and `path: ""`), the server auto-detects scan targets.
 
-# Logs
-*.log
-logs/
+### Examples
 
-# OS files
-.DS_Store
-Thumbs.db
+**Single-language project (TypeScript at root):**
 
-# IDE
-.vscode/
-.idea/
-*.swp
-*.swo
+```json
+[
+  {
+    "language": "typescript",
+    "path": ""
+  }
+]
+```
 
-# Python
-__pycache__/
-*.pyc
-venv/
-.venv/
+**Monorepo with multiple languages:**
 
-# Misc
-*.min.js
-*.min.css
-*.map
+```json
+[
+  {
+    "language": "typescript",
+    "path": "frontend"
+  },
+  {
+    "language": "python",
+    "path": "backend"
+  },
+  {
+    "language": "csharp",
+    "path": "services/auth"
+  }
+]
 ```
 
-### Bypassing `.shiftignore`
+**C++ project in a subdirectory:**
 
-Use the `--no-ignore` flag to skip `.shiftignore` rules for a single run:
+```json
+[
+  {
+    "language": "cpp",
+    "path": "engine/src"
+  }
+]
+```
 
-```bash
-shift-cli init --no-ignore         # Index all files
-shift-cli update-drg --no-ignore   # Include ignored files in DRG update
+**Mixed JavaScript and Python at root:**
+
+```json
+[
+  {
+    "language": "javascript",
+    "path": ""
+  },
+  {
+    "language": "python",
+    "path": ""
+  }
+]
 ```
 
 ## MCP Tools
@@ -255,4 +314,4 @@ Each tool accepts an optional `project_id` parameter. If not provided, it falls
 |------|----------|-------------|
 | 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) |
+| Scan targets | `.shift/scan_target.json` | Language and path targets for scanning (auto-created) |

package/build/cli/commands/add.js

@@ -0,0 +1,209 @@
+import { exec } from 'child_process';
+import { promisify } from 'util';
+import * as fs from 'fs';
+import * as path from 'path';
+import { getProjectId } from '../../utils/config.js';
+const execAsync = promisify(exec);
+const SUPPORTED_TOOLS = ['claude-code', 'opencode', 'codex', 'copilot', 'droid'];
+function isNotFound(e) {
+    return e.code === 'ENOENT' || /ENOENT|not found|not recognized/.test(e.message);
+}
+function getStderr(e) {
+    return (e.stderr || e.message || '').trim();
+}
+function shellEscape(arg) {
+    if (/^[a-zA-Z0-9._\-=/]+$/.test(arg))
+        return arg;
+    return `"${arg.replace(/"/g, '\\"')}"`;
+}
+function buildCommand(bin, args) {
+    return [bin, ...args.map(shellEscape)].join(' ');
+}
+function getMcpConfig(projectId) {
+    return {
+        command: 'shift-cli',
+        args: ['mcp'],
+        env: { SHIFT_PROJECT_ID: projectId },
+    };
+}
+async function addClaudeCode(projectId) {
+    const jsonPayload = JSON.stringify({
+        type: 'stdio',
+        command: 'shift-cli',
+        args: ['mcp'],
+        env: { SHIFT_PROJECT_ID: projectId },
+    });
+    try {
+        await execAsync(buildCommand('claude', ['mcp', 'add-json', 'shift', jsonPayload]));
+        console.log('  Added Shift MCP server to Claude Code.');
+        console.log('\n  Verify with: claude mcp list');
+    }
+    catch (e) {
+        const err = e;
+        const stderr = getStderr(err);
+        if (/already exists/.test(stderr)) {
+            console.log('  Shift MCP server is already configured in Claude Code.');
+            console.log('  To update, remove it first: claude mcp remove shift');
+        }
+        else if (isNotFound(err)) {
+            console.log('  "claude" CLI not found. Add manually:\n');
+            console.log(`  claude mcp add-json shift '${jsonPayload}'`);
+        }
+        else {
+            console.log(`  Failed: ${stderr}`);
+            console.log('\n  Try adding manually:\n');
+            console.log(`  claude mcp add-json shift '${jsonPayload}'`);
+        }
+    }
+}
+async function addCodex(projectId) {
+    const config = getMcpConfig(projectId);
+    const args = ['mcp', 'add', 'shift'];
+    for (const [k, v] of Object.entries(config.env)) {
+        args.push('--env', `${k}=${v}`);
+    }
+    args.push('--', config.command, ...config.args);
+    const manualCmd = `codex ${args.join(' ')}`;
+    try {
+        await execAsync(buildCommand('codex', args));
+        console.log('  Added Shift MCP server to Codex.');
+        console.log('\n  Verify with: codex mcp list');
+    }
+    catch (e) {
+        const err = e;
+        const stderr = getStderr(err);
+        if (isNotFound(err)) {
+            console.log('  "codex" CLI not found. Make sure Codex CLI is installed and on your PATH.\n');
+            console.log('  Once installed, add manually:\n');
+        }
+        else if (/already exists/.test(stderr)) {
+            console.log('  Shift MCP server is already configured in Codex.');
+            console.log('  To update, remove it first: codex mcp remove shift');
+            return;
+        }
+        else {
+            console.log(`  Failed: ${stderr}`);
+            console.log('\n  Try adding manually:\n');
+        }
+        console.log(`  ${manualCmd}`);
+    }
+}
+async function addFactoryDroid(projectId) {
+    const config = getMcpConfig(projectId);
+    const args = ['mcp', 'add', 'shift', config.command];
+    for (const [k, v] of Object.entries(config.env)) {
+        args.push('--env', `${k}=${v}`);
+    }
+    const manualCmd = `droid ${args.join(' ')}`;
+    try {
+        await execAsync(buildCommand('droid', args));
+        console.log('  Added Shift MCP server to Factory Droid.');
+        console.log('\n  Verify: type /mcp within droid to see configured servers');
+    }
+    catch (e) {
+        const err = e;
+        console.log(`  Failed: ${getStderr(err)}`);
+        console.log('\n  Try adding manually:\n');
+        console.log(`  ${manualCmd}`);
+    }
+}
+function mergeJsonConfig(filePath, serverKey, serverValue) {
+    let config = {};
+    if (fs.existsSync(filePath)) {
+        try {
+            config = JSON.parse(fs.readFileSync(filePath, 'utf-8'));
+        }
+        catch {
+            console.log(`  Warning: Could not parse existing ${filePath}, creating new file.`);
+            config = {};
+        }
+    }
+    // Navigate/create nested keys
+    let obj = config;
+    for (let i = 0; i < serverKey.length - 1; i++) {
+        const key = serverKey[i];
+        if (typeof obj[key] !== 'object' || obj[key] === null) {
+            obj[key] = {};
+        }
+        obj = obj[key];
+    }
+    const finalKey = serverKey[serverKey.length - 1];
+    obj[finalKey] = serverValue;
+    // Ensure parent directory exists
+    const dir = path.dirname(filePath);
+    if (!fs.existsSync(dir)) {
+        fs.mkdirSync(dir, { recursive: true });
+    }
+    fs.writeFileSync(filePath, JSON.stringify(config, null, 2) + '\n');
+}
+function addOpencode(projectId, projectRoot) {
+    const filePath = path.join(projectRoot, 'opencode.json');
+    let existing = {};
+    if (fs.existsSync(filePath)) {
+        try {
+            existing = JSON.parse(fs.readFileSync(filePath, 'utf-8'));
+        }
+        catch { /* will be recreated */ }
+    }
+    if (!existing['$schema']) {
+        existing['$schema'] = 'https://opencode.ai/config.json';
+        const dir = path.dirname(filePath);
+        if (!fs.existsSync(dir))
+            fs.mkdirSync(dir, { recursive: true });
+        fs.writeFileSync(filePath, JSON.stringify(existing, null, 2) + '\n');
+    }
+    mergeJsonConfig(filePath, ['mcp', 'shift'], {
+        type: 'local',
+        command: ["shift-cli", "mcp"],
+        enabled: true,
+        environment: { "SHIFT_PROJECT_ID": projectId },
+    });
+    console.log(`  Updated ${filePath}`);
+    console.log('\n  Verify: check "mcp.shift" in opencode.json');
+}
+function addCopilot(projectId, projectRoot) {
+    const config = getMcpConfig(projectId);
+    const filePath = path.join(projectRoot, '.vscode', 'mcp.json');
+    mergeJsonConfig(filePath, ['servers', 'shift'], {
+        command: config.command,
+        args: config.args,
+        env: config.env,
+    });
+    console.log(`  Updated ${filePath}`);
+    console.log('\n  Verify: check "servers.shift" in .vscode/mcp.json');
+}
+export async function addCommand(tool) {
+    if (!SUPPORTED_TOOLS.includes(tool)) {
+        console.error(`\n  Unknown tool: "${tool}"\n`);
+        console.error('  Supported tools:');
+        for (const t of SUPPORTED_TOOLS) {
+            console.error(`    - ${t}`);
+        }
+        process.exit(1);
+    }
+    const projectRoot = process.cwd();
+    const projectId = getProjectId(projectRoot);
+    if (!projectId) {
+        console.error('\n  No project configured. Run "shift-cli init" first to set up your project.\n');
+        process.exit(1);
+    }
+    console.log(`\n  Configuring Shift MCP for ${tool}...\n`);
+    switch (tool) {
+        case 'claude-code':
+            await addClaudeCode(projectId);
+            break;
+        case 'opencode':
+            addOpencode(projectId, projectRoot);
+            break;
+        case 'codex':
+            await addCodex(projectId);
+            break;
+        case 'copilot':
+            addCopilot(projectId, projectRoot);
+            break;
+        case 'droid':
+            await addFactoryDroid(projectId);
+            break;
+    }
+    console.log('');
+}

package/build/cli/commands/init.js

@@ -2,12 +2,13 @@ import { exec } from 'child_process';
 import { promisify } from 'util';
 import { createInterface } from 'readline';
 import { createRequire } from 'module';
-import { readProjectConfig, writeProjectConfig } from '../../utils/config.js';
+import { existsSync, readFileSync } from 'fs';
+import path from 'path';
+import { readProjectConfig, writeProjectConfig, ensureScanTargetFile } 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 { loadShiftIgnore, scaffoldShiftIgnore } from '../../utils/shiftignore.js';
+import { getProjectTree, extractAllFilePaths, categorizeFiles, countProjectLOC } from '../../utils/tree-scanner.js';
 const require = createRequire(import.meta.url);
 const { version } = require('../../../package.json');
 const execAsync = promisify(exec);
@@ -64,6 +65,8 @@ export async function initCommand(options = {}) {
         console.error('\n❌ Failed to configure project.');
         process.exit(1);
     }
+    // Ensure .shift/scan_target.json exists (template for user customization)
+    ensureScanTargetFile(projectRoot);
     // Check if project is already indexed (skip check if --force flag is used)
     if (!options.force) {
         try {
@@ -121,18 +124,6 @@ export async function initCommand(options = {}) {
     }
     // 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
@@ -149,7 +140,6 @@ export async function initCommand(options = {}) {
             'venv',
             'env',
         ],
-        shiftIgnore,
     });
     console.log(`[Init]   Files: ${treeData.file_count}`);
     console.log(`[Init]   Directories: ${treeData.dir_count}`);
@@ -174,11 +164,49 @@ export async function initCommand(options = {}) {
     // Extract file paths and categorize (matching extension)
     const allFiles = extractAllFilePaths(treeData.tree);
     const categorized = categorizeFiles(treeData.tree);
+    // Count total lines of code
+    const totalLOC = countProjectLOC(projectRoot, allFiles);
+    console.log(`[Init] Total LOC: ${totalLOC}`);
     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...');
+    // Read scan targets from .shift/scan_target.json if it exists
+    let scanTargets = null;
+    const scanTargetPath = path.join(projectRoot, '.shift', 'scan_target.json');
+    if (existsSync(scanTargetPath)) {
+        try {
+            const raw = readFileSync(scanTargetPath, 'utf-8');
+            const parsed = JSON.parse(raw);
+            // Accept both array format and single object format
+            const targets = Array.isArray(parsed) ? parsed : [parsed];
+            const mapped = targets.map((t) => ({
+                language: t.language ?? t.lang ?? null,
+                path: t.path ?? '',
+            }));
+            // Treat default template (single entry with language=null, path="") as unconfigured
+            const isDefault = mapped.length === 1 && mapped[0].language === null && mapped[0].path === '';
+            if (isDefault) {
+                console.log('[Init] .shift/scan_target.json is default template — server will auto-detect scan targets');
+                console.log('[Init]   Edit the file to manually specify scan targets');
+            }
+            else {
+                scanTargets = mapped;
+                console.log(`[Init] ✓ Loaded ${scanTargets.length} scan target(s) from .shift/scan_target.json`);
+                for (const t of scanTargets) {
+                    console.log(`[Init]   → language=${t.language ?? 'auto'}, path="${t.path || '(root)'}"`);
+                }
+            }
+        }
+        catch (err) {
+            console.log(`[Init] ⚠️  Failed to read .shift/scan_target.json: ${err.message}`);
+            console.log('[Init]   Proceeding without scan targets (server will auto-detect)');
+        }
+    }
+    else {
+        console.log('[Init] No .shift/scan_target.json found — server will auto-detect scan targets');
+    }
     const payload = {
         project_id: project.projectId,
         project_tree: treeData,
@@ -192,6 +220,8 @@ export async function initCommand(options = {}) {
             scan_timestamp: new Date().toISOString(),
             project_name: project.projectName,
         },
+        scan_targets: scanTargets,
+        total_loc: totalLOC,
     };
     try {
         const response = await sendInitScan(apiKey, project.projectId, payload);

package/build/cli/commands/start.js

@@ -1,7 +1,6 @@
-import { readProjectConfig, setProject } from '../../utils/config.js';
+import { readProjectConfig, setProject, ensureScanTargetFile } from '../../utils/config.js';
 import { startDaemon, getDaemonStatus } from '../../daemon/daemon-manager.js';
 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;
@@ -38,10 +37,8 @@ export async function startCommand(options = {}) {
         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');
-    }
+    // Ensure .shift/scan_target.json exists (template for user customization)
+    ensureScanTargetFile(projectRoot);
     // Step 3: Check if daemon is already running
     console.log('[Start] Step 3/4: Checking daemon status...');
     const status = getDaemonStatus(projectRoot);

package/build/cli/commands/update-drg.js

@@ -4,13 +4,12 @@ import { exec } from 'child_process';
 import { promisify } from 'util';
 import { getApiKey, readProjectConfig } from '../../utils/config.js';
 import { getProjectTree, extractAllFilePaths } from '../../utils/tree-scanner.js';
-import { loadShiftIgnore, filterPaths } from '../../utils/shiftignore.js';
 import { sendUpdateDrg } from '../../utils/api-client.js';
 const execAsync = promisify(exec);
 async function detectGitChanges(projectRoot, extensions) {
     const changes = { added: [], modified: [], deleted: [] };
     try {
-        const { stdout } = await execAsync('git status --porcelain', { cwd: projectRoot });
+        const { stdout } = await execAsync('git status --porcelain -u', { cwd: projectRoot });
         for (const line of stdout.split('\n')) {
             if (!line.trim())
                 continue;
@@ -52,7 +51,24 @@ async function detectGitChanges(projectRoot, extensions) {
     }
     return changes;
 }
-const JS_TS_EXTENSIONS = new Set(['.js', '.jsx', '.ts', '.tsx', '.mjs', '.cjs']);
+const LANGUAGE_CONFIG = {
+    js_ts: {
+        extensions: new Set(['.js', '.jsx', '.ts', '.tsx', '.mjs', '.cjs']),
+        label: 'JS/TS',
+    },
+    python: {
+        extensions: new Set(['.py']),
+        label: 'Python',
+    },
+    csharp: {
+        extensions: new Set(['.cs']),
+        label: 'C#',
+    },
+    cpp: {
+        extensions: new Set(['.cpp', '.cc', '.cxx', '.h', '.hpp', '.c']),
+        label: 'C/C++',
+    },
+};
 export async function updateDrgCommand(options = {}) {
     const projectRoot = process.cwd();
     const mode = options.mode || 'incremental';
@@ -76,15 +92,8 @@ export async function updateDrgCommand(options = {}) {
         process.exit(1);
     }
     console.log(`[DRG] ✓ Project: ${projectConfig.project_name} (${projectConfig.project_id})\n`);
-    // Step 3: Scan project for JS/TS files
-    console.log('[DRG] Step 3/4: Scanning project for JS/TS files...');
-    const shiftIgnore = options.noIgnore ? null : loadShiftIgnore(projectRoot);
-    if (options.noIgnore) {
-        console.log('[DRG] ⚠️  --no-ignore flag set — skipping .shiftignore rules\n');
-    }
-    else if (shiftIgnore) {
-        console.log('[DRG] ✓ Found .shiftignore — applying custom ignore rules\n');
-    }
+    // Step 3: Scan project for all supported language files
+    console.log('[DRG] Step 3/4: Scanning project for supported languages...');
     const treeData = getProjectTree(projectRoot, {
         depth: 0,
         exclude_patterns: [
@@ -100,89 +109,86 @@ export async function updateDrgCommand(options = {}) {
             'venv',
             'env',
         ],
-        shiftIgnore,
     });
     const allFiles = extractAllFilePaths(treeData.tree);
-    const jstsFiles = allFiles.filter((filePath) => {
-        const ext = path.extname(filePath).toLowerCase();
-        return JS_TS_EXTENSIONS.has(ext);
-    });
+    // Group files by language (each file counted in first matching language)
+    const filesByLanguage = {};
+    for (const lang of Object.keys(LANGUAGE_CONFIG)) {
+        const extSet = LANGUAGE_CONFIG[lang].extensions;
+        filesByLanguage[lang] = allFiles.filter((filePath) => extSet.has(path.extname(filePath).toLowerCase()));
+    }
+    const languagesWithFiles = Object.entries(filesByLanguage).filter(([_, files]) => files.length > 0);
     console.log(`[DRG]   Total files scanned: ${allFiles.length}`);
-    console.log(`[DRG]   JS/TS files found: ${jstsFiles.length}\n`);
-    if (jstsFiles.length === 0) {
-        console.log('⚠️  No JS/TS files found in project. Nothing to update.\n');
+    for (const [lang, files] of languagesWithFiles) {
+        console.log(`[DRG]   ${LANGUAGE_CONFIG[lang].label} files: ${files.length}`);
+    }
+    console.log('');
+    if (languagesWithFiles.length === 0) {
+        console.log('⚠️  No supported language files found (JS/TS, Python, C#, C++). Nothing to update.\n');
         return;
     }
-    // Read file contents
-    const files = [];
-    let readErrors = 0;
-    for (const filePath of jstsFiles) {
-        const absolutePath = path.join(projectRoot, filePath);
-        try {
-            const content = fs.readFileSync(absolutePath, 'utf-8');
-            files.push({ file_path: filePath, content });
+    let anySent = false;
+    let lastError = null;
+    for (const [language, langFiles] of languagesWithFiles) {
+        const extSet = LANGUAGE_CONFIG[language].extensions;
+        const label = LANGUAGE_CONFIG[language].label;
+        // Read file contents for this language
+        const files = [];
+        let readErrors = 0;
+        for (const filePath of langFiles) {
+            const absolutePath = path.join(projectRoot, filePath);
+            try {
+                const content = fs.readFileSync(absolutePath, 'utf-8');
+                files.push({ file_path: filePath, content });
+            }
+            catch {
+                readErrors++;
+            }
         }
-        catch {
-            readErrors++;
+        if (readErrors > 0) {
+            console.log(`[DRG]   [${label}] ⚠️  Could not read ${readErrors} file(s)\n`);
         }
-    }
-    if (readErrors > 0) {
-        console.log(`[DRG] ⚠️  Could not read ${readErrors} file(s)\n`);
-    }
-    // Always use git to compute added/modified/deleted (single source of truth)
-    console.log('[DRG]   Detecting git changes...');
-    const gitChanges = await detectGitChanges(projectRoot, JS_TS_EXTENSIONS);
-    // Filter git changes through .shiftignore
-    gitChanges.added = filterPaths(shiftIgnore, gitChanges.added);
-    gitChanges.modified = filterPaths(shiftIgnore, gitChanges.modified);
-    gitChanges.deleted = filterPaths(shiftIgnore, gitChanges.deleted);
-    console.log(`[DRG]   Git changes — added: ${gitChanges.added.length}, modified: ${gitChanges.modified.length}, deleted: ${gitChanges.deleted.length}`);
-    // Which files to send: incremental = only changed; baseline = all (full re-analysis)
-    const changedPaths = new Set([...gitChanges.added, ...gitChanges.modified]);
-    const filesToSend = mode === 'baseline'
-        ? files
-        : files.filter((f) => changedPaths.has(f.file_path));
-    if (mode === 'baseline') {
-        console.log(`[DRG]   Baseline: sending all ${filesToSend.length} JS/TS files.\n`);
-    }
-    else {
-        console.log(`[DRG]   Incremental: sending ${filesToSend.length} changed file(s).\n`);
-    }
-    if (filesToSend.length === 0 && gitChanges.deleted.length === 0) {
-        console.log('\n✓ No JS/TS changes detected. DRG is up to date.\n');
-        return;
-    }
-    // Step 4: Send to backend
-    console.log(`[DRG] Step 4/4: Sending ${filesToSend.length} files to backend (mode: ${mode})...`);
-    const payload = {
-        project_id: projectConfig.project_id,
-        language: 'js_ts',
-        mode: mode,
-        changes: gitChanges,
-        files: filesToSend,
-    };
-    try {
-        const response = await sendUpdateDrg(apiKey, payload);
-        console.log('\n╔═══════════════════════════════════════════════╗');
-        console.log('║         ✓ DRG Update Complete                 ║');
-        console.log('╚═══════════════════════════════════════════════╝\n');
-        console.log(`  Success:    ${response.success}`);
-        console.log(`  Message:    ${response.message}`);
-        if (response.stats) {
-            console.log(`  Files sent: ${response.stats.total_files_provided}`);
-            console.log(`  Unique:     ${response.stats.unique_paths}`);
-            console.log(`  Added:      ${response.stats.added}`);
-            console.log(`  Modified:   ${response.stats.modified}`);
-            console.log(`  Deleted:    ${response.stats.deleted}`);
-            const affected = response.stats.affected_file_paths;
-            if (affected?.length) {
-                console.log(`  Affected by deletions (edges updated): ${affected.length} file(s)`);
+        const gitChanges = await detectGitChanges(projectRoot, extSet);
+        const changedPaths = new Set([...gitChanges.added, ...gitChanges.modified]);
+        const filesToSend = mode === 'baseline'
+            ? files
+            : files.filter((f) => changedPaths.has(f.file_path));
+        if (filesToSend.length === 0 && gitChanges.deleted.length === 0) {
+            console.log(`[DRG]   [${label}] No changes. Skipping.\n`);
+            continue;
+        }
+        console.log(`[DRG]   [${label}] Git changes — added: ${gitChanges.added.length}, modified: ${gitChanges.modified.length}, deleted: ${gitChanges.deleted.length}`);
+        console.log(`[DRG]   [${label}] Sending ${filesToSend.length} file(s) (mode: ${mode})...`);
+        const payload = {
+            project_id: projectConfig.project_id,
+            language,
+            mode,
+            changes: gitChanges,
+            files: filesToSend,
+        };
+        try {
+            const response = await sendUpdateDrg(apiKey, payload);
+            anySent = true;
+            console.log(`[DRG]   [${label}] ✓ ${response.message}`);
+            if (response.stats) {
+                console.log(`[DRG]   [${label}]   Files sent: ${response.stats.total_files_provided}, Added: ${response.stats.added}, Modified: ${response.stats.modified}, Deleted: ${response.stats.deleted}`);
             }
         }
-        console.log('\nUse "shift-cli status" to check progress.\n');
+        catch (error) {
+            lastError = error;
+            console.error(`[DRG]   [${label}] ❌ ${error.message}`);
+        }
+        console.log('');
     }
-    catch (error) {
-        console.error(`\n❌ Failed to update DRG: ${error.message}`);
+    // Step 4: Summary
+    console.log('╔═══════════════════════════════════════════════╗');
+    console.log('║         ✓ DRG Update Complete                 ║');
+    console.log('╚═══════════════════════════════════════════════╝\n');
+    if (lastError && !anySent) {
+        console.error(`❌ All updates failed. Last error: ${lastError.message}`);
         process.exit(1);
     }
+    if (lastError) {
+        console.log(`⚠️  Some languages failed (see above).`);
+    }
 }

package/build/index.js

@@ -16,8 +16,7 @@ program
     '  shift-cli status         Check current status\n\n' +
     'Configuration:\n' +
     '  Global config:   ~/.shift/config.json\n' +
-    '  Project config:  .shift/config.json\n' +
-    '  Ignore rules:    .shiftignore (auto-created on first run)')
+    '  Project config:  .shift/config.json')
     .version(version);
 // MCP server mode (default when run via MCP host)
 program
@@ -55,7 +54,7 @@ startCmd.addHelpText('after', `
 Details:
   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.
+  Shift backend.
 
 Examples:
   shift-cli start                                   Interactive setup
@@ -72,7 +71,6 @@ const initCmd = program
     .option('--project-name <name>', 'Create a new project or match an existing one by name')
     .option('--project-id <id>', 'Link to an existing project by its UUID')
     .option('--template <id>', 'Use a specific migration template when creating the project')
-    .option('--no-ignore', 'Skip .shiftignore rules for this run (send all files)')
     .action(async (options) => {
     const { initCommand } = await import('./cli/commands/init.js');
     await initCommand({
@@ -82,7 +80,6 @@ const initCmd = program
         projectName: options.projectName,
         projectId: options.projectId,
         template: options.template,
-        noIgnore: options.noIgnore,
     });
 });
 initCmd.addHelpText('after', `
@@ -90,7 +87,6 @@ Details:
   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.
-  Creates a default .shiftignore if one doesn't exist.
 
   If the project is already indexed, you will be prompted to re-index.
   Use --force to skip the prompt.
@@ -98,7 +94,6 @@ Details:
 Examples:
   shift-cli init                     Interactive initialization
   shift-cli init --force             Force re-index without prompt
-  shift-cli init --no-ignore         Index all files, ignore .shiftignore
   shift-cli init --guest             Quick init with guest auth
 `);
 // --- stop ---
@@ -136,16 +131,15 @@ const updateDrgCmd = program
     .command('update-drg')
     .description('Update the dependency relationship graph (DRG)')
     .option('-m, --mode <mode>', 'Update mode: "baseline" (all files) or "incremental" (git-changed only)', 'incremental')
-    .option('--no-ignore', 'Skip .shiftignore rules for this run (send all files)')
     .action(async (options) => {
     const { updateDrgCommand } = await import('./cli/commands/update-drg.js');
-    await updateDrgCommand({ mode: options.mode, noIgnore: options.noIgnore });
+    await updateDrgCommand({ mode: options.mode });
 });
 updateDrgCmd.addHelpText('after', `
 Details:
   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.
+  dependency analysis.
 
 Modes:
   incremental    Send only git-changed files (default, faster)
@@ -154,7 +148,27 @@ Modes:
 Examples:
   shift-cli update-drg                       Incremental update
   shift-cli update-drg -m baseline           Full re-analysis
-  shift-cli update-drg --no-ignore           Include ignored files
+`);
+// --- add mcp servers---
+const addCmd = program
+    .command('add <tool>')
+    .description('Add Shift MCP server to an AI coding tool')
+    .action(async (tool) => {
+    const { addCommand } = await import('./cli/commands/add.js');
+    await addCommand(tool);
+});
+addCmd.addHelpText('after', `
+Supported tools:
+  claude-code     Configure via Claude Code CLI
+  opencode        Write to opencode.json
+  codex           Configure via Codex CLI
+  copilot         Write to .vscode/mcp.json
+  droid           Configure via Factory-Droid CLI
+
+Examples:
+  shift-cli add claude-code
+  shift-cli add copilot
+  shift-cli add opencode
 `);
 // --- config ---
 const configCmd = program

package/build/utils/api-client.js

@@ -48,19 +48,28 @@ export async function fetchProjects(apiKey) {
  * Matching extension's init-scan API call
  */
 export async function sendInitScan(apiKey, projectId, payload) {
-    const response = await fetch(`${API_BASE_URL_ORCH}/api/projects/${projectId}/init-scan`, {
-        method: 'POST',
-        headers: {
-            'Authorization': `Bearer ${apiKey}`,
-            'Content-Type': 'application/json',
-        },
-        body: JSON.stringify(payload),
-    });
-    if (!response.ok) {
-        const text = await response.text();
-        throw new Error(text || `HTTP ${response.status}`);
+    try {
+        // Ensure proper URL construction with leading slash
+        const path = `/api/projects/${projectId}/init-scan`;
+        const url = new URL(path, API_BASE_URL_ORCH).toString();
+        const response = await fetch(url, {
+            method: 'POST',
+            headers: {
+                'Authorization': `Bearer ${apiKey}`,
+                'Content-Type': 'application/json',
+            },
+            body: JSON.stringify(payload),
+        });
+        if (!response.ok) {
+            const text = await response.text();
+            throw new Error(text || `HTTP ${response.status}`);
+        }
+        return await response.json();
+    }
+    catch (error) {
+        // Re-throw for caller to handle; keep stack/context
+        throw error;
     }
-    return await response.json();
 }
 /**
  * Send update-drg request to backend

package/build/utils/config.js

@@ -132,6 +132,22 @@ export function ensureLocalShiftDir(projectRoot) {
         fs.mkdirSync(dir, { recursive: true });
     }
 }
+const SCAN_TARGET_TEMPLATE = [
+    {
+        language: null,
+        path: '',
+    },
+];
+/**
+ * Create .shift/scan_target.json with a template if it doesn't exist.
+ * Users can edit this file to manually specify scan targets.
+ */
+export function ensureScanTargetFile(projectRoot) {
+    const filePath = path.join(getLocalShiftDir(projectRoot), 'scan_target.json');
+    if (!fs.existsSync(filePath)) {
+        fs.writeFileSync(filePath, JSON.stringify(SCAN_TARGET_TEMPLATE, null, 2));
+    }
+}
 export function readProjectConfig(projectRoot) {
     try {
         const filePath = path.join(getLocalShiftDir(projectRoot), LOCAL_CONFIG_FILE);
@@ -152,8 +168,10 @@ export function writeProjectConfig(config, projectRoot) {
     // Also create .gitignore in .shift folder (matching extension)
     const gitignorePath = path.join(getLocalShiftDir(projectRoot), '.gitignore');
     if (!fs.existsSync(gitignorePath)) {
-        fs.writeFileSync(gitignorePath, '*\n!.gitignore\n!config.json\n');
+        fs.writeFileSync(gitignorePath, '*\n!.gitignore\n!config.json\n!scan_target.json\n');
     }
+    // Create scan_target.json template if it doesn't exist
+    ensureScanTargetFile(projectRoot);
 }
 export function getProjectId(projectRoot) {
     const config = readProjectConfig(projectRoot);

package/build/utils/tree-scanner.js

@@ -21,7 +21,7 @@ const DEFAULT_EXCLUDE_PATTERNS = [
  * Get project tree - matching extension's getProjectTree function
  */
 export function getProjectTree(workspaceRoot, options = {}) {
-    const { depth = 0, exclude_patterns = DEFAULT_EXCLUDE_PATTERNS, shiftIgnore = null, } = options;
+    const { depth = 0, exclude_patterns = DEFAULT_EXCLUDE_PATTERNS, } = options;
     let file_count = 0;
     let dir_count = 0;
     let total_size = 0;
@@ -40,15 +40,6 @@ export function getProjectTree(workspaceRoot, options = {}) {
                 }
                 const itemPath = path.join(dirPath, entry.name);
                 const itemRelativePath = relativePath ? path.join(relativePath, entry.name) : entry.name;
-                // Check if should be excluded by .shiftignore
-                if (shiftIgnore) {
-                    // Use forward slashes for ignore matching; add trailing / for directories
-                    const testPath = itemRelativePath.replace(/\\/g, '/');
-                    const isDir = entry.isDirectory();
-                    if (shiftIgnore.ignores(isDir ? testPath + '/' : testPath)) {
-                        continue;
-                    }
-                }
                 if (entry.isDirectory()) {
                     dir_count++;
                     const children = scanDirectory(itemPath, currentDepth + 1, itemRelativePath);
@@ -123,6 +114,23 @@ export function extractAllFilePaths(tree, basePath = '') {
  * Categorize files by type
  * Matching extension's categorizeFiles function
  */
+/**
+ * Count total lines of code across all project files
+ */
+export function countProjectLOC(rootPath, filePaths) {
+    let totalLOC = 0;
+    for (const filePath of filePaths) {
+        try {
+            const fullPath = path.join(rootPath, filePath);
+            const content = fs.readFileSync(fullPath, 'utf-8');
+            totalLOC += content.split('\n').length;
+        }
+        catch {
+            // Skip binary/unreadable files
+        }
+    }
+    return totalLOC;
+}
 export function categorizeFiles(tree, basePath = '') {
     const categories = {
         source_files: [],

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@latentforce/shift",
-    "version": "1.0.10",
+    "version": "1.0.12",
     "description": "Shift CLI - AI-powered code intelligence with MCP support",
     "type": "module",
     "main": "./build/index.js",
@@ -38,7 +38,6 @@
     "dependencies": {
         "@modelcontextprotocol/sdk": "^1.25.3",
         "commander": "^12.0.0",
-        "ignore": "^7.0.5",
         "ws": "^8.14.0",
         "zod": "^3.25.76"
     },