linchpin-cli 0.2.0 → 0.2.2

package/dist/bin/vm.js

@@ -6,16 +6,32 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 const dotenv_1 = __importDefault(require("dotenv"));
 dotenv_1.default.config(); // Load env vars once at entry point
+// Read version from package.json
+// Path: from bin/vm.ts -> ../package.json (source)
+// Path: from dist/bin/vm.js -> ../../package.json (compiled)
+// eslint-disable-next-line @typescript-eslint/no-var-requires
+const pkg = require('../../package.json');
+const CLI_VERSION = pkg.version;
+const sentry_1 = require("../src/lib/sentry");
+const auth_1 = require("../src/lib/auth");
+// Initialize Sentry early to catch all errors
+(0, sentry_1.initSentry)(CLI_VERSION);
+// Set user if already logged in (for error tracking)
+const existingToken = (0, auth_1.loadCredentials)();
+if (existingToken) {
+    (0, sentry_1.setUser)({ id: existingToken.substring(0, 16) });
+}
 const commander_1 = require("commander");
 const check_1 = require("../src/commands/check");
 const explain_1 = require("../src/commands/explain");
 const align_1 = require("../src/commands/align");
 const login_1 = require("../src/commands/login");
+const plan_1 = require("../src/commands/plan");
 const program = new commander_1.Command();
 program
     .name('linchpin')
     .description("Linchpin: The 'Don't Break My App' Tool")
-    .version('0.1.0');
+    .version(CLI_VERSION);
 program
     .command('check', { isDefault: true })
     .description('Scan your project for outdated dependencies')
@@ -44,4 +60,24 @@ program
     .command('whoami')
     .description('Show current login status')
     .action(() => (0, login_1.whoamiCommand)());
+program
+    .command('plan <file>')
+    .description('Execute an upgrade plan from a JSON file')
+    .option('-y, --yes', 'Skip confirmation prompts')
+    .option('--dry-run', 'Show what would be done without making changes')
+    .action((file, options) => (0, plan_1.planCommand)(file, options));
+// Global error handler to capture unhandled errors
+process.on('uncaughtException', async (error) => {
+    (0, sentry_1.captureException)(error, { type: 'uncaughtException' });
+    console.error('An unexpected error occurred:', error.message);
+    await (0, sentry_1.flush)();
+    process.exit(1);
+});
+process.on('unhandledRejection', async (reason) => {
+    const error = reason instanceof Error ? reason : new Error(String(reason));
+    (0, sentry_1.captureException)(error, { type: 'unhandledRejection' });
+    console.error('An unexpected error occurred:', error.message);
+    await (0, sentry_1.flush)();
+    process.exit(1);
+});
 program.parse(process.argv);

package/dist/src/__tests__/align.integration.test.js

