archicore 0.1.0

package/dist/cli/commands/projects.js

@@ -0,0 +1,249 @@
+/**
+ * ArchiCore CLI - Projects Commands
+ */
+import { loadConfig, setActiveProject, clearActiveProject } from '../utils/config.js';
+import { fetchProjects, selectProject, checkServerConnection, initSession, getSession } from '../utils/session.js';
+import { colors, projectsTable, createSpinner, printSuccess, printError, printKeyValue, printSection, simpleTable, header } from '../ui/index.js';
+export function registerProjectsCommand(program) {
+    const projects = program
+        .command('projects')
+        .description('Manage ArchiCore projects');
+    // List projects
+    projects
+        .command('list')
+        .alias('ls')
+        .description('List all projects')
+        .action(async () => {
+        const spinner = createSpinner('Fetching projects...').start();
+        try {
+            const connected = await checkServerConnection();
+            if (!connected) {
+                spinner.fail('Cannot connect to ArchiCore server');
+                printError('Make sure the server is running: npm run server');
+                process.exit(1);
+            }
+            const projectsList = await fetchProjects();
+            spinner.succeed(`Found ${projectsList.length} projects`);
+            if (projectsList.length === 0) {
+                console.log();
+                console.log(colors.muted('  No projects found. Create one with:'));
+                console.log(colors.secondary('  archicore projects create <path>'));
+                console.log();
+                return;
+            }
+            const config = await loadConfig();
+            console.log();
+            console.log(projectsTable(projectsList));
+            console.log();
+            if (config.activeProjectId) {
+                const active = projectsList.find(p => p.id === config.activeProjectId);
+                if (active) {
+                    console.log(colors.muted('  Active project: ') + colors.primary(active.name));
+                    console.log();
+                }
+            }
+        }
+        catch (error) {
+            spinner.fail('Failed to fetch projects');
+            printError(String(error));
+            process.exit(1);
+        }
+    });
+    // Create project
+    projects
+        .command('create <path>')
+        .description('Create or connect a project')
+        .option('-n, --name <name>', 'Project name')
+        .option('--index', 'Index project after creation', false)
+        .action(async (path, options) => {
+        const spinner = createSpinner('Creating project...').start();
+        try {
+            const config = await loadConfig();
+            const response = await fetch(`${config.serverUrl}/api/projects`, {
+                method: 'POST',
+                headers: { 'Content-Type': 'application/json' },
+                body: JSON.stringify({
+                    name: options.name || path.split('/').pop() || path.split('\\').pop(),
+                    path: path,
+                }),
+            });
+            if (!response.ok) {
+                const error = await response.json();
+                throw new Error(error.error || 'Failed to create project');
+            }
+            const data = await response.json();
+            spinner.succeed('Project created');
+            console.log();
+            printKeyValue('ID', data.id);
+            printKeyValue('Name', data.name);
+            printKeyValue('Path', path);
+            console.log();
+            // Set as active project
+            await setActiveProject(data.id, path);
+            printSuccess('Set as active project');
+            // Index if requested
+            if (options.index) {
+                console.log();
+                const indexSpinner = createSpinner('Indexing project...').start();
+                const indexResponse = await fetch(`${config.serverUrl}/api/projects/${data.id}/index`, {
+                    method: 'POST',
+                });
+                if (indexResponse.ok) {
+                    indexSpinner.succeed('Project indexed');
+                }
+                else {
+                    indexSpinner.fail('Failed to index project');
+                }
+            }
+        }
+        catch (error) {
+            spinner.fail('Failed to create project');
+            printError(String(error));
+            process.exit(1);
+        }
+    });
+    // Delete project
+    projects
+        .command('delete <id>')
+        .alias('rm')
+        .description('Delete a project')
+        .option('-f, --force', 'Skip confirmation')
+        .action(async (id, _options) => {
+        const spinner = createSpinner('Deleting project...').start();
+        try {
+            const config = await loadConfig();
+            const response = await fetch(`${config.serverUrl}/api/projects/${id}`, {
+                method: 'DELETE',
+            });
+            if (!response.ok) {
+                const error = await response.json();
+                throw new Error(error.error || 'Failed to delete project');
+            }
+            spinner.succeed('Project deleted');
+            // Clear active project if it was deleted
+            if (config.activeProjectId === id) {
+                await clearActiveProject();
+                console.log(colors.muted('  Active project cleared'));
+            }
+        }
+        catch (error) {
+            spinner.fail('Failed to delete project');
+            printError(String(error));
+            process.exit(1);
+        }
+    });
+    // Select project
+    projects
+        .command('select <id>')
+        .alias('use')
+        .description('Select active project')
+        .action(async (id) => {
+        const spinner = createSpinner('Selecting project...').start();
+        try {
+            const project = await selectProject(id);
+            if (!project) {
+                spinner.fail('Project not found');
+                process.exit(1);
+            }
+            spinner.succeed(`Selected project: ${project.name}`);
+            console.log();
+            printKeyValue('ID', project.id);
+            printKeyValue('Name', project.name);
+            printKeyValue('Path', project.path);
+            printKeyValue('Status', project.status);
+            if (project.files)
+                printKeyValue('Files', String(project.files));
+            if (project.symbols)
+                printKeyValue('Symbols', String(project.symbols));
+            console.log();
+        }
+        catch (error) {
+            spinner.fail('Failed to select project');
+            printError(String(error));
+            process.exit(1);
+        }
+    });
+    // Project status
+    projects
+        .command('status [id]')
+        .description('Show project status')
+        .action(async (id) => {
+        const spinner = createSpinner('Fetching status...').start();
+        try {
+            await initSession();
+            getSession(); // Initialize session state
+            const config = await loadConfig();
+            const projectId = id || config.activeProjectId;
+            if (!projectId) {
+                spinner.fail('No project specified');
+                printError('Use "archicore projects select <id>" or specify project ID');
+                process.exit(1);
+            }
+            const response = await fetch(`${config.serverUrl}/api/projects/${projectId}`);
+            if (!response.ok) {
+                spinner.fail('Project not found');
+                process.exit(1);
+            }
+            const data = await response.json();
+            spinner.succeed('Project status');
+            console.log();
+            console.log(header(data.name, data.path));
+            printSection('Statistics');
+            const stats = [
+                ['Status', data.status || 'unknown'],
+                ['Files', String(data.statistics?.codeIndex?.totalFiles || 0)],
+                ['Symbols', String(data.statistics?.codeIndex?.totalSymbols || 0)],
+                ['Nodes', String(data.statistics?.codeIndex?.totalNodes || 0)],
+                ['Edges', String(data.statistics?.codeIndex?.totalEdges || 0)],
+            ];
+            console.log(simpleTable(stats));
+            if (data.statistics?.codeIndex?.symbolsByKind) {
+                printSection('Symbols by Kind');
+                const kinds = Object.entries(data.statistics.codeIndex.symbolsByKind)
+                    .map(([k, v]) => [k, String(v)]);
+                console.log(simpleTable(kinds));
+            }
+            console.log();
+        }
+        catch (error) {
+            spinner.fail('Failed to fetch status');
+            printError(String(error));
+            process.exit(1);
+        }
+    });
+    // Index project
+    projects
+        .command('index [id]')
+        .description('Index or re-index project')
+        .action(async (id) => {
+        const spinner = createSpinner('Indexing project...').start();
+        try {
+            const config = await loadConfig();
+            const projectId = id || config.activeProjectId;
+            if (!projectId) {
+                spinner.fail('No project specified');
+                printError('Use "archicore projects select <id>" or specify project ID');
+                process.exit(1);
+            }
+            const response = await fetch(`${config.serverUrl}/api/projects/${projectId}/index`, {
+                method: 'POST',
+            });
+            if (!response.ok) {
+                const error = await response.json();
+                throw new Error(error.error || 'Failed to index project');
+            }
+            const data = await response.json();
+            spinner.succeed('Project indexed');
+            console.log();
+            printKeyValue('Files', String(data.statistics?.totalFiles || 0));
+            printKeyValue('Symbols', String(data.statistics?.totalSymbols || 0));
+            console.log();
+        }
+        catch (error) {
+            spinner.fail('Failed to index project');
+            printError(String(error));
+            process.exit(1);
+        }
+    });
+}
+//# sourceMappingURL=projects.js.map

