npm - contextstore-app - Versions diffs - 1.0.0 - Mend

contextstore-app 1.0.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (17) hide show

package/dist/index.js ADDED Viewed

@@ -0,0 +1,874 @@
+#!/usr/bin/env node
+import { Command } from 'commander';
+import * as p from '@clack/prompts';
+import * as fs from 'fs';
+import * as path from 'path';
+import * as http from 'http';
+import { exec } from 'child_process';
+import { randomBytes } from 'crypto';
+import { loadConfig, saveConfig } from './config.js';
+import { detectProjects } from './detector.js';
+import { walkWorkspace } from './walker.js';
+import { detectProjectType } from './type-detector.js';
+import { syncFile } from './syncer.js';
+import { startWatcher } from './watcher.js';
+// Open the browser pointing to URL dynamically depending on the OS
+function openBrowser(url) {
+    const platform = process.platform;
+    let cmd = '';
+    if (platform === 'win32') {
+        // PowerShell handles ampersands and special characters in URLs beautifully.
+        cmd = `powershell -Command "Start-Process '${url}'"`;
+    }
+    else if (platform === 'darwin') {
+        cmd = `open "${url}"`;
+    }
+    else {
+        cmd = `xdg-open "${url}"`;
+    }
+    exec(cmd, (err) => {
+        if (err) {
+            // Fallback
+        }
+    });
+}
+function getSuccessHtml(email) {
+    const emailText = email ? `<div class="email">${email}</div>` : '';
+    return `
+<!DOCTYPE html>
+<html lang="en">
+<head>
+  <meta charset="UTF-8">
+  <meta name="viewport" content="width=device-width, initial-scale=1.0">
+  <title>Login Successful — ContextStore</title>
+  <link rel="preconnect" href="https://fonts.googleapis.com">
+  <link href="https://fonts.googleapis.com/css2?family=DM+Sans:wght@400;500;700&display=swap" rel="stylesheet">
+  <style>
+    :root {
+      --bg: #0c0a09;
+      --card-bg: rgba(28, 25, 23, 0.6);
+      --amber: #f59e0b;
+      --amber-glowing: rgba(245, 158, 11, 0.15);
+      --green: #10b981;
+      --green-glowing: rgba(16, 185, 129, 0.2);
+      --text: #fafaf9;
+      --text-muted: #a8a29e;
+      --border: rgba(120, 113, 108, 0.2);
+    }
+    * { box-sizing: border-box; margin: 0; padding: 0; }
+    body {
+      background: var(--bg);
+      background-image: radial-gradient(circle at 50% -20%, #78350f 0%, #0c0a09 70%);
+      color: var(--text);
+      font-family: 'DM Sans', sans-serif;
+      min-height: 100vh;
+      display: flex;
+      align-items: center;
+      justify-content: center;
+      padding: 24px;
+      overflow: hidden;
+    }
+    .card {
+      background: var(--card-bg);
+      backdrop-filter: blur(16px);
+      border: 1px solid var(--border);
+      border-radius: 24px;
+      width: 100%;
+      max-width: 440px;
+      padding: 48px 40px;
+      text-align: center;
+      box-shadow: 0 25px 50px -12px rgba(0, 0, 0, 0.5);
+      animation: slideUp 0.6s cubic-bezier(0.16, 1, 0.3, 1) forwards;
+    }
+    @keyframes slideUp {
+      from { opacity: 0; transform: translateY(30px); }
+      to { opacity: 1; transform: translateY(0); }
+    }
+    .logo {
+      font-weight: 700;
+      font-size: 24px;
+      letter-spacing: -0.04em;
+      margin-bottom: 32px;
+    }
+    .logo span { color: var(--amber); }
+    .success-icon {
+      width: 80px;
+      height: 80px;
+      background: var(--green-glowing);
+      border: 2px solid var(--green);
+      border-radius: 50%;
+      display: flex;
+      align-items: center;
+      justify-content: center;
+      margin: 0 auto 24px;
+      animation: pulse 2s infinite;
+    }
+    @keyframes pulse {
+      0% { box-shadow: 0 0 0 0 rgba(16, 185, 129, 0.4); }
+      70% { box-shadow: 0 0 0 16px rgba(16, 185, 129, 0); }
+      100% { box-shadow: 0 0 0 0 rgba(16, 185, 129, 0); }
+    }
+    .success-icon svg {
+      width: 36px;
+      height: 36px;
+      color: var(--green);
+      stroke-dasharray: 100;
+      stroke-dashoffset: 100;
+      animation: drawCheck 0.6s 0.3s cubic-bezier(0.16, 1, 0.3, 1) forwards;
+    }
+    @keyframes drawCheck {
+      to { stroke-dashoffset: 0; }
+    }
+    h1 {
+      font-size: 24px;
+      font-weight: 700;
+      margin-bottom: 12px;
+      letter-spacing: -0.02em;
+    }
+    p {
+      color: var(--text-muted);
+      font-size: 15px;
+      line-height: 1.6;
+      margin-bottom: 24px;
+    }
+    .email {
+      background: rgba(255, 255, 255, 0.04);
+      border: 1px solid var(--border);
+      border-radius: 8px;
+      padding: 8px 16px;
+      display: inline-block;
+      font-size: 14px;
+      color: var(--amber);
+      font-weight: 500;
+      margin-bottom: 24px;
+    }
+    .footer {
+      border-top: 1px solid var(--border);
+      padding-top: 24px;
+      font-size: 13px;
+      color: var(--text-muted);
+    }
+  </style>
+</head>
+<body>
+  <div class="card">
+    <div class="logo">context<span>store</span></div>
+    <div class="success-icon">
+      <svg fill="none" viewBox="0 0 24 24" stroke="currentColor" stroke-width="3">
+        <path stroke-linecap="round" stroke-linejoin="round" d="M5 13l4 4L19 7" />
+      </svg>
+    </div>
+    <h1>Login Successful!</h1>
+    <p>You have successfully authenticated the CLI.</p>
+    ${emailText}
+    <div class="footer">
+      You can now close this tab and return to your terminal.
+    </div>
+  </div>
+</body>
+</html>
+  `;
+}
+function getErrorHtml(errorMessage) {
+    return `
+<!DOCTYPE html>
+<html lang="en">
+<head>
+  <meta charset="UTF-8">
+  <meta name="viewport" content="width=device-width, initial-scale=1.0">
+  <title>Login Failed — ContextStore</title>
+  <link rel="preconnect" href="https://fonts.googleapis.com">
+  <link href="https://fonts.googleapis.com/css2?family=DM+Sans:wght@400;500;700&display=swap" rel="stylesheet">
+  <style>
+    :root {
+      --bg: #0c0a09;
+      --card-bg: rgba(28, 25, 23, 0.6);
+      --amber: #f59e0b;
+      --red: #ef4444;
+      --red-glowing: rgba(239, 68, 68, 0.15);
+      --text: #fafaf9;
+      --text-muted: #a8a29e;
+      --border: rgba(120, 113, 108, 0.2);
+    }
+    * { box-sizing: border-box; margin: 0; padding: 0; }
+    body {
+      background: var(--bg);
+      background-image: radial-gradient(circle at 50% -20%, #7f1d1d 0%, #0c0a09 70%);
+      color: var(--text);
+      font-family: 'DM Sans', sans-serif;
+      min-height: 100vh;
+      display: flex;
+      align-items: center;
+      justify-content: center;
+      padding: 24px;
+      overflow: hidden;
+    }
+    .card {
+      background: var(--card-bg);
+      backdrop-filter: blur(16px);
+      border: 1px solid var(--border);
+      border-radius: 24px;
+      width: 100%;
+      max-width: 440px;
+      padding: 48px 40px;
+      text-align: center;
+      box-shadow: 0 25px 50px -12px rgba(0, 0, 0, 0.5);
+      animation: slideUp 0.6s cubic-bezier(0.16, 1, 0.3, 1) forwards;
+    }
+    @keyframes slideUp {
+      from { opacity: 0; transform: translateY(30px); }
+      to { opacity: 1; transform: translateY(0); }
+    }
+    .logo {
+      font-weight: 700;
+      font-size: 24px;
+      letter-spacing: -0.04em;
+      margin-bottom: 32px;
+    }
+    .logo span { color: var(--amber); }
+    .error-icon {
+      width: 80px;
+      height: 80px;
+      background: var(--red-glowing);
+      border: 2px solid var(--red);
+      border-radius: 50%;
+      display: flex;
+      align-items: center;
+      justify-content: center;
+      margin: 0 auto 24px;
+    }
+    .error-icon svg {
+      width: 36px;
+      height: 36px;
+      color: var(--red);
+    }
+    h1 {
+      font-size: 24px;
+      font-weight: 700;
+      margin-bottom: 12px;
+      letter-spacing: -0.02em;
+    }
+    p {
+      color: var(--text-muted);
+      font-size: 15px;
+      line-height: 1.6;
+      margin-bottom: 24px;
+    }
+    .err-msg {
+      background: rgba(239, 68, 68, 0.1);
+      border: 1px solid rgba(239, 68, 68, 0.2);
+      border-radius: 8px;
+      padding: 12px 16px;
+      font-size: 14px;
+      color: #fca5a5;
+      margin-bottom: 24px;
+      text-align: left;
+      font-family: monospace;
+      word-break: break-all;
+    }
+    .footer {
+      border-top: 1px solid var(--border);
+      padding-top: 24px;
+      font-size: 13px;
+      color: var(--text-muted);
+    }
+  </style>
+</head>
+<body>
+  <div class="card">
+    <div class="logo">context<span>store</span></div>
+    <div class="error-icon">
+      <svg fill="none" viewBox="0 0 24 24" stroke="currentColor" stroke-width="2.5">
+        <path stroke-linecap="round" stroke-linejoin="round" d="M6 18L18 6M6 6l12 12" />
+      </svg>
+    </div>
+    <h1>Authentication Failed</h1>
+    <p>Something went wrong during login verification.</p>
+    <div class="err-msg">${errorMessage}</div>
+    <div class="footer">
+      Please close this tab and try starting the login flow again in your terminal.
+    </div>
+  </div>
+</body>
+</html>
+  `;
+}
+// Start temporary local HTTP callback server and open browser for OAuth
+async function startBrowserLoginFlow(config) {
+    return new Promise((resolve, reject) => {
+        const port = 4224;
+        const state = randomBytes(16).toString('hex');
+        const redirectUri = `http://localhost:${port}/callback`;
+        const authorizeUrl = `${config.serverUrl}/oauth/authorize?response_type=code&client_id=cli&redirect_uri=${encodeURIComponent(redirectUri)}&state=${state}`;
+        const server = http.createServer(async (req, res) => {
+            try {
+                const reqUrl = new URL(req.url || '', `http://${req.headers.host}`);
+                if (reqUrl.pathname === '/callback') {
+                    const code = reqUrl.searchParams.get('code');
+                    const returnedState = reqUrl.searchParams.get('state');
+                    if (!code || returnedState !== state) {
+                        res.writeHead(400, { 'Content-Type': 'text/html' });
+                        res.end(getErrorHtml('Invalid OAuth state returned. High security warning.'));
+                        server.close();
+                        reject(new Error('OAuth state mismatch. Verification failed.'));
+                        return;
+                    }
+                    // Exchange code for token
+                    const tokenUrl = `${config.serverUrl}/oauth/token`;
+                    const tokenResponse = await fetch(tokenUrl, {
+                        method: 'POST',
+                        headers: { 'Content-Type': 'application/json' },
+                        body: JSON.stringify({
+                            code,
+                            grant_type: 'authorization_code'
+                        })
+                    });
+                    if (!tokenResponse.ok) {
+                        const errorText = await tokenResponse.text();
+                        res.writeHead(400, { 'Content-Type': 'text/html' });
+                        res.end(getErrorHtml('Failed to exchange authorization code for access token.'));
+                        server.close();
+                        reject(new Error(`Token exchange failed: ${errorText}`));
+                        return;
+                    }
+                    const tokenData = await tokenResponse.json();
+                    const accessToken = tokenData.access_token;
+                    if (!accessToken) {
+                        res.writeHead(400, { 'Content-Type': 'text/html' });
+                        res.end(getErrorHtml('No access token returned by the server.'));
+                        server.close();
+                        reject(new Error('Access token not found in oauth response.'));
+                        return;
+                    }
+                    // Retrieve user profile email using access token
+                    let email = '';
+                    try {
+                        const profileResponse = await fetch(`${config.serverUrl}/api/auth/me`, {
+                            headers: { 'Authorization': `Bearer ${accessToken}` }
+                        });
+                        if (profileResponse.ok) {
+                            const profileData = await profileResponse.json();
+                            email = profileData.email;
+                        }
+                    }
+                    catch (profileErr) {
+                        // Non-critical error, we can proceed without saving email or decode from JWT
+                    }
+                    res.writeHead(200, { 'Content-Type': 'text/html' });
+                    res.end(getSuccessHtml(email));
+                    server.close();
+                    resolve({ token: accessToken, email });
+                }
+                else {
+                    res.writeHead(404, { 'Content-Type': 'text/plain' });
+                    res.end('Not Found');
+                }
+            }
+            catch (err) {
+                res.writeHead(500, { 'Content-Type': 'text/html' });
+                res.end(getErrorHtml(err.message || 'Internal server error'));
+                server.close();
+                reject(err);
+            }
+        });
+        server.on('error', (err) => {
+            if (err.code === 'EADDRINUSE') {
+                reject(new Error(`Port ${port} is already in use. Please stop the application utilizing this port.`));
+            }
+            else {
+                reject(err);
+            }
+        });
+        server.listen(port, () => {
+            openBrowser(authorizeUrl);
+        });
+    });
+}
+const program = new Command();
+program
+    .name('contextstore')
+    .description('Connect local projects and files to your AI persistent memory')
+    .version('1.0.0');
+program
+    .command('login')
+    .description('Authenticate the CLI with your ContextStore account')
+    .action(async () => {
+    p.intro('ContextStore CLI Authentication');
+    const config = loadConfig();
+    const authMethod = await p.select({
+        message: 'Select authentication method:',
+        options: [
+            { value: 'browser', label: 'Browser-based Auto-Login (OAuth Flow) (Recommended)' },
+            { value: 'password', label: 'Email & Password (Automatic Token Retrieval)' },
+            { value: 'token', label: 'Paste JWT Token (Manual copy from Browser)' }
+        ]
+    });
+    if (p.isCancel(authMethod)) {
+        p.outro('Authentication cancelled.');
+        process.exit(0);
+    }
+    if (authMethod === 'browser') {
+        const s = p.spinner();
+        s.start('Waiting for browser authentication...');
+        try {
+            const result = await startBrowserLoginFlow(config);
+            saveConfig({ authToken: result.token, email: result.email });
+            s.stop('Authentication successful');
+            p.outro(`✓ Successfully authenticated as ${result.email}!`);
+        }
+        catch (error) {
+            s.stop('Authentication failed');
+            p.note(error.message || 'Error occurred during login', 'Login Error');
+            p.outro('Browser login failed. You can retry or use another login method.');
+        }
+    }
+    else if (authMethod === 'password') {
+        const email = await p.text({
+            message: 'Enter your email:',
+            placeholder: 'developer@example.com',
+            validate: (v) => (!v ? 'Email is required' : !v.includes('@') ? 'Invalid email' : undefined)
+        });
+        if (p.isCancel(email)) {
+            p.outro('Cancelled.');
+            process.exit(0);
+        }
+        const password = await p.password({
+            message: 'Enter your password:',
+            validate: (v) => (!v ? 'Password is required' : undefined)
+        });
+        if (p.isCancel(password)) {
+            p.outro('Cancelled.');
+            process.exit(0);
+        }
+        const s = p.spinner();
+        s.start('Authenticating with ContextStore server...');
+        try {
+            const response = await fetch(`${config.serverUrl}/api/auth/login`, {
+                method: 'POST',
+                headers: { 'Content-Type': 'application/json' },
+                body: JSON.stringify({ email: email.toLowerCase(), password })
+            });
+            const data = await response.json();
+            if (response.ok && data.token) {
+                saveConfig({ authToken: data.token, email: email.toLowerCase() });
+                s.stop('Authentication successful');
+                p.outro(`✓ Successfully authenticated as ${email}!`);
+            }
+            else {
+                s.stop('Authentication failed');
+                p.note(data.detail || 'Invalid email or password', 'Login Error');
+                p.outro('Please verify your credentials and try again.');
+            }
+        }
+        catch (error) {
+            s.stop('Authentication failed');
+            p.note(error.message || 'Could not connect to auth server', 'Network Error');
+            p.outro('Please make sure your backend server is running.');
+        }
+    }
+    else {
+        const token = await p.text({
+            message: 'Enter your ContextStore Auth Token:',
+            placeholder: 'eyJhbGciOi...',
+            validate: (value) => {
+                if (!value)
+                    return 'Token is required';
+                if (value.length < 15)
+                    return 'Invalid token length';
+                return;
+            }
+        });
+        if (p.isCancel(token)) {
+            p.outro('Authentication cancelled.');
+            process.exit(0);
+        }
+        const email = await p.text({
+            message: 'Confirm your account email:',
+            placeholder: 'name@domain.com',
+            validate: (value) => {
+                if (!value)
+                    return 'Email is required';
+                if (!value.includes('@'))
+                    return 'Invalid email address';
+                return;
+            }
+        });
+        if (p.isCancel(email)) {
+            p.outro('Authentication cancelled.');
+            process.exit(0);
+        }
+        saveConfig({ authToken: token, email: email.toLowerCase() });
+        p.outro('✓ Successfully authenticated! Token saved.');
+    }
+});
+program
+    .command('sync')
+    .description('Sync a workspace directory directly')
+    .argument('[path]', 'Path to the directory to sync', '.')
+    .action(async (dirPath) => {
+    const absolutePath = path.resolve(dirPath);
+    if (!fs.existsSync(absolutePath)) {
+        console.error(`Error: Path does not exist: ${absolutePath}`);
+        process.exit(1);
+    }
+    const config = loadConfig();
+    if (!config.authToken) {
+        console.error('Error: Not authenticated. Please run: npx contextstore-app login');
+        process.exit(1);
+    }
+    const files = walkWorkspace(absolutePath);
+    await performWorkspaceSync(absolutePath, files, config, 'Workspace');
+});
+program
+    .command('watch')
+    .description('Start file watcher daemon for incremental syncs')
+    .argument('[path]', 'Path to watch', '.')
+    .action(async (dirPath) => {
+    const absolutePath = path.resolve(dirPath);
+    if (!fs.existsSync(absolutePath)) {
+        console.error(`Error: Path does not exist: ${absolutePath}`);
+        process.exit(1);
+    }
+    const config = loadConfig();
+    if (!config.authToken) {
+        console.error('Error: Not authenticated. Please run: npx contextstore-app login');
+        process.exit(1);
+    }
+    p.intro(`Incremental Watcher Mode`);
+    startWatcher(absolutePath, config);
+});
+function cleanPath(input) {
+    let cleaned = input.trim();
+    if (cleaned.startsWith('"') && cleaned.endsWith('"')) {
+        cleaned = cleaned.substring(1, cleaned.length - 1);
+    }
+    if (cleaned.startsWith("'") && cleaned.endsWith("'")) {
+        cleaned = cleaned.substring(1, cleaned.length - 1);
+    }
+    return cleaned.trim();
+}
+// Main Interactive Entrypoint
+async function interactiveFlow() {
+    p.intro('Welcome to ContextStore');
+    const config = loadConfig();
+    if (!config.authToken) {
+        p.note('Authentication required. Opening your browser to sign in to ContextStore...', 'Authentication Required');
+        const s = p.spinner();
+        s.start('Waiting for browser authentication...');
+        try {
+            const result = await startBrowserLoginFlow(config);
+            saveConfig({ authToken: result.token, email: result.email });
+            config.authToken = result.token;
+            config.email = result.email;
+            s.stop('Authentication successful');
+            p.note(`✓ Successfully authenticated as ${result.email}!`, 'Success');
+        }
+        catch (error) {
+            s.stop('Authentication failed');
+            p.note(error.message || 'Error occurred during login', 'Login Error');
+            p.outro('Login failed. Please verify the server is running and try again.');
+            process.exit(0);
+        }
+    }
+    const syncType = await p.select({
+        message: 'What do you want to sync?',
+        options: [
+            { value: 'workspace', label: 'Workspace (Full project folders, auto-detected)', hint: 'recommended' },
+            { value: 'custom', label: 'Custom path (Type any local folder path)' }
+        ]
+    });
+    if (p.isCancel(syncType)) {
+        p.outro('Cancelled.');
+        process.exit(0);
+    }
+    let selectedPath = '';
+    if (syncType === 'workspace') {
+        const s = p.spinner();
+        s.start('Detecting local projects...');
+        const detected = await detectProjects();
+        s.stop('Projects detected');
+        const options = detected.map(p => ({
+            value: p.path,
+            label: `${p.name.padEnd(20)} ${p.path.padEnd(35)}`,
+            hint: `[${p.type}]`
+        }));
+        options.push({
+            value: 'custom',
+            label: 'Enter custom path...',
+            hint: ''
+        });
+        const projectSelect = await p.select({
+            message: 'Select a project:',
+            options
+        });
+        if (p.isCancel(projectSelect)) {
+            p.outro('Cancelled.');
+            process.exit(0);
+        }
+        if (projectSelect === 'custom') {
+            const customPath = await p.text({
+                message: 'Enter absolute folder path:',
+                validate: (v) => {
+                    const cleaned = cleanPath(v);
+                    if (!cleaned)
+                        return 'Path is required';
+                    if (!fs.existsSync(cleaned))
+                        return 'Directory does not exist';
+                    return;
+                }
+            });
+            if (p.isCancel(customPath)) {
+                p.outro('Cancelled.');
+                process.exit(0);
+            }
+            selectedPath = path.resolve(cleanPath(customPath));
+        }
+        else {
+            selectedPath = projectSelect;
+        }
+    }
+    else if (syncType === 'custom') {
+        const customPath = await p.text({
+            message: 'Enter folder path:',
+            validate: (v) => {
+                const cleaned = cleanPath(v);
+                if (!cleaned)
+                    return 'Path is required';
+                if (!fs.existsSync(cleaned))
+                    return 'Directory does not exist';
+                return;
+            }
+        });
+        if (p.isCancel(customPath)) {
+            p.outro('Cancelled.');
+            process.exit(0);
+        }
+        selectedPath = path.resolve(cleanPath(customPath));
+    }
+    // Ask for sync mode (All files vs Selective files)
+    const syncMode = await p.select({
+        message: 'How do you want to sync this folder?',
+        options: [
+            { value: 'all', label: 'Sync all files (recommended)' },
+            { value: 'selective', label: 'Select specific files to sync' }
+        ]
+    });
+    if (p.isCancel(syncMode)) {
+        p.outro('Cancelled.');
+        process.exit(0);
+    }
+    let filesToSync = [];
+    if (syncMode === 'selective') {
+        const s = p.spinner();
+        s.start('Scanning workspace files for selection...');
+        const allFiles = walkWorkspace(selectedPath);
+        s.stop(`Done. Found ${allFiles.length} indexable files.`);
+        if (allFiles.length === 0) {
+            p.note('No indexable files found in this directory based on ignore rules.', 'Scan Info');
+            p.outro('Goodbye!');
+            process.exit(0);
+        }
+        const fileOptions = allFiles.map(file => ({
+            value: file,
+            label: path.relative(selectedPath, file).replace(/\\/g, '/')
+        }));
+        const fileSelection = await p.multiselect({
+            message: 'Select files to sync (Space to select, Enter to confirm):',
+            options: fileOptions,
+            required: true
+        });
+        if (p.isCancel(fileSelection)) {
+            p.outro('Cancelled.');
+            process.exit(0);
+        }
+        filesToSync = fileSelection;
+    }
+    else {
+        const s = p.spinner();
+        s.start('Walking directories & filtering ignored paths...');
+        filesToSync = walkWorkspace(selectedPath);
+        s.stop(`Done. Found ${filesToSync.length} files to index.`);
+    }
+    // Perform indexing & syncing
+    await performWorkspaceSync(selectedPath, filesToSync, config, syncMode === 'selective' ? 'Files' : 'Workspace');
+    // Ask to watch directory
+    const watchConfirm = await p.confirm({
+        message: 'Would you like to watch this directory for file changes in the background?',
+        active: 'Yes (watch)',
+        inactive: 'No (exit)'
+    });
+    if (p.isCancel(watchConfirm) || !watchConfirm) {
+        p.outro('✓ Sync complete. Goodbye!');
+        process.exit(0);
+    }
+    p.note(`Watching for changes... Pres SIGINT (Ctrl+C) to stop.`, 'Active Watcher');
+    startWatcher(selectedPath, config);
+}
+async function performWorkspaceSync(workspacePath, files, config, syncTypeName = 'Workspace') {
+    const startTime = Date.now();
+    const projectType = detectProjectType(workspacePath);
+    p.note(`Project Path: ${workspacePath}\nProject Type: ${projectType}`, `Syncing ${syncTypeName}`);
+    if (files.length === 0) {
+        p.note('No files to sync.', 'Sync Info');
+        return;
+    }
+    // 1. Print syncing header
+    console.log(' \x1b[36m◆\x1b[0m Syncing workspace files...');
+    // 2. Hide terminal cursor
+    process.stdout.write('\x1b[?25l');
+    let successCount = 0;
+    let failedCount = 0;
+    const errors = [];
+    for (let index = 0; index < files.length; index += 1) {
+        const file = files[index];
+        const percentage = Math.round(((index + 1) / files.length) * 100);
+        const relativeName = path.relative(workspacePath, file).replace(/\\/g, '/');
+        // Render beautiful colored progress bar
+        const barWidth = 20;
+        const filledWidth = Math.round((percentage / 100) * barWidth);
+        const emptyWidth = barWidth - filledWidth;
+        const filledBar = `\x1b[32m${'▰'.repeat(filledWidth)}\x1b[0m`;
+        const emptyBar = `\x1b[90m${'▱'.repeat(emptyWidth)}\x1b[0m`;
+        const percentText = `\x1b[1;32m${percentage}%\x1b[0m`;
+        const countText = `\x1b[36m${index + 1}/${files.length} files\x1b[0m`;
+        const fileText = `\x1b[90mSynced ${relativeName}\x1b[0m`;
+        // Clear line and write progress in-place
+        process.stdout.write(`\r\x1b[K \x1b[36m│\x1b[0m ${filledBar}${emptyBar} ${percentText} | ${countText} | ${fileText}`);
+        const result = await syncFile(file, workspacePath, config);
+        if (result.status === 'synced') {
+            successCount += 1;
+        }
+        else {
+            failedCount += 1;
+            if (result.error) {
+                errors.push(`${relativeName}: ${result.error}`);
+            }
+        }
+    }
+    // 3. Restore terminal cursor and clear line
+    process.stdout.write('\x1b[?25h\r\x1b[K\n');
+    const duration = ((Date.now() - startTime) / 1000).toFixed(1);
+    if (failedCount === 0) {
+        console.log(' \x1b[32m✓\x1b[0m Sync completed successfully!');
+    }
+    else {
+        console.log(' \x1b[33m⚠\x1b[0m Sync completed with some failures.');
+    }
+    p.note(`Project   : ${path.basename(workspacePath)} [${projectType}]\nFiles     : ${successCount} indexed (${failedCount} failed)\nSync Time : ${duration}s`, 'Sync Status');
+    // Render synced files tree structure
+    try {
+        const relativeFiles = files.map(f => path.relative(workspacePath, f));
+        const treeRoot = buildTree(workspacePath, relativeFiles);
+        const { lines: treeLines, truncated } = renderTree(treeRoot);
+        let treeText = treeLines.join('\n');
+        if (truncated) {
+            treeText += `\n\n\x1b[90m... and ${files.length - treeLines.length + 1} more files collapsed (showing top structure)\x1b[0m`;
+        }
+        p.note(treeText, 'Synced Workspace Structure');
+    }
+    catch (err) {
+        // Fail-safe to ensure CLI doesn't crash if tree builder fails
+    }
+    if (failedCount > 0) {
+        const sampleErrors = errors.slice(0, 5);
+        let errorSummary = `Some files failed to sync. Top error details:\n` + sampleErrors.map(e => ` \x1b[31m•\x1b[0m ${e}`).join('\n');
+        if (errors.length > 5) {
+            errorSummary += `\n ... and ${errors.length - 5} more errors.`;
+        }
+        errorSummary += `\n\n\x1b[33mTip:\x1b[0m Make sure your backend server is running and your token is valid. Check network connectivity.`;
+        p.note(errorSummary, 'Sync Failure Details');
+    }
+    // Offer to generate/update CLAUDE.md for Claude Code integration
+    const claudeMdPath = path.join(workspacePath, 'CLAUDE.md');
+    const hasClaudeMd = fs.existsSync(claudeMdPath);
+    const setupClaude = await p.confirm({
+        message: hasClaudeMd
+            ? 'A CLAUDE.md file already exists. Would you like to append ContextStore instructions?'
+            : 'Would you like to auto-generate a CLAUDE.md instructions file in this workspace to link with Claude Code?',
+        active: 'Yes (setup)',
+        inactive: 'No'
+    });
+    if (!p.isCancel(setupClaude) && setupClaude) {
+        const instructionText = `# contextstore — Codex Memory Instructions\n\nYou are connected to **contextstore** persistent memory via the **hydradb-plus** MCP server.\n\n## At the START of every new conversation or mid-session context reload\n1. Call \`smart_checkin(user_intent='<brief description of what you want to do>')\` immediately.\n2. Log every message turn using \`log_conversation_turn()\`.\n3. If \`pending_syncs\` is returned from \`smart_checkin\`, read each raw file outline, extract codebase memories using \`memory_store(memory_type='codebase', ...)\` and call \`mark_sync_done(sync_id)\` for each processed item silently before answering the user.\n`;
+        try {
+            if (hasClaudeMd) {
+                // Append or replace if already present
+                const currentContent = fs.readFileSync(claudeMdPath, 'utf-8');
+                if (!currentContent.includes('contextstore')) {
+                    fs.writeFileSync(claudeMdPath, currentContent + '\n\n' + instructionText, 'utf-8');
+                    p.note(`✓ Appended ContextStore instructions to existing CLAUDE.md`, 'Integration Setup');
+                }
+                else {
+                    p.note(`✓ CLAUDE.md already configured for ContextStore.`, 'Integration Setup');
+                }
+            }
+            else {
+                fs.writeFileSync(claudeMdPath, instructionText, 'utf-8');
+                p.note(`✓ Successfully created CLAUDE.md in your workspace root.`, 'Integration Setup');
+            }
+        }
+        catch (err) {
+            p.note(`Failed to write CLAUDE.md: ${err.message}`, 'Setup Error');
+        }
+    }
+    saveConfig({ activeWorkspace: workspacePath });
+}
+function buildTree(basePath, relativePaths) {
+    const root = { name: path.basename(basePath), isFile: false, children: new Map() };
+    for (const relPath of relativePaths) {
+        const parts = relPath.split(/[/\\]/);
+        let current = root;
+        for (let i = 0; i < parts.length; i++) {
+            const part = parts[i];
+            const isFile = i === parts.length - 1;
+            if (!current.children.has(part)) {
+                current.children.set(part, {
+                    name: part,
+                    isFile,
+                    children: new Map()
+                });
+            }
+            current = current.children.get(part);
+        }
+    }
+    return root;
+}
+function renderTree(node, prefix = '', isLast = true, depth = 0, lines = [], maxLines = 20) {
+    if (lines.length >= maxLines) {
+        return { lines, truncated: true };
+    }
+    if (depth > 0) {
+        const connector = isLast ? '└── ' : '├── ';
+        const nameColor = node.isFile ? `\x1b[37m${node.name}\x1b[0m` : `\x1b[1;34m${node.name}/\x1b[0m`;
+        lines.push(`${prefix}${connector}${nameColor}`);
+    }
+    else {
+        lines.push(`\x1b[1;36m${node.name}\x1b[0m`);
+    }
+    const childPrefix = depth === 0 ? '' : prefix + (isLast ? '    ' : '│   ');
+    const sortedChildren = Array.from(node.children.values()).sort((a, b) => {
+        if (a.isFile !== b.isFile) {
+            return a.isFile ? 1 : -1;
+        }
+        return a.name.localeCompare(b.name);
+    });
+    for (let i = 0; i < sortedChildren.length; i++) {
+        if (lines.length >= maxLines) {
+            return { lines, truncated: true };
+        }
+        const child = sortedChildren[i];
+        const isLastChild = i === sortedChildren.length - 1;
+        const res = renderTree(child, childPrefix, isLastChild, depth + 1, lines, maxLines);
+        if (res.truncated) {
+            return res;
+        }
+    }
+    return { lines, truncated: false };
+}
+// Parse input arguments
+if (process.argv.length > 2) {
+    program.parse(process.argv);
+}
+else {
+    void interactiveFlow();
+}