archicore 0.1.0

package/dist/cli/commands/export.d.ts

@@ -0,0 +1,6 @@
+/**
+ * ArchiCore CLI - Export Command
+ */
+import { Command } from 'commander';
+export declare function registerExportCommand(program: Command): void;
+//# sourceMappingURL=export.d.ts.map

package/dist/cli/commands/export.js

@@ -0,0 +1,78 @@
+/**
+ * ArchiCore CLI - Export Command
+ */
+import { writeFile } from 'fs/promises';
+import { loadConfig } from '../utils/config.js';
+import { createSpinner, printError, printKeyValue, } from '../ui/index.js';
+export function registerExportCommand(program) {
+    program
+        .command('export')
+        .description('Export project data')
+        .option('-p, --project <id>', 'Project ID')
+        .option('-f, --format <format>', 'Output format (json|html|markdown|csv|graphml)', 'json')
+        .option('-o, --output <file>', 'Output file path')
+        .option('--include <types>', 'Include specific data (architecture,graph,metrics,analysis)', 'all')
+        .action(async (options) => {
+        const spinner = createSpinner(`Exporting as ${options.format}...`).start();
+        try {
+            const config = await loadConfig();
+            const projectId = options.project || config.activeProjectId;
+            if (!projectId) {
+                spinner.fail('No project selected');
+                printError('Use "archicore projects select <id>" first.');
+                process.exit(1);
+            }
+            // Determine what to include
+            const include = options.include === 'all'
+                ? ['architecture', 'graph', 'metrics', 'analysis']
+                : options.include.split(',').map((s) => s.trim());
+            const response = await fetch(`${config.serverUrl}/api/projects/${projectId}/export`, {
+                method: 'POST',
+                headers: { 'Content-Type': 'application/json' },
+                body: JSON.stringify({
+                    format: options.format,
+                    include,
+                }),
+            });
+            if (!response.ok) {
+                const error = await response.json();
+                throw new Error(error.error || 'Failed to export');
+            }
+            const data = await response.json();
+            // Determine output file
+            const extMap = {
+                json: 'json',
+                html: 'html',
+                markdown: 'md',
+                csv: 'csv',
+                graphml: 'graphml',
+            };
+            const ext = extMap[options.format] || 'txt';
+            const outputFile = options.output || `archicore-export.${ext}`;
+            // Get content based on format
+            let content;
+            if (options.format === 'json') {
+                content = JSON.stringify(data.data || data, null, 2);
+            }
+            else if (data.content) {
+                content = data.content;
+            }
+            else {
+                content = JSON.stringify(data, null, 2);
+            }
+            await writeFile(outputFile, content);
+            spinner.succeed('Export complete');
+            console.log();
+            printKeyValue('Format', options.format.toUpperCase());
+            printKeyValue('Output', outputFile);
+            printKeyValue('Size', `${(content.length / 1024).toFixed(1)} KB`);
+            console.log();
+        }
+        catch (error) {
+            spinner.fail('Export failed');
+            printError(String(error));
+            process.exit(1);
+        }
+    });
+}
+//# sourceMappingURL=export.js.map

package/dist/cli/commands/index.d.ts

@@ -0,0 +1,8 @@
+/**
+ * ArchiCore CLI Commands
+ */
+export { registerAnalyzerCommands } from './analyzers.js';
+export { registerExportCommand } from './export.js';
+export { startInteractiveMode } from './interactive.js';
+export { initProject, isInitialized, getLocalProject } from './init.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/cli/commands/index.js

@@ -0,0 +1,8 @@
+/**
+ * ArchiCore CLI Commands
+ */
+export { registerAnalyzerCommands } from './analyzers.js';
+export { registerExportCommand } from './export.js';
+export { startInteractiveMode } from './interactive.js';
+export { initProject, isInitialized, getLocalProject } from './init.js';
+//# sourceMappingURL=index.js.map

package/dist/cli/commands/init.d.ts

@@ -0,0 +1,26 @@
+/**
+ * ArchiCore CLI - Project Initialization
+ *
+ * Initializes ArchiCore in the current directory
+ */
+interface LocalProjectConfig {
+    id?: string;
+    name: string;
+    path: string;
+    createdAt: string;
+    indexed: boolean;
+}
+/**
+ * Check if ArchiCore is initialized in a directory
+ */
+export declare function isInitialized(dir: string): Promise<boolean>;
+/**
+ * Get local project config
+ */
+export declare function getLocalProject(dir: string): Promise<LocalProjectConfig | null>;
+/**
+ * Initialize ArchiCore in a directory
+ */
+export declare function initProject(dir: string, name?: string): Promise<void>;
+export {};
+//# sourceMappingURL=init.d.ts.map