package/dist/cli/index.d.ts

@@ -0,0 +1,7 @@
+/**
+ * ArchiCore CLI
+ */
+export * from './commands/index.js';
+export * from './ui/index.js';
+export * from './utils/index.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/cli/index.js

@@ -0,0 +1,7 @@
+/**
+ * ArchiCore CLI
+ */
+export * from './commands/index.js';
+export * from './ui/index.js';
+export * from './utils/index.js';
+//# sourceMappingURL=index.js.map

package/dist/cli/ui/box.d.ts

@@ -0,0 +1,17 @@
+/**
+ * ArchiCore CLI Box Components
+ */
+export interface BoxOptions {
+    title?: string;
+    padding?: number;
+    borderColor?: string;
+    borderStyle?: 'single' | 'double' | 'round' | 'bold' | 'singleDouble' | 'doubleSingle' | 'classic';
+}
+export declare function box(content: string, options?: BoxOptions): string;
+export declare function header(title: string, subtitle?: string): string;
+export declare function errorBox(message: string, title?: string): string;
+export declare function successBox(message: string, title?: string): string;
+export declare function warningBox(message: string, title?: string): string;
+export declare function infoBox(message: string, title?: string): string;
+export declare function resultBox(content: string, title?: string): string;
+//# sourceMappingURL=box.d.ts.map

