contextstore-app 1.0.0

package/dist/indexer.d.ts

@@ -0,0 +1,6 @@
+export interface FileOutline {
+    filePath: string;
+    outline: string;
+    snippet: string;
+}
+export declare function generateFileOutline(filePath: string): FileOutline;

package/dist/indexer.js

@@ -0,0 +1,181 @@
+import * as fs from 'fs';
+import * as path from 'path';
+export function generateFileOutline(filePath) {
+    try {
+        const ext = path.extname(filePath).toLowerCase();
+        const content = fs.readFileSync(filePath, 'utf-8');
+        if (ext === '.ts' || ext === '.tsx' || ext === '.js' || ext === '.jsx') {
+            return parseJsTsOutline(filePath, content);
+        }
+        else if (ext === '.py') {
+            return parsePythonOutline(filePath, content);
+        }
+        else if (ext === '.md') {
+            return parseMarkdownOutline(filePath, content);
+        }
+        else {
+            return parseGenericOutline(filePath, content);
+        }
+    }
+    catch (error) {
+        return {
+            filePath,
+            outline: 'Error reading file structural outline.',
+            snippet: ''
+        };
+    }
+}
+function parseJsTsOutline(filePath, content) {
+    const lines = content.split(/\r?\n/);
+    const outlineLines = [];
+    const snippetLines = [];
+    let inDocstring = false;
+    let docstringBuffer = [];
+    for (let index = 0; index < lines.length; index += 1) {
+        const line = lines[index];
+        const trimmed = line.trim();
+        // Catch JSDoc comments
+        if (trimmed.startsWith('/**')) {
+            inDocstring = true;
+            docstringBuffer = [trimmed];
+            continue;
+        }
+        if (inDocstring) {
+            docstringBuffer.push(trimmed);
+            if (trimmed.endsWith('*/')) {
+                inDocstring = false;
+            }
+            continue;
+        }
+        // Match exports, classes, interfaces, types, functions, and arrow function definitions
+        const isExport = trimmed.startsWith('export ');
+        const isClass = trimmed.match(/^(?:export\s+)?class\s+(\w+)/);
+        const isInterface = trimmed.match(/^(?:export\s+)?interface\s+(\w+)/);
+        const isType = trimmed.match(/^(?:export\s+)?type\s+(\w+)/);
+        const isFunction = trimmed.match(/^(?:export\s+|async\s+|export\s+async\s+)?function\s+(\w+)/);
+        const isArrowFunction = trimmed.match(/^(?:export\s+)?const\s+(\w+)\s*=\s*(?:async\s*)?\([^)]*\)\s*=>/);
+        if (isExport || isClass || isInterface || isType || isFunction || isArrowFunction) {
+            // If we have docstring buffer, prepend it
+            if (docstringBuffer.length > 0) {
+                snippetLines.push(...docstringBuffer);
+                docstringBuffer = [];
+            }
+            snippetLines.push(trimmed);
+            if (isClass)
+                outlineLines.push(`class ${isClass[1]}`);
+            else if (isInterface)
+                outlineLines.push(`interface ${isInterface[1]}`);
+            else if (isType)
+                outlineLines.push(`type ${isType[1]}`);
+            else if (isFunction)
+                outlineLines.push(`function ${isFunction[1]}()`);
+            else if (isArrowFunction)
+                outlineLines.push(`const ${isArrowFunction[1]}()`);
+        }
+        else {
+            // Clear docstring buffer if we hit general code
+            if (!trimmed.startsWith('//') && trimmed !== '') {
+                docstringBuffer = [];
+            }
+        }
+    }
+    const outline = outlineLines.length > 0
+        ? `Exports: ${outlineLines.join(', ')}`
+        : 'Generic Script File (no explicit class/function exports found)';
+    return {
+        filePath,
+        outline,
+        snippet: snippetLines.slice(0, 50).join('\n') // Cap snippet to 50 structural lines
+    };
+}
+function parsePythonOutline(filePath, content) {
+    const lines = content.split(/\r?\n/);
+    const outlineLines = [];
+    const snippetLines = [];
+    let currentClass = '';
+    let inDocstring = false;
+    let docstringBuffer = [];
+    for (let index = 0; index < lines.length; index += 1) {
+        const line = lines[index];
+        const trimmed = line.trim();
+        // Catch docstrings (triple quotes)
+        if (trimmed.startsWith('"""') || trimmed.startsWith("'''")) {
+            if (trimmed.endsWith('"""') && trimmed.length > 3 || trimmed.endsWith("'''") && trimmed.length > 3) {
+                // Single-line docstring
+                docstringBuffer.push(trimmed);
+            }
+            else {
+                inDocstring = !inDocstring;
+                docstringBuffer.push(trimmed);
+            }
+            continue;
+        }
+        if (inDocstring) {
+            docstringBuffer.push(trimmed);
+            if (trimmed.endsWith('"""') || trimmed.endsWith("'''")) {
+                inDocstring = false;
+            }
+            continue;
+        }
+        const isClass = line.match(/^class\s+(\w+)/);
+        const isDef = line.match(/^\s*def\s+(\w+)/);
+        if (isClass) {
+            currentClass = isClass[1];
+            outlineLines.push(`class ${currentClass}`);
+            if (docstringBuffer.length > 0) {
+                snippetLines.push(...docstringBuffer);
+                docstringBuffer = [];
+            }
+            snippetLines.push(trimmed);
+        }
+        else if (isDef) {
+            const funcName = isDef[1];
+            outlineLines.push(currentClass ? `  def ${funcName}()` : `def ${funcName}()`);
+            if (docstringBuffer.length > 0) {
+                snippetLines.push(...docstringBuffer.map(d => '  ' + d));
+                docstringBuffer = [];
+            }
+            snippetLines.push(trimmed);
+        }
+        else {
+            if (!trimmed.startsWith('#') && trimmed !== '') {
+                docstringBuffer = [];
+            }
+        }
+    }
+    const outline = outlineLines.length > 0
+        ? outlineLines.join('\n')
+        : 'Generic Python File (no classes/functions defined)';
+    return {
+        filePath,
+        outline,
+        snippet: snippetLines.slice(0, 50).join('\n')
+    };
+}
+function parseMarkdownOutline(filePath, content) {
+    const lines = content.split(/\r?\n/);
+    const headings = [];
+    for (const line of lines) {
+        if (line.startsWith('#')) {
+            headings.push(line.trim());
+        }
+    }
+    const outline = headings.length > 0
+        ? `Markdown Sections: ${headings.slice(0, 10).join(' -> ')}`
+        : 'Markdown Document';
+    return {
+        filePath,
+        outline,
+        snippet: headings.slice(0, 30).join('\n')
+    };
+}
+function parseGenericOutline(filePath, content) {
+    // Take first 5 lines as a quick identifier outline, first 1000 characters as snippet
+    const lines = content.split(/\r?\n/).slice(0, 10).filter(l => l.trim().length > 0);
+    const outline = lines.length > 0 ? `Snippet: ${lines[0].substring(0, 80)}` : 'Empty File';
+    return {
+        filePath,
+        outline,
+        snippet: content.substring(0, 1500)
+    };
+}