package/dist/cli/commands/init.js

@@ -0,0 +1,140 @@
+/**
+ * ArchiCore CLI - Project Initialization
+ *
+ * Initializes ArchiCore in the current directory
+ */
+import * as path from 'path';
+import * as fs from 'fs/promises';
+import { createSpinner, printError, printInfo, printKeyValue } from '../ui/index.js';
+import { loadConfig } from '../utils/config.js';
+const ARCHICORE_DIR = '.archicore';
+const CONFIG_FILE = 'project.json';
+/**
+ * Check if ArchiCore is initialized in a directory
+ */
+export async function isInitialized(dir) {
+    try {
+        await fs.access(path.join(dir, ARCHICORE_DIR, CONFIG_FILE));
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Get local project config
+ */
+export async function getLocalProject(dir) {
+    try {
+        const configPath = path.join(dir, ARCHICORE_DIR, CONFIG_FILE);
+        const content = await fs.readFile(configPath, 'utf-8');
+        return JSON.parse(content);
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Save local project config
+ */
+async function saveLocalProject(dir, config) {
+    const archicoreDir = path.join(dir, ARCHICORE_DIR);
+    const configPath = path.join(archicoreDir, CONFIG_FILE);
+    // Ensure directory exists
+    await fs.mkdir(archicoreDir, { recursive: true });
+    await fs.writeFile(configPath, JSON.stringify(config, null, 2));
+}
+/**
+ * Initialize ArchiCore in a directory
+ */
+export async function initProject(dir, name) {
+    console.log();
+    // Check if already initialized
+    const existing = await getLocalProject(dir);
+    if (existing) {
+        printInfo(`ArchiCore already initialized in this directory`);
+        printKeyValue('Project', existing.name);
+        printKeyValue('ID', existing.id || 'Not synced');
+        console.log();
+        return;
+    }
+    // Derive name from directory if not provided
+    const projectName = name || path.basename(dir);
+    const spinner = createSpinner('Initializing ArchiCore...').start();
+    try {
+        const config = await loadConfig();
+        // Create project on server
+        const response = await fetch(`${config.serverUrl}/api/projects`, {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify({ name: projectName, path: dir }),
+        });
+        let projectId;
+        let serverName = projectName;
+        if (response.ok) {
+            const data = await response.json();
+            projectId = data.id || data.project?.id;
+            serverName = data.name || data.project?.name || projectName;
+        }
+        else {
+            // Server might not be running, that's OK - we can still create local config
+            spinner.warn('Server not available, creating local config only');
+        }
+        // Create local config
+        const localConfig = {
+            id: projectId,
+            name: serverName,
+            path: dir,
+            createdAt: new Date().toISOString(),
+            indexed: false,
+        };
+        await saveLocalProject(dir, localConfig);
+        // Add .archicore to .gitignore if git repo
+        await addToGitignore(dir);
+        if (projectId) {
+            spinner.succeed('ArchiCore initialized');
+        }
+        console.log();
+        printKeyValue('Directory', dir);
+        printKeyValue('Project', serverName);
+        if (projectId) {
+            printKeyValue('ID', projectId.slice(0, 8));
+        }
+        console.log();
+        printInfo('Run `archicore` to start interactive mode');
+        printInfo('Use /index to index your codebase');
+        console.log();
+    }
+    catch (error) {
+        spinner.fail('Initialization failed');
+        printError(String(error));
+    }
+}
+/**
+ * Add .archicore to .gitignore
+ */
+async function addToGitignore(dir) {
+    const gitignorePath = path.join(dir, '.gitignore');
+    try {
+        let content = '';
+        try {
+            content = await fs.readFile(gitignorePath, 'utf-8');
+        }
+        catch {
+            // File doesn't exist
+        }
+        // Check if already ignored
+        if (content.includes('.archicore')) {
+            return;
+        }
+        // Add to gitignore
+        const newContent = content.trim()
+            ? `${content.trim()}\n\n# ArchiCore\n.archicore/\n`
+            : `# ArchiCore\n.archicore/\n`;
+        await fs.writeFile(gitignorePath, newContent);
+    }
+    catch {
+        // Ignore errors
+    }
+}
+//# sourceMappingURL=init.js.map

package/dist/cli/commands/interactive.d.ts

@@ -0,0 +1,7 @@
+/**
+ * ArchiCore CLI - Interactive Mode
+ *
+ * REPL-style interface similar to Claude Code
+ */
+export declare function startInteractiveMode(): Promise<void>;
+//# sourceMappingURL=interactive.d.ts.map