package/dist/cli/ui/box.js

@@ -0,0 +1,62 @@
+/**
+ * ArchiCore CLI Box Components
+ */
+import boxen from 'boxen';
+import { colors } from './colors.js';
+export function box(content, options = {}) {
+    const boxenOptions = {
+        padding: options.padding ?? 1,
+        borderColor: options.borderColor ?? '#7C3AED',
+        borderStyle: options.borderStyle ?? 'round',
+        title: options.title,
+        titleAlignment: 'center',
+    };
+    return boxen(content, boxenOptions);
+}
+export function header(title, subtitle) {
+    const content = subtitle
+        ? `${colors.brand(title)}\n${colors.muted(subtitle)}`
+        : colors.brand(title);
+    return box(content, {
+        borderColor: '#7C3AED',
+        borderStyle: 'round',
+        padding: 1,
+    });
+}
+export function errorBox(message, title = 'Error') {
+    return box(colors.error(message), {
+        title: colors.error.bold(title),
+        borderColor: '#EF4444',
+        borderStyle: 'round',
+    });
+}
+export function successBox(message, title = 'Success') {
+    return box(colors.success(message), {
+        title: colors.success.bold(title),
+        borderColor: '#10B981',
+        borderStyle: 'round',
+    });
+}
+export function warningBox(message, title = 'Warning') {
+    return box(colors.warning(message), {
+        title: colors.warning.bold(title),
+        borderColor: '#F59E0B',
+        borderStyle: 'round',
+    });
+}
+export function infoBox(message, title = 'Info') {
+    return box(colors.info(message), {
+        title: colors.info.bold(title),
+        borderColor: '#3B82F6',
+        borderStyle: 'round',
+    });
+}
+export function resultBox(content, title) {
+    return box(content, {
+        title,
+        borderColor: '#6B7280',
+        borderStyle: 'single',
+        padding: 1,
+    });
+}
+//# sourceMappingURL=box.js.map

package/dist/cli/ui/colors.d.ts

@@ -0,0 +1,49 @@
+/**
+ * ArchiCore CLI Color Scheme
+ */
+export declare const colors: {
+    primary: import("chalk").ChalkInstance;
+    secondary: import("chalk").ChalkInstance;
+    accent: import("chalk").ChalkInstance;
+    success: import("chalk").ChalkInstance;
+    warning: import("chalk").ChalkInstance;
+    error: import("chalk").ChalkInstance;
+    info: import("chalk").ChalkInstance;
+    dim: import("chalk").ChalkInstance;
+    muted: import("chalk").ChalkInstance;
+    highlight: import("chalk").ChalkInstance;
+    critical: import("chalk").ChalkInstance;
+    high: import("chalk").ChalkInstance;
+    medium: import("chalk").ChalkInstance;
+    low: import("chalk").ChalkInstance;
+    brand: import("chalk").ChalkInstance;
+    link: import("chalk").ChalkInstance;
+    code: import("chalk").ChalkInstance;
+};
+export declare const icons: {
+    success: string;
+    error: string;
+    warning: string;
+    info: string;
+    arrow: string;
+    bullet: string;
+    dash: string;
+    spinner: string[];
+    progress: string;
+    empty: string;
+    folder: string;
+    file: string;
+    code: string;
+    graph: string;
+    search: string;
+    gear: string;
+    lightning: string;
+    lock: string;
+    severityCritical: string;
+    severityHigh: string;
+    severityMedium: string;
+    severityLow: string;
+};
+export declare function formatImpactLevel(level: string): string;
+export declare function formatSeverity(severity: string): string;
+//# sourceMappingURL=colors.d.ts.map

package/dist/cli/ui/colors.js

