contextstore-app 1.0.0

package/dist/config.d.ts

@@ -0,0 +1,8 @@
+export interface Config {
+    serverUrl: string;
+    authToken: string;
+    email?: string;
+    activeWorkspace?: string;
+}
+export declare function loadConfig(): Config;
+export declare function saveConfig(config: Partial<Config>): void;

package/dist/config.js

@@ -0,0 +1,39 @@
+import * as fs from 'fs';
+import * as path from 'path';
+import * as os from 'os';
+const CONFIG_DIR = path.join(os.homedir(), '.contextstore');
+const CONFIG_FILE = path.join(CONFIG_DIR, 'config.json');
+const DEFAULT_CONFIG = {
+    serverUrl: process.env.CONTEXTSTORE_SERVER_URL || 'https://contextstore.oritm.tech',
+    authToken: ''
+};
+export function loadConfig() {
+    try {
+        if (!fs.existsSync(CONFIG_DIR)) {
+            fs.mkdirSync(CONFIG_DIR, { recursive: true });
+        }
+        if (!fs.existsSync(CONFIG_FILE)) {
+            fs.writeFileSync(CONFIG_FILE, JSON.stringify(DEFAULT_CONFIG, null, 2), 'utf-8');
+            return DEFAULT_CONFIG;
+        }
+        const data = fs.readFileSync(CONFIG_FILE, 'utf-8');
+        return { ...DEFAULT_CONFIG, ...JSON.parse(data) };
+    }
+    catch (error) {
+        console.error('Error loading config, using defaults:', error);
+        return DEFAULT_CONFIG;
+    }
+}
+export function saveConfig(config) {
+    try {
+        if (!fs.existsSync(CONFIG_DIR)) {
+            fs.mkdirSync(CONFIG_DIR, { recursive: true });
+        }
+        const current = loadConfig();
+        const updated = { ...current, ...config };
+        fs.writeFileSync(CONFIG_FILE, JSON.stringify(updated, null, 2), 'utf-8');
+    }
+    catch (error) {
+        console.error('Error saving config:', error);
+    }
+}

package/dist/detector.d.ts

@@ -0,0 +1,6 @@
+export interface ProjectInfo {
+    name: string;
+    path: string;
+    type: string;
+}
+export declare function detectProjects(): Promise<ProjectInfo[]>;

package/dist/detector.js

@@ -0,0 +1,154 @@
+import * as fs from 'fs';
+import * as path from 'path';
+import * as os from 'os';
+const COMMON_PROJECT_MARKERS = [
+    { file: 'package.json', type: 'Node/JS' },
+    { file: 'requirements.txt', type: 'Python' },
+    { file: 'pyproject.toml', type: 'Python' },
+    { file: 'Cargo.toml', type: 'Rust' },
+    { file: 'go.mod', type: 'Go' },
+    { file: 'Gemfile', type: 'Ruby' },
+    { file: 'pom.xml', type: 'Java/Maven' },
+    { file: 'build.gradle', type: 'Java/Gradle' },
+    { file: 'CMakeLists.txt', type: 'C/C++' },
+    { file: '.git', type: 'Git Repository', isDir: true }
+];
+export async function detectProjects() {
+    const projects = [];
+    // 1. Check if the current working directory itself is a project
+    const currentDir = path.resolve(process.cwd());
+    const currentType = identifyProjectType(currentDir);
+    if (currentType) {
+        projects.push({
+            name: `Current: ${path.basename(currentDir)}`,
+            path: currentDir,
+            type: currentType
+        });
+    }
+    // 2. Determine safe search roots
+    const searchRoots = [];
+    // Add parent of current directory if it's safe to scan (to find sibling projects)
+    const parentDir = path.dirname(currentDir);
+    if (isSafeToScan(parentDir)) {
+        searchRoots.push(parentDir);
+    }
+    // Add standard user locations
+    const desktopPath = path.join(os.homedir(), 'Desktop');
+    const documentsPath = path.join(os.homedir(), 'Documents');
+    if (isSafeToScan(desktopPath))
+        searchRoots.push(desktopPath);
+    if (isSafeToScan(documentsPath))
+        searchRoots.push(documentsPath);
+    if (isSafeToScan(os.homedir()))
+        searchRoots.push(os.homedir());
+    for (const root of searchRoots) {
+        if (!fs.existsSync(root))
+            continue;
+        try {
+            const items = fs.readdirSync(root);
+            for (const item of items) {
+                if (item.startsWith('.') || item === 'node_modules' || item === 'Library' || item === 'Applications') {
+                    continue;
+                }
+                const fullPath = path.join(root, item);
+                try {
+                    const stat = fs.statSync(fullPath);
+                    if (stat.isDirectory()) {
+                        const projectType = identifyProjectType(fullPath);
+                        if (projectType) {
+                            projects.push({
+                                name: item,
+                                path: fullPath,
+                                type: projectType
+                            });
+                        }
+                        else {
+                            // Deep scan 1 level for projects inside directories (e.g. Documents/Projects/...)
+                            const subItems = fs.readdirSync(fullPath);
+                            for (const subItem of subItems) {
+                                if (subItem.startsWith('.') || subItem === 'node_modules')
+                                    continue;
+                                const subFullPath = path.join(fullPath, subItem);
+                                try {
+                                    const subStat = fs.statSync(subFullPath);
+                                    if (subStat.isDirectory()) {
+                                        const subType = identifyProjectType(subFullPath);
+                                        if (subType) {
+                                            projects.push({
+                                                name: `${item}/${subItem}`,
+                                                path: subFullPath,
+                                                type: subType
+                                            });
+                                        }
+                                    }
+                                }
+                                catch {
+                                    // Ignore permission or file errors
+                                }
+                            }
+                        }
+                    }
+                }
+                catch {
+                    // Ignore directory read errors
+                }
+            }
+        }
+        catch (error) {
+            // Ignore root read errors
+        }
+    }
+    // Deduplicate and return top 10 unique projects
+    return projects
+        .filter((v, i, a) => a.findIndex(t => t.path === v.path) === i)
+        .slice(0, 10);
+}
+function identifyProjectType(dirPath) {
+    try {
+        const files = fs.readdirSync(dirPath);
+        for (const marker of COMMON_PROJECT_MARKERS) {
+            if (files.includes(marker.file)) {
+                const markerPath = path.join(dirPath, marker.file);
+                try {
+                    const stat = fs.statSync(markerPath);
+                    if (marker.isDir && stat.isDirectory()) {
+                        return marker.type;
+                    }
+                    else if (!marker.isDir && stat.isFile()) {
+                        return marker.type;
+                    }
+                }
+                catch {
+                    // Continue if file check fails
+                }
+            }
+        }
+    }
+    catch {
+        // Return null if reading folder fails
+    }
+    return null;
+}
+function isSafeToScan(dirPath) {
+    if (!dirPath)
+        return false;
+    try {
+        const normalized = path.normalize(dirPath).toLowerCase();
+        const parsed = path.parse(normalized);
+        // Check if it's drive root (e.g. C:\ or /)
+        if (normalized === parsed.root.toLowerCase())
+            return false;
+        // Check for Windows or Unix system folders
+        const forbidden = [
+            'c:\\users', 'c:\\users\\', 'c:\\windows', 'c:\\program files', 'c:\\program files (x86)',
+            '/home', '/users', '/system', '/etc', '/var', '/usr', '/bin', '/lib', '/opt', '/private'
+        ];
+        if (forbidden.some(f => normalized === f || normalized.startsWith(f + path.sep))) {
+            return false;
+        }
+        return true;
+    }
+    catch {
+        return false;
+    }
+}

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};