@@ -0,0 +1,209 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const align_1 = require("../commands/align");
+// Mock dependencies
+jest.mock('../lib/files', () => ({
+    getPackageJson: jest.fn(),
+}));
+jest.mock('../lib/npm', () => ({
+    getRegistryVersion: jest.fn(),
+    hasApiKey: jest.fn(),
+}));
+jest.mock('../lib/ai', () => ({
+    getLatestVersion: jest.fn(),
+    getUpgradeRisks: jest.fn(),
+}));
+jest.mock('child_process', () => ({
+    execSync: jest.fn(),
+}));
+jest.mock('inquirer', () => ({
+    prompt: jest.fn(),
+}));
+// Mock chalk (uses __mocks__/chalk.js)
+jest.mock('chalk');
+const files_1 = require("../lib/files");
+const npm_1 = require("../lib/npm");
+const child_process_1 = require("child_process");
+const inquirer_1 = __importDefault(require("inquirer"));
+const mockGetPackageJson = files_1.getPackageJson;
+const mockGetRegistryVersion = npm_1.getRegistryVersion;
+const mockHasApiKey = npm_1.hasApiKey;
+const mockExecSync = child_process_1.execSync;
+const mockPrompt = inquirer_1.default.prompt;
+describe('alignCommand integration', () => {
+    let consoleSpy;
+    let stdoutSpy;
+    beforeEach(() => {
+        jest.clearAllMocks();
+        consoleSpy = jest.spyOn(console, 'log').mockImplementation();
+        stdoutSpy = jest.spyOn(process.stdout, 'write').mockImplementation();
+        // Default mocks
+        mockHasApiKey.mockReturnValue(false);
+    });
+    afterEach(() => {
+        consoleSpy.mockRestore();
+        stdoutSpy.mockRestore();
+    });
+    describe('single package alignment', () => {
+        it('shows error when package.json is missing', async () => {
+            mockGetPackageJson.mockResolvedValue(null);
+            await (0, align_1.alignCommand)('express');
+            expect(consoleSpy).toHaveBeenCalledWith(expect.stringContaining('No package.json found'));
+        });
+        it('shows error when package is not found', async () => {
+            mockGetPackageJson.mockResolvedValue({
+                name: 'test-project',
+                version: '1.0.0',
+                dependencies: { 'lodash': '4.17.0' },
+            });
+            await (0, align_1.alignCommand)('nonexistent-pkg');
+            expect(consoleSpy).toHaveBeenCalledWith(expect.stringContaining('not found'));
+        });
+        it('shows up-to-date message when no update needed', async () => {
+            mockGetPackageJson.mockResolvedValue({
+                name: 'test-project',
+                version: '1.0.0',
+                dependencies: { 'express': '4.18.2' },
+            });
+            mockGetRegistryVersion.mockReturnValue('4.18.2');
+            await (0, align_1.alignCommand)('express');
+            expect(consoleSpy).toHaveBeenCalledWith(expect.stringContaining('Already up to date'));
+        });
+        it('prompts for confirmation on safe upgrade', async () => {
+            mockGetPackageJson.mockResolvedValue({
+                name: 'test-project',
+                version: '1.0.0',
+                dependencies: { 'express': '^4.17.0' },
+            });
+            mockGetRegistryVersion.mockReturnValue('4.18.2');
+            mockPrompt.mockResolvedValue({ confirm: false });
+            // Mock git check
+            mockExecSync.mockImplementation((cmd) => {
+                if (cmd.includes('rev-parse'))
+                    throw new Error('not a git repo');
+                return Buffer.from('');
+            });
+            await (0, align_1.alignCommand)('express');
+            // Should show current and target versions
+            expect(consoleSpy).toHaveBeenCalledWith(expect.stringContaining('Current'));
+            expect(consoleSpy).toHaveBeenCalledWith(expect.stringContaining('Target'));
+            // Should prompt for confirmation
+            expect(mockPrompt).toHaveBeenCalled();
+            // User declined, should show blocked message
+            expect(consoleSpy).toHaveBeenCalledWith(expect.stringContaining('blocked'));
+        });
+        it('installs package when user confirms', async () => {
+            mockGetPackageJson.mockResolvedValue({
+                name: 'test-project',
+                version: '1.0.0',
+                dependencies: { 'express': '^4.17.0' },
+            });
+            mockGetRegistryVersion.mockReturnValue('4.18.2');
+            mockPrompt.mockResolvedValue({ confirm: true });
+            // Mock git and npm commands
+            mockExecSync.mockImplementation((cmd) => {
+                if (cmd.includes('rev-parse'))
+                    throw new Error('not a git repo');
+                return Buffer.from('');
+            });
+            await (0, align_1.alignCommand)('express');
+            // Should run npm install
+            expect(mockExecSync).toHaveBeenCalledWith(expect.stringContaining('npm install express@4.18.2'), expect.anything());
+            // Should show success
+            expect(consoleSpy).toHaveBeenCalledWith(expect.stringContaining('Success'));
+        });
+        it('warns about major version upgrades', async () => {
+            mockGetPackageJson.mockResolvedValue({
+                name: 'test-project',
+                version: '1.0.0',
+                dependencies: { 'express': '^3.0.0' },
+            });
+            mockGetRegistryVersion.mockReturnValue('4.18.2');
+            mockPrompt.mockResolvedValue({ confirm: false });
+            mockExecSync.mockImplementation((cmd) => {
+                if (cmd.includes('rev-parse'))
+                    throw new Error('not a git repo');
+                return Buffer.from('');
+            });
+            await (0, align_1.alignCommand)('express');
+            // Should show major version warning
+            expect(consoleSpy).toHaveBeenCalledWith(expect.stringContaining('MAJOR VERSION JUMP'));
+        });
+        it('creates git restore point when in git repo', async () => {
+            mockGetPackageJson.mockResolvedValue({
+                name: 'test-project',
+                version: '1.0.0',
+                dependencies: { 'express': '^4.17.0' },
+            });
+            mockGetRegistryVersion.mockReturnValue('4.18.2');
+            mockPrompt.mockResolvedValue({ confirm: true });
+            // Mock as git repo
+            mockExecSync.mockImplementation(() => Buffer.from(''));
+            await (0, align_1.alignCommand)('express');
+            // Should create backup commit
+            expect(mockExecSync).toHaveBeenCalledWith(expect.stringContaining('git commit'), expect.anything());
+            // Should show restore hint
+            expect(consoleSpy).toHaveBeenCalledWith(expect.stringContaining('restore point'));
+        });
+    });
+    describe('align --all mode', () => {
+        it('shows up-to-date when no updates available', async () => {
+            mockGetPackageJson.mockResolvedValue({
+                name: 'test-project',
+                version: '1.0.0',
+                dependencies: {
+                    'express': '4.18.2',
+                    'lodash': '4.17.21',
+                },
+            });
+            mockGetRegistryVersion
+                .mockReturnValueOnce('4.18.2')
+                .mockReturnValueOnce('4.17.21');
+            await (0, align_1.alignCommand)({ all: true });
+            expect(consoleSpy).toHaveBeenCalledWith(expect.stringContaining('All packages are up to date'));
+        });
+        it('allows user to select packages for update', async () => {
+            mockGetPackageJson.mockResolvedValue({
+                name: 'test-project',
+                version: '1.0.0',
+                dependencies: {
+                    'express': '4.17.0',
+                    'lodash': '4.17.0',
+                },
+            });
+            mockGetRegistryVersion
+                .mockReturnValueOnce('4.18.2') // express - minor
+                .mockReturnValueOnce('4.17.21'); // lodash - patch
+            mockPrompt.mockResolvedValue({ selected: [] });
+            mockExecSync.mockImplementation((cmd) => {
+                if (cmd.includes('rev-parse'))
+                    throw new Error('not a git repo');
+                return Buffer.from('');
+            });
+            await (0, align_1.alignCommand)({ all: true });
+            // Should show found updates
+            expect(consoleSpy).toHaveBeenCalledWith(expect.stringContaining('Found 2 packages with updates'));
+            // User selected none
+            expect(consoleSpy).toHaveBeenCalledWith(expect.stringContaining('No packages selected'));
+        });
+    });
+});
+describe('isMajorUpgrade', () => {
+    it('detects major version changes', () => {
+        expect((0, align_1.isMajorUpgrade)('1.0.0', '2.0.0')).toBe(true);
+        expect((0, align_1.isMajorUpgrade)('4.17.21', '5.0.0')).toBe(true);
+        expect((0, align_1.isMajorUpgrade)('^3.0.0', '4.0.0')).toBe(true);
+    });
+    it('returns false for minor/patch changes', () => {
+        expect((0, align_1.isMajorUpgrade)('1.0.0', '1.1.0')).toBe(false);
+        expect((0, align_1.isMajorUpgrade)('1.0.0', '1.0.1')).toBe(false);
+        expect((0, align_1.isMajorUpgrade)('^4.17.0', '4.18.2')).toBe(false);
+    });
+    it('handles edge cases', () => {
+        expect((0, align_1.isMajorUpgrade)('0.9.0', '1.0.0')).toBe(true);
+        expect((0, align_1.isMajorUpgrade)('~1.0.0', '2.0.0')).toBe(true);
+    });
+});