@@ -0,0 +1,86 @@
+/**
+ * ArchiCore CLI Color Scheme
+ */
+import chalk from 'chalk';
+export const colors = {
+    // Primary colors
+    primary: chalk.hex('#7C3AED'), // Purple
+    secondary: chalk.hex('#06B6D4'), // Cyan
+    accent: chalk.hex('#F59E0B'), // Amber
+    // Status colors
+    success: chalk.hex('#10B981'), // Green
+    warning: chalk.hex('#F59E0B'), // Amber
+    error: chalk.hex('#EF4444'), // Red
+    info: chalk.hex('#3B82F6'), // Blue
+    // Text colors
+    dim: chalk.gray,
+    muted: chalk.hex('#6B7280'),
+    highlight: chalk.bold.white,
+    // Impact levels
+    critical: chalk.hex('#DC2626'), // Red
+    high: chalk.hex('#EA580C'), // Orange
+    medium: chalk.hex('#CA8A04'), // Yellow
+    low: chalk.hex('#16A34A'), // Green
+    // Special
+    brand: chalk.hex('#7C3AED').bold,
+    link: chalk.hex('#3B82F6').underline,
+    code: chalk.hex('#F472B6'), // Pink
+};
+export const icons = {
+    // Status
+    success: '\u2713', // checkmark
+    error: '\u2717', // x
+    warning: '\u26A0', // warning triangle
+    info: '\u2139', // info
+    // Actions
+    arrow: '\u276F', // >
+    bullet: '\u2022', // bullet
+    dash: '\u2500', // horizontal line
+    // Progress
+    spinner: ['\u25DC', '\u25DD', '\u25DE', '\u25DF'],
+    progress: '\u25CF', // filled circle
+    empty: '\u25CB', // empty circle
+    // Objects
+    folder: '\uD83D\uDCC1', // folder emoji
+    file: '\uD83D\uDCC4', // file emoji
+    code: '\uD83D\uDCBB', // laptop emoji
+    graph: '\uD83D\uDCCA', // chart emoji
+    search: '\uD83D\uDD0D', // magnifying glass
+    gear: '\u2699', // gear
+    lightning: '\u26A1', // lightning
+    lock: '\uD83D\uDD12', // lock
+    // Severity
+    severityCritical: '\uD83D\uDD34', // red circle
+    severityHigh: '\uD83D\uDFE0', // orange circle
+    severityMedium: '\uD83D\uDFE1', // yellow circle
+    severityLow: '\uD83D\uDFE2', // green circle
+};
+export function formatImpactLevel(level) {
+    switch (level) {
+        case 'critical':
+            return colors.critical(`${icons.severityCritical} CRITICAL`);
+        case 'high':
+            return colors.high(`${icons.severityHigh} HIGH`);
+        case 'medium':
+            return colors.medium(`${icons.severityMedium} MEDIUM`);
+        case 'low':
+            return colors.low(`${icons.severityLow} LOW`);
+        default:
+            return colors.muted(level);
+    }
+}
+export function formatSeverity(severity) {
+    switch (severity.toLowerCase()) {
+        case 'critical':
+            return colors.critical.bold(severity.toUpperCase());
+        case 'high':
+            return colors.high.bold(severity.toUpperCase());
+        case 'medium':
+            return colors.medium(severity.toUpperCase());
+        case 'low':
+            return colors.low(severity.toUpperCase());
+        default:
+            return colors.muted(severity);
+    }
+}
+//# sourceMappingURL=colors.js.map

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

@@ -0,0 +1,9 @@
+/**
+ * ArchiCore CLI UI Components
+ */
+export * from './colors.js';
+export * from './box.js';
+export * from './table.js';
+export * from './spinner.js';
+export * from './prompt.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/cli/ui/index.js

@@ -0,0 +1,9 @@
+/**
+ * ArchiCore CLI UI Components
+ */
+export * from './colors.js';
+export * from './box.js';
+export * from './table.js';
+export * from './spinner.js';
+export * from './prompt.js';
+//# sourceMappingURL=index.js.map

package/dist/cli/ui/prompt.d.ts

@@ -0,0 +1,34 @@
+/**
+ * ArchiCore CLI Prompt Components
+ */
+export interface PromptOptions {
+    message?: string;
+    prefix?: string;
+}
+export declare class Prompt {
+    private rl;
+    private history;
+    constructor();
+    ask(question: string): Promise<string>;
+    confirm(question: string, defaultValue?: boolean): Promise<boolean>;
+    select<T extends string>(question: string, options: Array<{
+        value: T;
+        label: string;
+        description?: string;
+    }>): Promise<T>;
+    close(): void;
+}
+export declare function createPrompt(): Prompt;
+export declare function printPrompt(_prefix?: string): void;
+export declare function printWelcome(): void;
+export declare function printHelp(): void;
+export declare function printGoodbye(): void;
+export declare function printDivider(): void;
+export declare function printSection(title: string): void;
+export declare function printKeyValue(key: string, value: string): void;
+export declare function printBullet(text: string, indent?: number): void;
+export declare function printSuccess(message: string): void;
+export declare function printError(message: string): void;
+export declare function printWarning(message: string): void;
+export declare function printInfo(message: string): void;
+//# sourceMappingURL=prompt.d.ts.map