package/dist/syncer.d.ts

@@ -0,0 +1,8 @@
+import { Config } from './config.js';
+export interface SyncResult {
+    filePath: string;
+    status: 'synced' | 'skipped' | 'failed';
+    error?: string;
+}
+export declare function computeFileHash(filePath: string): string;
+export declare function syncFile(filePath: string, workspacePath: string, config: Config): Promise<SyncResult>;

package/dist/syncer.js

@@ -0,0 +1,77 @@
+import axios from 'axios';
+import * as crypto from 'crypto';
+import * as fs from 'fs';
+import * as path from 'path';
+import { generateFileOutline } from './indexer.js';
+export function computeFileHash(filePath) {
+    try {
+        const content = fs.readFileSync(filePath);
+        return crypto.createHash('sha256').update(content).digest('hex');
+    }
+    catch {
+        return '';
+    }
+}
+export async function syncFile(filePath, workspacePath, config) {
+    const relativePath = path.relative(workspacePath, filePath).replace(/\\/g, '/');
+    try {
+        const fileHash = computeFileHash(filePath);
+        if (!fileHash) {
+            return { filePath: relativePath, status: 'failed', error: 'Could not read file hash' };
+        }
+        // Generate AST-style outline and structural snippet
+        const { outline, snippet } = generateFileOutline(filePath);
+        // Format raw text for client-side LLM consumption (free processing design)
+        const rawText = `WORKSPACE FILE SYNC:
+Path: ${relativePath}
+Checksum: ${fileHash}
+Outline:
+${outline}
+
+Snippet:
+${snippet}`;
+        // POST ingest request to backend API
+        const response = await axios.post(`${config.serverUrl}/sync/ingest`, {
+            text: rawText,
+            source: `codebase:${relativePath}`
+        }, {
+            headers: {
+                Authorization: `Bearer ${config.authToken}`,
+                'Content-Type': 'application/json'
+            }
+        });
+        if (response.status === 200 && response.data.success) {
+            return { filePath: relativePath, status: 'synced' };
+        }
+        else {
+            return {
+                filePath: relativePath,
+                status: 'failed',
+                error: response.data.message || 'Server rejected request'
+            };
+        }
+    }
+    catch (error) {
+        let errMsg = 'Unknown error';
+        if (error.response?.data?.detail) {
+            errMsg = error.response.data.detail;
+        }
+        else if (error.response?.data?.message) {
+            errMsg = error.response.data.message;
+        }
+        else if (error.message) {
+            errMsg = error.message;
+        }
+        else if (error.code) {
+            errMsg = `Network Error (${error.code})`;
+        }
+        else if (error.toString) {
+            errMsg = error.toString();
+        }
+        return {
+            filePath: relativePath,
+            status: 'failed',
+            error: errMsg
+        };
+    }
+}

