spck 0.3.1

package/dist/setup/wizard.js

@@ -0,0 +1,172 @@
+/**
+ * Interactive setup wizard for spck-cli
+ * Configures CLI to connect to proxy server
+ */
+import * as readline from 'readline';
+import { saveConfig, createDefaultConfig } from '../config/config.js';
+import { ensureProjectDir } from '../utils/project-dir.js';
+import { gitignoreExists, isSpckEditorIgnored, addSpckEditorToGitignore } from '../utils/gitignore.js';
+import { t } from '../i18n/index.js';
+const USER_AUTH_DOCS_URL = 'https://spck.io/docs/cli#user-authentication';
+/**
+ * Create readline interface
+ */
+function createPrompt() {
+    return readline.createInterface({
+        input: process.stdin,
+        output: process.stdout,
+    });
+}
+/**
+ * Prompt user for input
+ */
+function question(rl, query) {
+    return new Promise((resolve) => {
+        rl.question(query, (answer) => {
+            resolve(answer);
+        });
+    });
+}
+/**
+ * Ask yes/no question
+ */
+async function questionYesNo(rl, query, defaultValue) {
+    const answer = await question(rl, query);
+    const normalized = answer.trim().toLowerCase();
+    if (normalized === '') {
+        return defaultValue;
+    }
+    return normalized === 'y' || normalized === 'yes';
+}
+/**
+ * Run the setup wizard
+ */
+export async function runSetup(configPath) {
+    const rl = createPrompt();
+    console.log('\n' + '='.repeat(60));
+    console.log('     ' + t('setup.title'));
+    console.log('='.repeat(60) + '\n');
+    console.log(t('setup.description1'));
+    console.log(t('setup.description2'));
+    console.log(t('setup.description3') + '\n');
+    try {
+        // Step 1: Root directory
+        console.log('--- ' + t('setup.projectConfig') + ' ---\n');
+        const root = await question(rl, t('setup.rootDirPrompt', { default: process.cwd() }));
+        const rootPath = root.trim() || process.cwd();
+        // Step 1.5: Server name (for QR code identification)
+        const defaultConfig = createDefaultConfig();
+        // Step 2: Terminal service
+        console.log('\n--- ' + t('setup.terminalConfig') + ' ---\n');
+        console.log(t('setup.terminalDescription'));
+        const terminalEnabled = await questionYesNo(rl, t('setup.terminalPrompt'), true);
+        let maxBufferedLines = 5000;
+        let maxTerminals = 10;
+        // Step 4: Advanced terminal configuration
+        if (terminalEnabled) {
+            const advancedTerminal = await questionYesNo(rl, '\n' + t('setup.advancedTerminalPrompt'), false);
+            if (advancedTerminal) {
+                console.log('');
+                const bufferInput = await question(rl, t('setup.maxBufferPrompt', { default: String(maxBufferedLines) }));
+                maxBufferedLines = parseInt(bufferInput) || 5000;
+                console.log('   ' + t('setup.maxBufferHint') + '\n');
+                const maxTermInput = await question(rl, t('setup.maxTerminalsPrompt', { default: String(maxTerminals) }));
+                maxTerminals = parseInt(maxTermInput) || 10;
+            }
+        }
+        // Step 5: Browser proxy configuration
+        console.log('\n--- ' + t('setup.browserProxyConfig') + ' ---\n');
+        console.log(t('setup.browserProxyDescription') + '\n');
+        const browserProxyEnabled = await questionYesNo(rl, t('setup.browserProxyPrompt'), true);
+        // Step 6: Security configuration
+        console.log('\n--- ' + t('setup.securityConfig') + ' ---\n');
+        console.log(t('setup.securityDescription1'));
+        console.log(t('setup.securityDescription2'));
+        console.log(t('setup.securityDescription3'));
+        console.log(t('setup.securityDocsHint', { url: USER_AUTH_DOCS_URL }) + '\n');
+        const userAuthEnabled = await questionYesNo(rl, t('setup.securityPrompt'), false);
+        // Step 6: .gitignore configuration (advanced)
+        let shouldAddToGitignore = false;
+        if (gitignoreExists(rootPath)) {
+            if (!isSpckEditorIgnored(rootPath)) {
+                console.log('\n--- ' + t('setup.gitConfig') + ' ---\n');
+                console.log(t('setup.gitignoreDetected'));
+                console.log(t('setup.gitignoreRecommend1'));
+                console.log(t('setup.gitignoreRecommend2') + '\n');
+                shouldAddToGitignore = await questionYesNo(rl, t('setup.gitignorePrompt'), true);
+            }
+        }
+        rl.close();
+        // Create configuration
+        const config = {
+            version: 1,
+            root: rootPath,
+            name: defaultConfig.name,
+            terminal: {
+                enabled: terminalEnabled,
+                maxBufferedLines,
+                maxTerminals
+            },
+            security: {
+                userAuthenticationEnabled: userAuthEnabled
+            },
+            browserProxy: {
+                enabled: browserProxyEnabled
+            },
+            filesystem: {
+                maxFileSize: '10MB',
+                watchIgnorePatterns: [
+                    '**/.git/**',
+                    '**/.spck-editor/**',
+                    '**/node_modules/**',
+                    '**/*.log',
+                    '**/.DS_Store',
+                    '**/dist/**',
+                    '**/build/**'
+                ]
+            }
+        };
+        // Ensure project directory exists (creates symlink)
+        ensureProjectDir(config.root);
+        // Save configuration
+        saveConfig(config, configPath);
+        // Add to .gitignore if requested
+        if (shouldAddToGitignore) {
+            try {
+                addSpckEditorToGitignore(config.root);
+                console.log('\n✅ ' + t('setup.gitignoreAdded'));
+            }
+            catch (error) {
+                console.warn('\n⚠️  ' + t('setup.gitignoreFailed', { message: error.message }));
+                console.warn('   ' + t('setup.gitignoreManualHint'));
+            }
+        }
+        console.log('\n' + '='.repeat(60));
+        console.log('✅ ' + t('config.saved'));
+        console.log('='.repeat(60) + '\n');
+        displayConfigSummary(config);
+        return config;
+    }
+    catch (error) {
+        rl.close();
+        console.error('\n❌ ' + t('setup.setupFailed', { message: error.message }));
+        throw error;
+    }
+}
+/**
+ * Display configuration summary
+ */
+function displayConfigSummary(config) {
+    console.log(t('setup.configSummary'));
+    console.log('  ' + t('setup.summaryName', { name: config.name || t('setup.summaryNameNotSet') }));
+    console.log('  ' + t('setup.summaryRoot', { root: config.root }));
+    console.log('  ' + t('setup.summaryTerminal', { status: config.terminal.enabled ? t('setup.summaryEnabled') : t('setup.summaryDisabled') }));
+    if (config.terminal.enabled) {
+        console.log('  ' + t('setup.summaryMaxBuffer', { value: String(config.terminal.maxBufferedLines) }));
+        console.log('  ' + t('setup.summaryMaxProcesses', { value: String(config.terminal.maxTerminals) }));
+    }
+    console.log('  ' + t('setup.summaryUserAuth', { status: config.security.userAuthenticationEnabled ? t('setup.summaryEnabled') : t('setup.summaryDisabled') }));
+    console.log('  ' + t('setup.summaryBrowserProxy', { status: config.browserProxy?.enabled !== false ? t('setup.summaryEnabled') : t('setup.summaryDisabled') }));
+    console.log('');
+}
+//# sourceMappingURL=wizard.js.map