package/dist/src/__tests__/check.integration.test.js

@@ -0,0 +1,148 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const check_1 = require("../commands/check");
+// Mock dependencies
+jest.mock('../lib/files', () => ({
+    getPackageJson: jest.fn(),
+}));
+jest.mock('../lib/npm', () => ({
+    getRegistryVersion: jest.fn(),
+    hasApiKey: jest.fn(),
+    isUsingCloudApi: jest.fn(),
+    apiRequest: jest.fn(),
+}));
+jest.mock('../lib/ai', () => ({
+    getLatestVersion: jest.fn(),
+    getBatchRiskAnalysis: jest.fn(),
+}));
+// Mock chalk (uses __mocks__/chalk.js)
+jest.mock('chalk');
+const files_1 = require("../lib/files");
+const npm_1 = require("../lib/npm");
+const mockGetPackageJson = files_1.getPackageJson;
+const mockGetRegistryVersion = npm_1.getRegistryVersion;
+const mockHasApiKey = npm_1.hasApiKey;
+const mockIsUsingCloudApi = npm_1.isUsingCloudApi;
+describe('checkCommand integration', () => {
+    let consoleSpy;
+    let stdoutSpy;
+    beforeEach(() => {
+        jest.clearAllMocks();
+        consoleSpy = jest.spyOn(console, 'log').mockImplementation();
+        stdoutSpy = jest.spyOn(process.stdout, 'write').mockImplementation();
+        // Default mocks
+        mockHasApiKey.mockReturnValue(false);
+        mockIsUsingCloudApi.mockReturnValue(false);
+    });
+    afterEach(() => {
+        consoleSpy.mockRestore();
+        stdoutSpy.mockRestore();
+    });
+    describe('when package.json is missing', () => {
+        it('shows error message', async () => {
+            mockGetPackageJson.mockResolvedValue(null);
+            await (0, check_1.checkCommand)({});
+            expect(consoleSpy).toHaveBeenCalledWith(expect.stringContaining('No package.json found'));
+        });
+    });
+    describe('when package.json has no dependencies', () => {
+        it('shows warning message', async () => {
+            mockGetPackageJson.mockResolvedValue({
+                name: 'test-project',
+                version: '1.0.0',
+                dependencies: {},
+                devDependencies: {},
+            });
+            await (0, check_1.checkCommand)({});
+            expect(consoleSpy).toHaveBeenCalledWith(expect.stringContaining('no dependencies listed'));
+        });
+    });
+    describe('when scanning dependencies (free mode)', () => {
+        it('checks all dependencies and displays results', async () => {
+            mockGetPackageJson.mockResolvedValue({
+                name: 'test-project',
+                version: '1.0.0',
+                dependencies: {
+                    'express': '^4.18.0',
+                    'lodash': '^4.17.21',
+                },
+                devDependencies: {
+                    'jest': '^29.0.0',
+                },
+            });
+            mockGetRegistryVersion
+                .mockReturnValueOnce('4.21.0') // express - MINOR
+                .mockReturnValueOnce('4.17.21') // lodash - OK
+                .mockReturnValueOnce('30.0.0'); // jest - MAJOR
+            await (0, check_1.checkCommand)({});
+            // Should check each package
+            expect(mockGetRegistryVersion).toHaveBeenCalledTimes(3);
+            expect(mockGetRegistryVersion).toHaveBeenCalledWith('express');
+            expect(mockGetRegistryVersion).toHaveBeenCalledWith('lodash');
+            expect(mockGetRegistryVersion).toHaveBeenCalledWith('jest');
+            // Should display scanning message
+            expect(consoleSpy).toHaveBeenCalledWith(expect.stringContaining('Checking 3 packages'));
+            // Should show free mode hint
+            expect(consoleSpy).toHaveBeenCalledWith(expect.stringContaining('Free mode'));
+        });
+        it('counts upgrade types correctly', async () => {
+            mockGetPackageJson.mockResolvedValue({
+                name: 'test-project',
+                version: '1.0.0',
+                dependencies: {
+                    'pkg-major': '1.0.0',
+                    'pkg-minor': '1.0.0',
+                    'pkg-patch': '1.0.0',
+                    'pkg-ok': '1.0.0',
+                },
+            });
+            mockGetRegistryVersion
+                .mockReturnValueOnce('2.0.0') // MAJOR
+                .mockReturnValueOnce('1.1.0') // MINOR
+                .mockReturnValueOnce('1.0.1') // PATCH
+                .mockReturnValueOnce('1.0.0'); // OK
+            await (0, check_1.checkCommand)({});
+            // Should display summary with correct counts
+            expect(consoleSpy).toHaveBeenCalledWith(expect.stringContaining('1 major'));
+            expect(consoleSpy).toHaveBeenCalledWith(expect.stringContaining('1 minor'));
+            expect(consoleSpy).toHaveBeenCalledWith(expect.stringContaining('1 patch'));
+        });
+    });
+    describe('deep scan mode', () => {
+        it('requires API key for deep scan', async () => {
+            mockHasApiKey.mockReturnValue(false);
+            await (0, check_1.checkCommand)({ deep: true });
+            expect(consoleSpy).toHaveBeenCalledWith(expect.stringContaining('Deep scan requires an API key'));
+        });
+    });
+    describe('error handling', () => {
+        it('handles npm registry errors gracefully', async () => {
+            mockGetPackageJson.mockResolvedValue({
+                name: 'test-project',
+                version: '1.0.0',
+                dependencies: {
+                    'nonexistent-package': '1.0.0',
+                },
+            });
+            mockGetRegistryVersion.mockReturnValue('Unknown');
+            await (0, check_1.checkCommand)({});
+            // Should not throw, should display result
+            expect(mockGetRegistryVersion).toHaveBeenCalledWith('nonexistent-package');
+        });
+    });
+});
+describe('getUpgradeType edge cases', () => {
+    it('handles zero versions', () => {
+        expect((0, check_1.getUpgradeType)('0.1.0', '1.0.0')).toBe('MAJOR');
+        expect((0, check_1.getUpgradeType)('0.0.1', '0.1.0')).toBe('MINOR');
+        expect((0, check_1.getUpgradeType)('0.0.1', '0.0.2')).toBe('PATCH');
+    });
+    it('handles prerelease versions', () => {
+        // Prerelease tags are stripped, major/minor detection still works
+        expect((0, check_1.getUpgradeType)('1.0.0-alpha', '2.0.0')).toBe('MAJOR');
+        expect((0, check_1.getUpgradeType)('1.0.0-beta', '1.1.0')).toBe('MINOR');
+    });
+    it('handles versions with v prefix', () => {
+        expect((0, check_1.getUpgradeType)('v1.0.0', '2.0.0')).toBe('MAJOR');
+    });
+});