package/dist/type-detector.d.ts

@@ -0,0 +1 @@
+export declare function detectProjectType(workspacePath: string): string;

package/dist/type-detector.js

@@ -0,0 +1,53 @@
+import * as fs from 'fs';
+import * as path from 'path';
+export function detectProjectType(workspacePath) {
+    try {
+        const files = fs.readdirSync(workspacePath);
+        if (files.includes('package.json')) {
+            // Check if React, Next.js, Vite, Vue, etc. are specified
+            try {
+                const pkgContent = fs.readFileSync(path.join(workspacePath, 'package.json'), 'utf-8');
+                const pkg = JSON.parse(pkgContent);
+                const deps = { ...pkg.dependencies, ...pkg.devDependencies };
+                if (deps['next'])
+                    return 'Next.js';
+                if (deps['react'])
+                    return 'React';
+                if (deps['vue'])
+                    return 'Vue';
+                if (deps['nuxt'])
+                    return 'Nuxt';
+                if (deps['svelte'])
+                    return 'Svelte';
+                return 'NodeJS';
+            }
+            catch {
+                return 'NodeJS';
+            }
+        }
+        if (files.includes('requirements.txt') || files.includes('pyproject.toml') || files.includes('Pipfile') || files.includes('setup.py')) {
+            return 'Python';
+        }
+        if (files.includes('Cargo.toml')) {
+            return 'Rust';
+        }
+        if (files.includes('go.mod')) {
+            return 'Go';
+        }
+        if (files.includes('pom.xml') || files.includes('build.gradle')) {
+            return 'Java';
+        }
+        if (files.includes('Gemfile')) {
+            return 'Ruby';
+        }
+        // Check if it's primarily a Docs workspace
+        const mdFiles = files.filter(f => f.endsWith('.md'));
+        if (mdFiles.length > 3 || files.includes('docs') || files.includes('wiki')) {
+            return 'Docs';
+        }
+    }
+    catch {
+        // Ignore read errors
+    }
+    return 'Generic';
+}