package/dist/types.d.ts

@@ -0,0 +1,196 @@
+/**
+ * Core type definitions for spck-cli server
+ */
+export interface SocketInterface {
+    id: string;
+    emit(event: string, data?: any): boolean;
+    on(event: string, listener: (...args: any[]) => void): this;
+    off(event: string, listener: (...args: any[]) => void): this;
+    broadcast: {
+        emit(event: string, data?: any): boolean;
+    };
+    data: {
+        uid: string;
+        deviceId: string;
+    };
+}
+export interface ServerConfig {
+    version: number;
+    root: string;
+    name?: string;
+    terminal: {
+        enabled: boolean;
+        maxBufferedLines: number;
+        maxTerminals: number;
+    };
+    security: {
+        userAuthenticationEnabled: boolean;
+    };
+    filesystem: {
+        maxFileSize: string;
+        watchIgnorePatterns: string[];
+    };
+    browserProxy?: {
+        enabled: boolean;
+    };
+}
+export interface ConnectionSettings {
+    serverToken: string;
+    serverTokenExpiry: number;
+    clientId: string;
+    secret: string;
+    userId: string;
+    connectedAt: number;
+}
+export interface StoredCredentials {
+    refreshToken: string;
+    userId: string;
+    proxyServerUrl?: string;
+}
+export interface GlobalConfig {
+    knownDeviceIds: string[];
+}
+export interface FirebaseCredentials {
+    firebaseToken: string;
+    firebaseTokenExpiry: number;
+    refreshToken: string;
+    userId: string;
+}
+export interface JSONRPCRequest {
+    jsonrpc: '2.0';
+    method: string;
+    params?: any;
+    id?: number | string;
+    timestamp?: number;
+    hmac: string;
+    nonce: string;
+}
+export interface JSONRPCResponse {
+    jsonrpc: '2.0';
+    result?: any;
+    error?: JSONRPCError;
+    id: number | string | null;
+}
+export interface JSONRPCError {
+    code: number;
+    message: string;
+    data?: any;
+}
+export interface JSONRPCNotification {
+    jsonrpc: '2.0';
+    method: string;
+    params?: any;
+}
+export interface JWTPayload {
+    aud: string;
+    iat: number;
+    exp: number;
+    iss: string;
+    sub: string;
+    [key: string]: any;
+}
+export interface AuthenticatedSocket extends SocketInterface {
+}
+export declare enum ErrorCode {
+    PARSE_ERROR = -32700,
+    INVALID_REQUEST = -32600,
+    METHOD_NOT_FOUND = -32601,
+    INVALID_PARAMS = -32602,
+    INTERNAL_ERROR = -32603,
+    AUTHENTICATION_FAILED = -32001,
+    JWT_EXPIRED = -32002,
+    HMAC_VALIDATION_FAILED = -32003,
+    PERMISSION_DENIED = -32005,
+    FILE_NOT_FOUND = -32004,
+    WRITE_CONFLICT = -32006,
+    INVALID_PATH = -32007,
+    FILE_TOO_LARGE = -32031,
+    INVALID_ENCODING = -32032,
+    DELTA_PATCH_FAILED = -32033,
+    GIT_OPERATION_FAILED = -32010,
+    INVALID_OID = -32011,
+    REPOSITORY_NOT_FOUND = -32012,
+    TERMINAL_NOT_FOUND = -32020,
+    TERMINAL_LIMIT_EXCEEDED = -32021,
+    TERMINAL_PROCESS_EXITED = -32022,
+    BROWSER_PROXY_REQUEST_FAILED = -32050,
+    OPERATION_TIMEOUT = -32030,
+    UID_NOT_AUTHORIZED = -32040,
+    FEATURE_DISABLED = -32041
+}
+export declare function createRPCError(code: ErrorCode, message: string, data?: any): JSONRPCError;
+export type HandshakeMessageType = 'auth' | 'auth_result' | 'request_user_verification' | 'user_verification' | 'protocol_info' | 'protocol_selected' | 'connected';
+export interface ClientAuthMessage {
+    type: 'auth';
+    jwt: string;
+}
+export interface AuthResultMessage {
+    type: 'auth_result';
+    success: boolean;
+    error?: string;
+}
+export interface UserVerificationRequestMessage {
+    type: 'request_user_verification';
+    message: string;
+}
+export interface UserVerificationMessage {
+    type: 'user_verification';
+    firebaseToken: string;
+}
+export interface ProtocolInfoMessage {
+    type: 'protocol_info';
+    minVersion: number;
+    maxVersion: number;
+    features: {
+        terminal: boolean;
+        git: boolean;
+        fastSearch: boolean;
+    };
+}
+export interface ProtocolSelectedMessage {
+    type: 'protocol_selected';
+    version: number;
+    ready: boolean;
+}
+export interface ConnectedMessage {
+    type: 'connected';
+    message: string;
+}
+export type HandshakeMessage = ClientAuthMessage | AuthResultMessage | UserVerificationRequestMessage | UserVerificationMessage | ProtocolInfoMessage | ProtocolSelectedMessage | ConnectedMessage;
+export interface FreeTierInfo {
+    dailyLimitSeconds: number;
+    usedSeconds: number;
+}
+export interface ProxyAuthenticatedEvent {
+    token: string;
+    clientId: string;
+    userId: string;
+    expiresAt: number;
+    freeTierInfo?: FreeTierInfo | null;
+}
+export interface ProxyClientConnectingEvent {
+    connectionId: string;
+}
+export interface ProxyMultipleConnectionEvent {
+    existingConnections: string[];
+    newConnectionId: string;
+}
+export interface ProxyClientMessageEvent {
+    connectionId: string;
+    data: any;
+}
+export interface ProxyClientDisconnectedEvent {
+    connectionId: string;
+    reason?: string;
+    resetTime?: number;
+}
+export interface ProxyErrorEvent {
+    code: string;
+    message: string;
+    [key: string]: any;
+}
+export interface ToolDetectionResult {
+    git: boolean;
+    ripgrep: boolean;
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/types.js

@@ -0,0 +1,44 @@
+/**
+ * Core type definitions for spck-cli server
+ */
+// Error codes (JSON-RPC 2.0 + custom)
+export var ErrorCode;
+(function (ErrorCode) {
+    // Standard JSON-RPC 2.0
+    ErrorCode[ErrorCode["PARSE_ERROR"] = -32700] = "PARSE_ERROR";
+    ErrorCode[ErrorCode["INVALID_REQUEST"] = -32600] = "INVALID_REQUEST";
+    ErrorCode[ErrorCode["METHOD_NOT_FOUND"] = -32601] = "METHOD_NOT_FOUND";
+    ErrorCode[ErrorCode["INVALID_PARAMS"] = -32602] = "INVALID_PARAMS";
+    ErrorCode[ErrorCode["INTERNAL_ERROR"] = -32603] = "INTERNAL_ERROR";
+    // Authentication & Security
+    ErrorCode[ErrorCode["AUTHENTICATION_FAILED"] = -32001] = "AUTHENTICATION_FAILED";
+    ErrorCode[ErrorCode["JWT_EXPIRED"] = -32002] = "JWT_EXPIRED";
+    ErrorCode[ErrorCode["HMAC_VALIDATION_FAILED"] = -32003] = "HMAC_VALIDATION_FAILED";
+    ErrorCode[ErrorCode["PERMISSION_DENIED"] = -32005] = "PERMISSION_DENIED";
+    // Filesystem
+    ErrorCode[ErrorCode["FILE_NOT_FOUND"] = -32004] = "FILE_NOT_FOUND";
+    ErrorCode[ErrorCode["WRITE_CONFLICT"] = -32006] = "WRITE_CONFLICT";
+    ErrorCode[ErrorCode["INVALID_PATH"] = -32007] = "INVALID_PATH";
+    ErrorCode[ErrorCode["FILE_TOO_LARGE"] = -32031] = "FILE_TOO_LARGE";
+    ErrorCode[ErrorCode["INVALID_ENCODING"] = -32032] = "INVALID_ENCODING";
+    ErrorCode[ErrorCode["DELTA_PATCH_FAILED"] = -32033] = "DELTA_PATCH_FAILED";
+    // Git
+    ErrorCode[ErrorCode["GIT_OPERATION_FAILED"] = -32010] = "GIT_OPERATION_FAILED";
+    ErrorCode[ErrorCode["INVALID_OID"] = -32011] = "INVALID_OID";
+    ErrorCode[ErrorCode["REPOSITORY_NOT_FOUND"] = -32012] = "REPOSITORY_NOT_FOUND";
+    // Terminal
+    ErrorCode[ErrorCode["TERMINAL_NOT_FOUND"] = -32020] = "TERMINAL_NOT_FOUND";
+    ErrorCode[ErrorCode["TERMINAL_LIMIT_EXCEEDED"] = -32021] = "TERMINAL_LIMIT_EXCEEDED";
+    ErrorCode[ErrorCode["TERMINAL_PROCESS_EXITED"] = -32022] = "TERMINAL_PROCESS_EXITED";
+    // Browser Proxy
+    ErrorCode[ErrorCode["BROWSER_PROXY_REQUEST_FAILED"] = -32050] = "BROWSER_PROXY_REQUEST_FAILED";
+    // General
+    ErrorCode[ErrorCode["OPERATION_TIMEOUT"] = -32030] = "OPERATION_TIMEOUT";
+    ErrorCode[ErrorCode["UID_NOT_AUTHORIZED"] = -32040] = "UID_NOT_AUTHORIZED";
+    ErrorCode[ErrorCode["FEATURE_DISABLED"] = -32041] = "FEATURE_DISABLED";
+})(ErrorCode || (ErrorCode = {}));
+// Helper to create JSON-RPC error
+export function createRPCError(code, message, data) {
+    return { code, message, data };
+}
+//# sourceMappingURL=types.js.map

package/dist/utils/__tests__/gitignore.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=gitignore.test.d.ts.map

package/dist/utils/__tests__/gitignore.test.js

@@ -0,0 +1,127 @@
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+/**
+ * Tests for .gitignore utilities
+ */
+import * as fs from 'fs';
+import * as path from 'path';
+import * as os from 'os';
+import { gitignoreExists, isSpckEditorIgnored, addSpckEditorToGitignore, getGitignorePath, } from '../gitignore';
+describe('gitignore utilities', () => {
+    let tempDir;
+    beforeEach(() => {
+        // Create a temporary directory for each test
+        tempDir = fs.mkdtempSync(path.join(os.tmpdir(), 'spck-gitignore-test-'));
+    });
+    afterEach(() => {
+        // Clean up temporary directory
+        if (fs.existsSync(tempDir)) {
+            fs.rmSync(tempDir, { recursive: true, force: true });
+        }
+    });
+    describe('gitignoreExists', () => {
+        it('should return false when .gitignore does not exist', () => {
+            expect(gitignoreExists(tempDir)).toBe(false);
+        });
+        it('should return true when .gitignore exists', () => {
+            const gitignorePath = path.join(tempDir, '.gitignore');
+            fs.writeFileSync(gitignorePath, 'node_modules/\n', 'utf8');
+            expect(gitignoreExists(tempDir)).toBe(true);
+        });
+    });
+    describe('isSpckEditorIgnored', () => {
+        it('should return false when .gitignore does not exist', () => {
+            expect(isSpckEditorIgnored(tempDir)).toBe(false);
+        });
+        it('should return false when .spck-editor/ is not in .gitignore', () => {
+            const gitignorePath = path.join(tempDir, '.gitignore');
+            fs.writeFileSync(gitignorePath, 'node_modules/\ndist/\n', 'utf8');
+            expect(isSpckEditorIgnored(tempDir)).toBe(false);
+        });
+        it('should return true when .spck-editor/ is in .gitignore', () => {
+            const gitignorePath = path.join(tempDir, '.gitignore');
+            fs.writeFileSync(gitignorePath, 'node_modules/\n.spck-editor/\ndist/\n', 'utf8');
+            expect(isSpckEditorIgnored(tempDir)).toBe(true);
+        });
+        it('should return false when only .spck-editor (without slash) is in .gitignore', () => {
+            const gitignorePath = path.join(tempDir, '.gitignore');
+            fs.writeFileSync(gitignorePath, 'node_modules/\n.spck-editor\ndist/\n', 'utf8');
+            expect(isSpckEditorIgnored(tempDir)).toBe(false);
+        });
+        it('should ignore comments in .gitignore', () => {
+            const gitignorePath = path.join(tempDir, '.gitignore');
+            fs.writeFileSync(gitignorePath, '# This is a comment\nnode_modules/\n# .spck-editor/\ndist/\n', 'utf8');
+            expect(isSpckEditorIgnored(tempDir)).toBe(false);
+        });
+        it('should ignore empty lines in .gitignore', () => {
+            const gitignorePath = path.join(tempDir, '.gitignore');
+            fs.writeFileSync(gitignorePath, 'node_modules/\n\n\ndist/\n', 'utf8');
+            expect(isSpckEditorIgnored(tempDir)).toBe(false);
+        });
+        it('should handle .gitignore with only whitespace lines', () => {
+            const gitignorePath = path.join(tempDir, '.gitignore');
+            fs.writeFileSync(gitignorePath, '   \n\t\n\n', 'utf8');
+            expect(isSpckEditorIgnored(tempDir)).toBe(false);
+        });
+    });
+    describe('addSpckEditorToGitignore', () => {
+        it('should create .gitignore with .spck-editor/ when file does not exist', () => {
+            addSpckEditorToGitignore(tempDir);
+            const gitignorePath = path.join(tempDir, '.gitignore');
+            expect(fs.existsSync(gitignorePath)).toBe(true);
+            const content = fs.readFileSync(gitignorePath, 'utf8');
+            expect(content).toContain('.spck-editor/');
+            expect(content).toContain('# Spck CLI project data');
+        });
+        it('should append .spck-editor/ to existing .gitignore', () => {
+            const gitignorePath = path.join(tempDir, '.gitignore');
+            fs.writeFileSync(gitignorePath, 'node_modules/\ndist/\n', 'utf8');
+            addSpckEditorToGitignore(tempDir);
+            const content = fs.readFileSync(gitignorePath, 'utf8');
+            expect(content).toContain('node_modules/');
+            expect(content).toContain('dist/');
+            expect(content).toContain('.spck-editor/');
+            expect(content).toContain('# Spck CLI project data');
+        });
+        it('should add newline before comment if .gitignore does not end with newline', () => {
+            const gitignorePath = path.join(tempDir, '.gitignore');
+            fs.writeFileSync(gitignorePath, 'node_modules/', 'utf8'); // No trailing newline
+            addSpckEditorToGitignore(tempDir);
+            const content = fs.readFileSync(gitignorePath, 'utf8');
+            expect(content).toBe('node_modules/\n\n# Spck CLI project data\n.spck-editor/\n');
+        });
+        it('should not add .spck-editor/ if already present', () => {
+            const gitignorePath = path.join(tempDir, '.gitignore');
+            const initialContent = 'node_modules/\n.spck-editor/\ndist/\n';
+            fs.writeFileSync(gitignorePath, initialContent, 'utf8');
+            addSpckEditorToGitignore(tempDir);
+            const content = fs.readFileSync(gitignorePath, 'utf8');
+            // Content should be unchanged
+            expect(content).toBe(initialContent);
+        });
+        it('should add .spck-editor/ even if .spck-editor (without slash) is present', () => {
+            const gitignorePath = path.join(tempDir, '.gitignore');
+            const initialContent = 'node_modules/\n.spck-editor\ndist/\n';
+            fs.writeFileSync(gitignorePath, initialContent, 'utf8');
+            addSpckEditorToGitignore(tempDir);
+            const content = fs.readFileSync(gitignorePath, 'utf8');
+            // Should add the pattern since .spck-editor (without slash) is different from .spck-editor/
+            expect(content).toContain('.spck-editor/');
+            expect(content).toContain('# Spck CLI project data');
+        });
+        it('should handle empty .gitignore file', () => {
+            const gitignorePath = path.join(tempDir, '.gitignore');
+            fs.writeFileSync(gitignorePath, '', 'utf8');
+            addSpckEditorToGitignore(tempDir);
+            const content = fs.readFileSync(gitignorePath, 'utf8');
+            expect(content).toContain('.spck-editor/');
+            expect(content).toContain('# Spck CLI project data');
+        });
+    });
+    describe('getGitignorePath', () => {
+        it('should return correct .gitignore path', () => {
+            const expected = path.join(tempDir, '.gitignore');
+            expect(getGitignorePath(tempDir)).toBe(expected);
+        });
+    });
+});
+//# sourceMappingURL=gitignore.test.js.map

package/dist/utils/gitignore.d.ts

@@ -0,0 +1,24 @@
+/**
+ * .gitignore file management utilities
+ * Handles checking and updating .gitignore files
+ */
+/**
+ * Check if .gitignore exists in a directory
+ */
+export declare function gitignoreExists(directory: string): boolean;
+/**
+ * Check if .gitignore contains the .spck-editor pattern
+ * Returns true if the pattern is found (exact match)
+ */
+export declare function isSpckEditorIgnored(directory: string): boolean;
+/**
+ * Add .spck-editor/ to .gitignore
+ * Creates .gitignore if it doesn't exist
+ * Appends the pattern if not already present
+ */
+export declare function addSpckEditorToGitignore(directory: string): void;
+/**
+ * Get the full path to .gitignore in a directory
+ */
+export declare function getGitignorePath(directory: string): string;
+//# sourceMappingURL=gitignore.d.ts.map

package/dist/utils/gitignore.js

@@ -0,0 +1,77 @@
+/**
+ * .gitignore file management utilities
+ * Handles checking and updating .gitignore files
+ */
+import * as fs from 'fs';
+import * as path from 'path';
+const DIR_PATTERN = '.spck-editor/';
+/**
+ * Check if .gitignore exists in a directory
+ */
+export function gitignoreExists(directory) {
+    const gitignorePath = path.join(directory, '.gitignore');
+    return fs.existsSync(gitignorePath);
+}
+/**
+ * Check if .gitignore contains the .spck-editor pattern
+ * Returns true if the pattern is found (exact match)
+ */
+export function isSpckEditorIgnored(directory) {
+    const gitignorePath = path.join(directory, '.gitignore');
+    if (!fs.existsSync(gitignorePath)) {
+        return false;
+    }
+    try {
+        const content = fs.readFileSync(gitignorePath, 'utf8');
+        const lines = content.split('\n');
+        // Check if any line contains .spck-editor/ (ignoring comments and whitespace)
+        for (const line of lines) {
+            const trimmed = line.trim();
+            // Skip empty lines and comments
+            if (trimmed === '' || trimmed.startsWith('#')) {
+                continue;
+            }
+            // Check if line matches the directory pattern
+            if (trimmed === DIR_PATTERN) {
+                return true;
+            }
+        }
+        return false;
+    }
+    catch (error) {
+        // If we can't read the file, assume it's not ignored
+        return false;
+    }
+}
+/**
+ * Add .spck-editor/ to .gitignore
+ * Creates .gitignore if it doesn't exist
+ * Appends the pattern if not already present
+ */
+export function addSpckEditorToGitignore(directory) {
+    const gitignorePath = path.join(directory, '.gitignore');
+    // Check if already ignored
+    if (isSpckEditorIgnored(directory)) {
+        return; // Already present, nothing to do
+    }
+    let content = '';
+    if (fs.existsSync(gitignorePath)) {
+        // Read existing content
+        content = fs.readFileSync(gitignorePath, 'utf8');
+        // Ensure content ends with newline
+        if (content.length > 0 && !content.endsWith('\n')) {
+            content += '\n';
+        }
+    }
+    // Add comment and pattern
+    const addition = `\n# Spck CLI project data\n${DIR_PATTERN}\n`;
+    // Write back to file
+    fs.writeFileSync(gitignorePath, content + addition, 'utf8');
+}
+/**
+ * Get the full path to .gitignore in a directory
+ */
+export function getGitignorePath(directory) {
+    return path.join(directory, '.gitignore');
+}
+//# sourceMappingURL=gitignore.js.map