package/dist/src/commands/check.js

@@ -144,6 +144,41 @@ async function checkCommand(options = {}) {
     else if ((0, npm_1.isUsingCloudApi)()) {
         console.log(chalk_1.default.gray('\n  ☁️  Connected to Linchpin cloud.'));
     }
+    // Sync scan results to cloud if logged in
+    if ((0, npm_1.isUsingCloudApi)()) {
+        const scanResults = packageData.map(({ name, current, latest }) => {
+            const upgradeType = getUpgradeType(current, latest);
+            const riskLevel = upgradeType === 'MAJOR' ? 'critical' : upgradeType === 'MINOR' ? 'warning' : 'safe';
+            const risk = riskMap.get(name);
+            return {
+                name,
+                current,
+                latest,
+                riskLevel,
+                reason: risk?.risk || '',
+                aiRisk: risk?.risk,
+                safeVersion: risk?.safeVersion,
+            };
+        });
+        const total = packageData.length;
+        const safeCount = total - majorCount - minorCount - patchCount;
+        const healthScore = total > 0
+            ? Math.round(((safeCount * 100) + (patchCount * 80) + (minorCount * 50) + (majorCount * 0)) / total)
+            : 100;
+        // Fire and forget - don't block CLI output
+        (0, npm_1.apiRequest)('/api/cli/scan', {
+            healthScore,
+            packagesCount: total,
+            criticalCount: majorCount,
+            warningCount: minorCount,
+            scanResults,
+            deepAnalysis: isDeep,
+        }).then(result => {
+            if (result.error && process.env.DEBUG) {
+                console.error('Failed to sync scan:', result.error);
+            }
+        });
+    }
     // Action hints
     console.log(chalk_1.default.gray('\n  💡 Actions:'));
     if (!isDeep && useAI) {

package/dist/src/commands/login.js

@@ -41,6 +41,7 @@ exports.logoutCommand = logoutCommand;
 exports.whoamiCommand = whoamiCommand;
 const chalk_1 = __importDefault(require("chalk"));
 const auth_1 = require("../lib/auth");
+const sentry_1 = require("../lib/sentry");
 const API_BASE = process.env.LINCHPIN_API_URL || 'https://getlinchpin.dev';
 // Open URL in browser (cross-platform)
 function openBrowser(url) {
@@ -144,6 +145,9 @@ async function loginCommand() {
     // Step 4: Save credentials
     try {
         (0, auth_1.saveCredentials)(token);
+        // Set user in Sentry for error tracking (using token hash for anonymity)
+        const userHash = token.substring(0, 16);
+        (0, sentry_1.setUser)({ id: userHash });
         console.log(chalk_1.default.green.bold('  ✓ Successfully logged in!\n'));
         console.log(chalk_1.default.gray(`  Credentials saved to: ${(0, auth_1.getCredentialsPath)()}`));
         console.log(chalk_1.default.gray('  You can now use AI-powered features.\n'));
@@ -157,6 +161,8 @@ async function logoutCommand() {
     const { clearCredentials } = await Promise.resolve().then(() => __importStar(require('../lib/auth')));
     const hadCredentials = (0, auth_1.loadCredentials)() !== null;
     clearCredentials();
+    // Clear user from Sentry
+    (0, sentry_1.clearUser)();
     if (hadCredentials) {
         console.log(chalk_1.default.green('\n  ✓ Successfully logged out.\n'));
     }

package/dist/src/commands/plan.js

@@ -0,0 +1,152 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.planCommand = planCommand;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const child_process_1 = require("child_process");
+const readline_1 = __importDefault(require("readline"));
+const logger_1 = require("../utils/logger");
+// Console helpers
+const log = (msg) => console.log(msg);
+const highlight = (msg) => console.log(`\x1b[36m${msg}\x1b[0m`);
+const { info, success, error } = logger_1.logger;
+const warning = logger_1.logger.warn;
+function askQuestion(query) {
+    const rl = readline_1.default.createInterface({
+        input: process.stdin,
+        output: process.stdout,
+    });
+    return new Promise((resolve) => {
+        rl.question(query, (answer) => {
+            rl.close();
+            resolve(answer.trim().toLowerCase());
+        });
+    });
+}
+async function planCommand(filePath, options) {
+    // Resolve file path
+    const resolvedPath = path_1.default.resolve(process.cwd(), filePath);
+    // Check if file exists
+    if (!fs_1.default.existsSync(resolvedPath)) {
+        error(`Plan file not found: ${resolvedPath}`);
+        process.exit(1);
+    }
+    // Read and parse plan
+    let plan;
+    try {
+        const content = fs_1.default.readFileSync(resolvedPath, 'utf-8');
+        plan = JSON.parse(content);
+    }
+    catch (err) {
+        error(`Failed to parse plan file: ${err}`);
+        process.exit(1);
+    }
+    // Validate plan structure
+    if (!plan.steps || !Array.isArray(plan.steps) || plan.steps.length === 0) {
+        error('Invalid plan file: no steps found');
+        process.exit(1);
+    }
+    log('');
+    highlight('='.repeat(50));
+    highlight('  LINCHPIN UPGRADE PLAN');
+    highlight('='.repeat(50));
+    log('');
+    if (plan.created) {
+        info(`Plan created: ${new Date(plan.created).toLocaleString()}`);
+    }
+    info(`Total steps: ${plan.steps.length}`);
+    log('');
+    // Show warnings
+    if (plan.warnings && plan.warnings.length > 0) {
+        warning('Warnings:');
+        plan.warnings.forEach((w) => {
+            log(`  - ${w}`);
+        });
+        log('');
+    }
+    // Show steps
+    log('Steps:');
+    plan.steps.forEach((step) => {
+        log(`  ${step.order}. ${step.group}`);
+        log(`     Packages: ${step.packages.join(', ')}`);
+        log(`     Note: ${step.note}`);
+        log(`     Command: ${step.command}`);
+        log('');
+    });
+    if (options.dryRun) {
+        info('Dry run mode - no changes will be made');
+        return;
+    }
+    // Confirm unless --yes flag
+    if (!options.yes) {
+        const answer = await askQuestion('Execute this plan? (y/n): ');
+        if (answer !== 'y' && answer !== 'yes') {
+            info('Plan execution cancelled');
+            return;
+        }
+    }
+    log('');
+    highlight('Executing plan...');
+    log('');
+    // Create backup of package.json and package-lock.json
+    const backupDir = path_1.default.join(process.cwd(), '.linchpin-backup');
+    if (!fs_1.default.existsSync(backupDir)) {
+        fs_1.default.mkdirSync(backupDir);
+    }
+    const timestamp = new Date().toISOString().replace(/[:.]/g, '-');
+    const pkgJsonPath = path_1.default.join(process.cwd(), 'package.json');
+    const lockPath = path_1.default.join(process.cwd(), 'package-lock.json');
+    if (fs_1.default.existsSync(pkgJsonPath)) {
+        fs_1.default.copyFileSync(pkgJsonPath, path_1.default.join(backupDir, `package.json.${timestamp}`));
+    }
+    if (fs_1.default.existsSync(lockPath)) {
+        fs_1.default.copyFileSync(lockPath, path_1.default.join(backupDir, `package-lock.json.${timestamp}`));
+    }
+    success('Backup created in .linchpin-backup/');
+    log('');
+    // Execute each step
+    let completed = 0;
+    let failed = 0;
+    for (const step of plan.steps) {
+        log(`Step ${step.order}: ${step.group}`);
+        info(`Running: ${step.command}`);
+        try {
+            (0, child_process_1.execSync)(step.command, {
+                cwd: process.cwd(),
+                stdio: 'inherit',
+            });
+            success(`Step ${step.order} completed`);
+            completed++;
+        }
+        catch (err) {
+            error(`Step ${step.order} failed: ${err}`);
+            failed++;
+            // Ask if user wants to continue
+            if (!options.yes) {
+                const answer = await askQuestion('Continue with remaining steps? (y/n): ');
+                if (answer !== 'y' && answer !== 'yes') {
+                    info('Plan execution stopped');
+                    break;
+                }
+            }
+        }
+        log('');
+    }
+    // Summary
+    log('');
+    highlight('='.repeat(50));
+    highlight('  PLAN EXECUTION COMPLETE');
+    highlight('='.repeat(50));
+    log('');
+    success(`Completed: ${completed}/${plan.steps.length} steps`);
+    if (failed > 0) {
+        warning(`Failed: ${failed} step(s)`);
+    }
+    log('');
+    info('Backup files are in .linchpin-backup/');
+    info('Run "npm test" to verify your app still works!');
+    log('');
+}

package/dist/src/lib/sentry.js

@@ -0,0 +1,116 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.initSentry = initSentry;
+exports.captureException = captureException;
+exports.captureMessage = captureMessage;
+exports.setUser = setUser;
+exports.clearUser = clearUser;
+exports.flush = flush;
+const Sentry = __importStar(require("@sentry/node"));
+const SENTRY_DSN = process.env.SENTRY_DSN || 'https://9cf669968b5daf7a525d9e8a4dd66ee7@o4510643901956096.ingest.us.sentry.io/4510687506333696';
+// Version is passed in to avoid path issues after compilation
+let isInitialized = false;
+let cliVersion = '0.0.0';
+function initSentry(version) {
+    // Skip if already initialized
+    if (isInitialized) {
+        return;
+    }
+    if (version) {
+        cliVersion = version;
+    }
+    Sentry.init({
+        dsn: SENTRY_DSN,
+        environment: process.env.NODE_ENV || 'production',
+        release: `linchpin-cli@${cliVersion}`,
+        // Only send errors, not transactions (keeps it lightweight)
+        tracesSampleRate: 0,
+        // Filter out sensitive data
+        beforeSend(event) {
+            // Remove any file paths that might contain user info
+            if (event.exception?.values) {
+                event.exception.values.forEach((exception) => {
+                    if (exception.stacktrace?.frames) {
+                        exception.stacktrace.frames.forEach((frame) => {
+                            // Normalize paths to hide user directories
+                            if (frame.filename) {
+                                frame.filename = frame.filename.replace(/^.*[\\\/]node_modules/, 'node_modules');
+                            }
+                        });
+                    }
+                });
+            }
+            return event;
+        },
+    });
+    isInitialized = true;
+}
+function captureException(error, context) {
+    if (!isInitialized) {
+        return;
+    }
+    Sentry.withScope((scope) => {
+        if (context) {
+            scope.setExtras(context);
+        }
+        Sentry.captureException(error);
+    });
+}
+function captureMessage(message, level = 'info') {
+    if (!isInitialized) {
+        return;
+    }
+    Sentry.captureMessage(message, level);
+}
+function setUser(user) {
+    if (!isInitialized) {
+        return;
+    }
+    Sentry.setUser(user);
+}
+function clearUser() {
+    if (!isInitialized) {
+        return;
+    }
+    Sentry.setUser(null);
+}
+// Flush events before process exits
+async function flush(timeout = 2000) {
+    if (!isInitialized) {
+        return true;
+    }
+    return Sentry.flush(timeout);
+}

package/dist/src/utils/logger.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.logger = void 0;
+const sentry_1 = require("../lib/sentry");
 // ANSI color codes for terminal output
 const colors = {
     reset: '\x1b[0m',
@@ -21,9 +22,16 @@ exports.logger = {
     },
     warn: (message) => {
         console.log(`${colors.yellow}[WARN]${colors.reset} ${message}`);
+        (0, sentry_1.captureMessage)(message, 'warning');
     },
-    error: (message) => {
+    error: (message, error) => {
         console.log(`${colors.red}[ERROR]${colors.reset} ${message}`);
+        if (error) {
+            (0, sentry_1.captureException)(error, { message });
+        }
+        else {
+            (0, sentry_1.captureMessage)(message, 'error');
+        }
     },
     debug: (message) => {
         if (process.env.DEBUG) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "linchpin-cli",
-  "version": "0.2.0",
+  "version": "0.2.2",
   "description": "Linchpin: The 'Don't Break My App' Tool - AI-powered dependency management for solo founders",
   "main": "dist/src/index.js",
   "bin": {
@@ -39,6 +39,7 @@
     "node": ">=16.0.0"
   },
   "dependencies": {
+    "@sentry/node": "^10.32.1",
     "chalk": "^4.1.2",
     "cli-table3": "^0.6.5",
     "commander": "^11.1.0",