package/dist/walker.d.ts

@@ -0,0 +1,4 @@
+export interface WalkOptions {
+    maxFiles?: number;
+}
+export declare function walkWorkspace(workspacePath: string, options?: WalkOptions): string[];

package/dist/walker.js

@@ -0,0 +1,103 @@
+import * as fs from 'fs';
+import * as path from 'path';
+import { minimatch } from 'minimatch';
+const DEFAULT_IGNORES = [
+    '**/node_modules/**',
+    '**/.git/**',
+    '**/dist/**',
+    '**/build/**',
+    '**/out/**',
+    '**/.next/**',
+    '**/.nuxt/**',
+    '**/.venv/**',
+    '**/venv/**',
+    '**/env/**',
+    '**/__pycache__/**',
+    '**/.pytest_cache/**',
+    '**/.DS_Store',
+    '**/Thumbs.db'
+];
+const BINARY_EXTENSIONS = new Set([
+    '.png', '.jpg', '.jpeg', '.gif', '.ico', '.pdf', '.zip', '.tar', '.gz', '.tgz',
+    '.mp4', '.mp3', '.wav', '.avi', '.mov', '.exe', '.dll', '.so', '.dylib', '.bin',
+    '.woff', '.woff2', '.eot', '.ttf', '.otf', '.svg', '.db', '.sqlite', '.pyc'
+]);
+export function walkWorkspace(workspacePath, options = {}) {
+    const maxFiles = options.maxFiles || 1000;
+    const filesList = [];
+    const gitignorePatterns = [...DEFAULT_IGNORES];
+    // Load root .gitignore patterns
+    const gitignorePath = path.join(workspacePath, '.gitignore');
+    if (fs.existsSync(gitignorePath)) {
+        try {
+            const content = fs.readFileSync(gitignorePath, 'utf-8');
+            const lines = content.split(/\r?\n/);
+            for (const line of lines) {
+                const trimmed = line.trim();
+                if (trimmed && !trimmed.startsWith('#')) {
+                    // Normalize gitignore patterns to glob patterns
+                    let globPattern = trimmed;
+                    if (trimmed.endsWith('/')) {
+                        globPattern = `**/${trimmed}**`;
+                    }
+                    else {
+                        globPattern = `**/${trimmed}`;
+                    }
+                    gitignorePatterns.push(globPattern);
+                }
+            }
+        }
+        catch {
+            // Ignore gitignore read errors
+        }
+    }
+    function shouldIgnore(relativeFilePath) {
+        const normalizedPath = relativeFilePath.replace(/\\/g, '/');
+        // Check custom and default ignores
+        for (const pattern of gitignorePatterns) {
+            if (minimatch(normalizedPath, pattern, { dot: true })) {
+                return true;
+            }
+        }
+        // Check extensions
+        const ext = path.extname(normalizedPath).toLowerCase();
+        if (BINARY_EXTENSIONS.has(ext)) {
+            return true;
+        }
+        return false;
+    }
+    function traverse(currentDir) {
+        if (filesList.length >= maxFiles)
+            return;
+        try {
+            const items = fs.readdirSync(currentDir);
+            for (const item of items) {
+                const fullPath = path.join(currentDir, item);
+                const relPath = path.relative(workspacePath, fullPath);
+                if (shouldIgnore(relPath)) {
+                    continue;
+                }
+                try {
+                    const stat = fs.statSync(fullPath);
+                    if (stat.isDirectory()) {
+                        traverse(fullPath);
+                    }
+                    else if (stat.isFile()) {
+                        filesList.push(fullPath);
+                        if (filesList.length >= maxFiles) {
+                            break;
+                        }
+                    }
+                }
+                catch {
+                    // Ignore stats errors
+                }
+            }
+        }
+        catch {
+            // Ignore read errors
+        }
+    }
+    traverse(workspacePath);
+    return filesList;
+}

package/dist/watcher.d.ts