package/dist/cli/ui/prompt.js

@@ -0,0 +1,122 @@
+/**
+ * ArchiCore CLI Prompt Components
+ */
+import * as readline from 'readline';
+import { colors, icons } from './colors.js';
+export class Prompt {
+    rl;
+    history = [];
+    constructor() {
+        this.rl = readline.createInterface({
+            input: process.stdin,
+            output: process.stdout,
+            terminal: true,
+        });
+    }
+    async ask(question) {
+        return new Promise((resolve) => {
+            this.rl.question(colors.primary(question + ' '), (answer) => {
+                if (answer.trim()) {
+                    this.history.push(answer.trim());
+                }
+                resolve(answer.trim());
+            });
+        });
+    }
+    async confirm(question, defaultValue = false) {
+        const hint = defaultValue ? '[Y/n]' : '[y/N]';
+        const answer = await this.ask(`${question} ${colors.muted(hint)}`);
+        if (!answer)
+            return defaultValue;
+        return answer.toLowerCase().startsWith('y');
+    }
+    async select(question, options) {
+        console.log(colors.primary(question));
+        console.log();
+        options.forEach((opt, index) => {
+            const num = colors.secondary(`  ${index + 1}.`);
+            const label = colors.highlight(opt.label);
+            const desc = opt.description ? colors.muted(` - ${opt.description}`) : '';
+            console.log(`${num} ${label}${desc}`);
+        });
+        console.log();
+        const answer = await this.ask('Enter number:');
+        const index = parseInt(answer) - 1;
+        if (index >= 0 && index < options.length) {
+            return options[index].value;
+        }
+        console.log(colors.error('Invalid selection, please try again.'));
+        return this.select(question, options);
+    }
+    close() {
+        this.rl.close();
+    }
+}
+export function createPrompt() {
+    return new Prompt();
+}
+export function printPrompt(_prefix = 'archicore') {
+    process.stdout.write(colors.primary(`${icons.arrow} `));
+}
+export function printWelcome() {
+    console.log();
+    console.log(colors.brand('  ArchiCore') + colors.muted(' v0.1.0'));
+    console.log(colors.muted('  AI Software Architect'));
+    console.log();
+}
+export function printHelp() {
+    console.log();
+    console.log(colors.primary.bold('  Commands:'));
+    console.log();
+    const commands = [
+        ['/index', 'Index current project'],
+        ['/analyze [desc]', 'Run impact analysis'],
+        ['/search <query>', 'Semantic code search'],
+        ['/dead-code', 'Find dead code'],
+        ['/security', 'Security analysis'],
+        ['/metrics', 'Code metrics'],
+        ['/export [format]', 'Export (json/html/md)'],
+        ['/status', 'Show current status'],
+        ['/clear', 'Clear screen'],
+        ['/help', 'Show this help'],
+        ['/exit', 'Exit ArchiCore'],
+    ];
+    for (const [cmd, desc] of commands) {
+        console.log(`    ${colors.secondary(cmd.padEnd(22))} ${colors.muted(desc)}`);
+    }
+    console.log();
+    console.log(colors.muted('  Or just ask a question about your code!'));
+    console.log();
+}
+export function printGoodbye() {
+    console.log();
+    console.log(colors.muted('  Goodbye! ') + colors.primary(icons.lightning));
+    console.log();
+}
+export function printDivider() {
+    console.log(colors.dim('\u2500'.repeat(60)));
+}
+export function printSection(title) {
+    console.log();
+    console.log(colors.primary.bold(`  ${title}`));
+    console.log();
+}
+export function printKeyValue(key, value) {
+    console.log(`  ${colors.muted(key + ':')} ${colors.highlight(value)}`);
+}
+export function printBullet(text, indent = 2) {
+    console.log(' '.repeat(indent) + colors.secondary(icons.bullet) + ' ' + text);
+}
+export function printSuccess(message) {
+    console.log(colors.success(`  ${icons.success} ${message}`));
+}
+export function printError(message) {
+    console.log(colors.error(`  ${icons.error} ${message}`));
+}
+export function printWarning(message) {
+    console.log(colors.warning(`  ${icons.warning} ${message}`));
+}
+export function printInfo(message) {
+    console.log(colors.info(`  ${icons.info} ${message}`));
+}
+//# sourceMappingURL=prompt.js.map