@@ -0,0 +1,3 @@
+import chokidar from 'chokidar';
+import { Config } from './config.js';
+export declare function startWatcher(workspacePath: string, config: Config): chokidar.FSWatcher;

package/dist/watcher.js

@@ -0,0 +1,71 @@
+import chokidar from 'chokidar';
+import * as path from 'path';
+import { syncFile } from './syncer.js';
+export function startWatcher(workspacePath, config) {
+    console.log(`Watching for file changes in: ${workspacePath}...`);
+    const ignoredPatterns = [
+        '**/node_modules/**',
+        '**/.git/**',
+        '**/dist/**',
+        '**/build/**',
+        '**/out/**',
+        '**/.venv/**',
+        '**/venv/**',
+        '**/env/**',
+        '**/__pycache__/**',
+        '**/.DS_Store'
+    ];
+    const watcher = chokidar.watch(workspacePath, {
+        ignored: (filePath) => {
+            const relative = path.relative(workspacePath, filePath).replace(/\\/g, '/');
+            return ignoredPatterns.some(pattern => {
+                // Simple pattern matching for ignoring during watch
+                return relative.includes('node_modules') ||
+                    relative.includes('.git') ||
+                    relative.includes('dist') ||
+                    relative.includes('build') ||
+                    relative.includes('venv') ||
+                    relative.includes('__pycache__');
+            });
+        },
+        persistent: true,
+        ignoreInitial: true, // Don't trigger add events for existing files on startup
+        awaitWriteFinish: {
+            stabilityThreshold: 1000,
+            pollInterval: 100
+        }
+    });
+    watcher.on('add', async (filePath) => {
+        const relative = path.relative(workspacePath, filePath);
+        console.log(`[Watcher] File added: ${relative}`);
+        const res = await syncFile(filePath, workspacePath, config);
+        if (res.status === 'synced') {
+            console.log(`[Watcher] Successfully synced new file: ${relative}`);
+        }
+        else {
+            console.error(`[Watcher] Failed to sync new file: ${relative}. Error: ${res.error}`);
+        }
+    });
+    watcher.on('change', async (filePath) => {
+        const relative = path.relative(workspacePath, filePath);
+        console.log(`[Watcher] File changed: ${relative}`);
+        const res = await syncFile(filePath, workspacePath, config);
+        if (res.status === 'synced') {
+            console.log(`[Watcher] Successfully re-synced modified file: ${relative}`);
+        }
+        else {
+            console.error(`[Watcher] Failed to sync changes for: ${relative}. Error: ${res.error}`);
+        }
+    });
+    watcher.on('unlink', (filePath) => {
+        const relative = path.relative(workspacePath, filePath);
+        console.log(`[Watcher] File deleted: ${relative} (queued for index cleanup)`);
+        // Note: We can notify the server if we add a dedicated clean endpoint,
+        // otherwise the next full sync or AI check-in cleans obsolete files.
+    });
+    process.on('SIGINT', () => {
+        void watcher.close();
+        process.exit(0);
+    });
+    return watcher;
+}

package/package.json

@@ -0,0 +1,28 @@
+{
+  "name": "contextstore-app",
+  "version": "1.0.0",
+  "description": "CLI tool to sync local workspaces to persistent AI memory via MCP.",
+  "type": "module",
+  "main": "dist/index.js",
+  "bin": {
+    "contextstore": "dist/index.js"
+  },
+  "scripts": {
+    "build": "tsc && node fix-shebang.js",
+    "watch": "tsc -w",
+    "start": "node ./dist/index.js"
+  },
+  "dependencies": {
+    "@clack/prompts": "^0.7.0",
+    "axios": "^1.7.2",
+    "chokidar": "^3.6.0",
+    "commander": "^12.1.0",
+    "dotenv": "^16.4.5",
+    "minimatch": "^9.0.4"
+  },
+  "devDependencies": {
+    "@types/node": "^20.14.2",
+    "@types/minimatch": "^5.1.2",
+    "typescript": "^5.4.5"
+  }
+}