archicore 0.1.0

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

@@ -0,0 +1,29 @@
+/**
+ * ArchiCore CLI Spinner Component
+ */
+export interface SpinnerOptions {
+    text: string;
+    color?: 'cyan' | 'green' | 'yellow' | 'red' | 'magenta' | 'blue' | 'white';
+}
+export declare class Spinner {
+    private spinner;
+    constructor(text: string);
+    start(text?: string): this;
+    update(text: string): this;
+    succeed(text?: string): this;
+    fail(text?: string): this;
+    warn(text?: string): this;
+    info(text?: string): this;
+    stop(): this;
+}
+export declare function createSpinner(text: string): Spinner;
+export declare function withSpinner<T>(text: string, action: () => Promise<T>, options?: {
+    successText?: string;
+    failText?: string;
+}): Promise<T>;
+export declare function progressSteps(steps: string[]): {
+    next: () => void;
+    complete: () => void;
+    fail: (error?: string) => void;
+};
+//# sourceMappingURL=spinner.d.ts.map

package/dist/cli/ui/spinner.js

@@ -0,0 +1,80 @@
+/**
+ * ArchiCore CLI Spinner Component
+ */
+import ora from 'ora';
+import { colors } from './colors.js';
+export class Spinner {
+    spinner;
+    constructor(text) {
+        this.spinner = ora({
+            text: colors.muted(text),
+            spinner: 'dots',
+            color: 'magenta',
+        });
+    }
+    start(text) {
+        if (text)
+            this.spinner.text = colors.muted(text);
+        this.spinner.start();
+        return this;
+    }
+    update(text) {
+        this.spinner.text = colors.muted(text);
+        return this;
+    }
+    succeed(text) {
+        this.spinner.succeed(text ? colors.success(text) : undefined);
+        return this;
+    }
+    fail(text) {
+        this.spinner.fail(text ? colors.error(text) : undefined);
+        return this;
+    }
+    warn(text) {
+        this.spinner.warn(text ? colors.warning(text) : undefined);
+        return this;
+    }
+    info(text) {
+        this.spinner.info(text ? colors.info(text) : undefined);
+        return this;
+    }
+    stop() {
+        this.spinner.stop();
+        return this;
+    }
+}
+export function createSpinner(text) {
+    return new Spinner(text);
+}
+export async function withSpinner(text, action, options) {
+    const spinner = createSpinner(text).start();
+    try {
+        const result = await action();
+        spinner.succeed(options?.successText || text);
+        return result;
+    }
+    catch (error) {
+        spinner.fail(options?.failText || `Failed: ${text}`);
+        throw error;
+    }
+}
+export function progressSteps(steps) {
+    let currentStep = 0;
+    const spinner = createSpinner(steps[0]).start();
+    return {
+        next: () => {
+            spinner.succeed();
+            currentStep++;
+            if (currentStep < steps.length) {
+                spinner.start(steps[currentStep]);
+            }
+        },
+        complete: () => {
+            spinner.succeed();
+        },
+        fail: (error) => {
+            spinner.fail(error || steps[currentStep]);
+        },
+    };
+}
+//# sourceMappingURL=spinner.js.map

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

@@ -0,0 +1,33 @@
+/**
+ * ArchiCore CLI Table Components
+ */
+import Table from 'cli-table3';
+export interface TableOptions {
+    head?: string[];
+    colWidths?: number[];
+    wordWrap?: boolean;
+}
+export declare function createTable(options?: TableOptions): Table.Table;
+export declare function projectsTable(projects: Array<{
+    id: string;
+    name: string;
+    path: string;
+    status: string;
+    files?: number;
+    symbols?: number;
+}>): string;
+export declare function metricsTable(metrics: Array<{
+    file: string;
+    complexity: number;
+    maintainability: number;
+    linesOfCode: number;
+}>): string;
+export declare function issuesTable(issues: Array<{
+    severity: string;
+    type: string;
+    file: string;
+    line?: number;
+    message: string;
+}>): string;
+export declare function simpleTable(data: Array<[string, string]>): string;
+//# sourceMappingURL=table.d.ts.map

package/dist/cli/ui/table.js

@@ -0,0 +1,84 @@
+/**
+ * ArchiCore CLI Table Components
+ */
+import Table from 'cli-table3';
+import { colors } from './colors.js';
+export function createTable(options = {}) {
+    const tableOptions = {
+        wordWrap: options.wordWrap ?? true,
+    };
+    if (options.head) {
+        tableOptions.head = options.head.map(h => colors.primary.bold(h));
+    }
+    if (options.colWidths) {
+        tableOptions.colWidths = options.colWidths;
+    }
+    return new Table(tableOptions);
+}
+export function projectsTable(projects) {
+    const table = createTable({
+        head: ['ID', 'Name', 'Path', 'Status', 'Files', 'Symbols'],
+    });
+    for (const project of projects) {
+        const statusColor = project.status === 'indexed' ? colors.success : colors.muted;
+        const id = project.id || 'unknown';
+        const name = project.name || 'Unnamed';
+        const path = project.path || '';
+        table.push([
+            colors.muted(id.slice(0, 8)),
+            colors.highlight(name),
+            colors.dim(path.length > 40 ? '...' + path.slice(-37) : path),
+            statusColor(project.status || 'unknown'),
+            colors.secondary(String(project.files || '-')),
+            colors.secondary(String(project.symbols || '-')),
+        ]);
+    }
+    return table.toString();
+}
+export function metricsTable(metrics) {
+    const table = createTable({
+        head: ['File', 'Complexity', 'Maintainability', 'LOC'],
+    });
+    for (const m of metrics) {
+        const complexityColor = m.complexity > 20 ? colors.error : m.complexity > 10 ? colors.warning : colors.success;
+        const maintColor = m.maintainability < 50 ? colors.error : m.maintainability < 70 ? colors.warning : colors.success;
+        table.push([
+            colors.dim(m.file.length > 50 ? '...' + m.file.slice(-47) : m.file),
+            complexityColor(String(m.complexity)),
+            maintColor(String(m.maintainability.toFixed(1))),
+            colors.muted(String(m.linesOfCode)),
+        ]);
+    }
+    return table.toString();
+}
+export function issuesTable(issues) {
+    const table = createTable({
+        head: ['Severity', 'Type', 'Location', 'Message'],
+    });
+    for (const issue of issues) {
+        const severityColor = {
+            critical: colors.critical,
+            high: colors.high,
+            medium: colors.medium,
+            low: colors.low,
+        }[issue.severity.toLowerCase()] || colors.muted;
+        const location = issue.line
+            ? `${issue.file}:${issue.line}`
+            : issue.file;
+        table.push([
+            severityColor(issue.severity.toUpperCase()),
+            colors.secondary(issue.type),
+            colors.dim(location.length > 35 ? '...' + location.slice(-32) : location),
+            issue.message.slice(0, 50) + (issue.message.length > 50 ? '...' : ''),
+        ]);
+    }
+    return table.toString();
+}
+export function simpleTable(data) {
+    const lines = [];
+    for (const [key, value] of data) {
+        lines.push(`  ${colors.muted(key + ':')} ${colors.highlight(value)}`);
+    }
+    return lines.join('\n');
+}
+//# sourceMappingURL=table.js.map

package/dist/cli/utils/config.d.ts

@@ -0,0 +1,23 @@
+/**
+ * ArchiCore CLI Configuration
+ */
+export interface CLIConfig {
+    activeProjectId?: string;
+    activeProjectPath?: string;
+    serverUrl: string;
+    colorOutput: boolean;
+    verboseOutput: boolean;
+    llmProvider?: 'openai' | 'anthropic' | 'deepseek';
+    llmModel?: string;
+    qdrantUrl: string;
+    qdrantApiKey?: string;
+}
+export declare function loadConfig(): Promise<CLIConfig>;
+export declare function saveConfig(config: Partial<CLIConfig>): Promise<void>;
+export declare function getConfigValue<K extends keyof CLIConfig>(key: K): Promise<CLIConfig[K]>;
+export declare function setConfigValue<K extends keyof CLIConfig>(key: K, value: CLIConfig[K]): Promise<void>;
+export declare function setActiveProject(projectId: string, projectPath: string): Promise<void>;
+export declare function clearActiveProject(): Promise<void>;
+export declare function getConfigDir(): string;
+export declare function getConfigFile(): string;
+//# sourceMappingURL=config.d.ts.map

package/dist/cli/utils/config.js

@@ -0,0 +1,73 @@
+/**
+ * ArchiCore CLI Configuration
+ */
+import { readFile, writeFile, mkdir } from 'fs/promises';
+import { homedir } from 'os';
+import { join } from 'path';
+const CONFIG_DIR = join(homedir(), '.archicore');
+const CONFIG_FILE = join(CONFIG_DIR, 'config.json');
+const DEFAULT_CONFIG = {
+    serverUrl: 'http://127.0.0.1:3000',
+    colorOutput: true,
+    verboseOutput: false,
+    qdrantUrl: 'http://127.0.0.1:6333',
+};
+let cachedConfig = null;
+export async function loadConfig() {
+    if (cachedConfig)
+        return cachedConfig;
+    let config;
+    try {
+        await mkdir(CONFIG_DIR, { recursive: true });
+        const data = await readFile(CONFIG_FILE, 'utf-8');
+        config = { ...DEFAULT_CONFIG, ...JSON.parse(data) };
+    }
+    catch {
+        config = { ...DEFAULT_CONFIG };
+    }
+    // Override with environment variables
+    if (process.env.ARCHICORE_SERVER_URL) {
+        config.serverUrl = process.env.ARCHICORE_SERVER_URL;
+    }
+    if (process.env.QDRANT_URL) {
+        config.qdrantUrl = process.env.QDRANT_URL;
+    }
+    if (process.env.QDRANT_API_KEY) {
+        config.qdrantApiKey = process.env.QDRANT_API_KEY;
+    }
+    cachedConfig = config;
+    return config;
+}
+export async function saveConfig(config) {
+    const current = await loadConfig();
+    const updated = { ...current, ...config };
+    await mkdir(CONFIG_DIR, { recursive: true });
+    await writeFile(CONFIG_FILE, JSON.stringify(updated, null, 2));
+    cachedConfig = updated;
+}
+export async function getConfigValue(key) {
+    const config = await loadConfig();
+    return config[key];
+}
+export async function setConfigValue(key, value) {
+    await saveConfig({ [key]: value });
+}
+export async function setActiveProject(projectId, projectPath) {
+    await saveConfig({
+        activeProjectId: projectId,
+        activeProjectPath: projectPath,
+    });
+}
+export async function clearActiveProject() {
+    await saveConfig({
+        activeProjectId: undefined,
+        activeProjectPath: undefined,
+    });
+}
+export function getConfigDir() {
+    return CONFIG_DIR;
+}
+export function getConfigFile() {
+    return CONFIG_FILE;
+}
+//# sourceMappingURL=config.js.map

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

@@ -0,0 +1,6 @@
+/**
+ * ArchiCore CLI Utilities
+ */
+export * from './config.js';
+export * from './session.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/cli/utils/index.js

@@ -0,0 +1,6 @@
+/**
+ * ArchiCore CLI Utilities
+ */
+export * from './config.js';
+export * from './session.js';
+//# sourceMappingURL=index.js.map

package/dist/cli/utils/session.d.ts

@@ -0,0 +1,27 @@
+/**
+ * ArchiCore CLI Session Management
+ */
+export interface ProjectInfo {
+    id: string;
+    name: string;
+    path: string;
+    status: string;
+    files?: number;
+    symbols?: number;
+    indexed?: boolean;
+    lastIndexed?: Date;
+}
+export interface SessionState {
+    project: ProjectInfo | null;
+    serverUrl: string;
+    connected: boolean;
+}
+export declare function initSession(): Promise<SessionState>;
+export declare function getSession(): SessionState | null;
+export declare function selectProject(projectId: string): Promise<ProjectInfo | null>;
+export declare function clearProject(): Promise<void>;
+export declare function fetchProjects(): Promise<ProjectInfo[]>;
+export declare function checkServerConnection(): Promise<boolean>;
+export declare function requireProject(): ProjectInfo;
+export declare function requireConnection(): void;
+//# sourceMappingURL=session.d.ts.map

package/dist/cli/utils/session.js

@@ -0,0 +1,117 @@
+/**
+ * ArchiCore CLI Session Management
+ */
+import { loadConfig, setActiveProject } from './config.js';
+let sessionState = null;
+export async function initSession() {
+    const config = await loadConfig();
+    sessionState = {
+        project: null,
+        serverUrl: config.serverUrl,
+        connected: false,
+    };
+    // Try to load active project
+    if (config.activeProjectId) {
+        try {
+            const project = await fetchProject(config.activeProjectId);
+            if (project) {
+                sessionState.project = project;
+                sessionState.connected = true;
+            }
+        }
+        catch {
+            // Project not found or server not available
+        }
+    }
+    return sessionState;
+}
+export function getSession() {
+    return sessionState;
+}
+export async function selectProject(projectId) {
+    const project = await fetchProject(projectId);
+    if (project && sessionState) {
+        sessionState.project = project;
+        await setActiveProject(project.id, project.path);
+    }
+    return project;
+}
+export async function clearProject() {
+    if (sessionState) {
+        sessionState.project = null;
+    }
+}
+async function fetchProject(projectId) {
+    const config = await loadConfig();
+    try {
+        const response = await fetch(`${config.serverUrl}/api/projects/${projectId}`);
+        if (!response.ok)
+            return null;
+        const data = await response.json();
+        return {
+            id: data.id,
+            name: data.name,
+            path: data.path,
+            status: data.status || 'unknown',
+            files: data.statistics?.codeIndex?.totalFiles,
+            symbols: data.statistics?.codeIndex?.totalSymbols,
+            indexed: data.status === 'indexed',
+            lastIndexed: data.lastIndexed ? new Date(data.lastIndexed) : undefined,
+        };
+    }
+    catch {
+        return null;
+    }
+}
+export async function fetchProjects() {
+    const config = await loadConfig();
+    try {
+        const response = await fetch(`${config.serverUrl}/api/projects`);
+        if (!response.ok)
+            return [];
+        const data = await response.json();
+        return (data.projects || []).map((p) => ({
+            id: p.id,
+            name: p.name,
+            path: p.path,
+            status: p.status || 'unknown',
+            files: p.stats?.filesCount || p.statistics?.codeIndex?.totalFiles,
+            symbols: p.stats?.symbolsCount || p.statistics?.codeIndex?.totalSymbols,
+            indexed: p.status === 'ready' || p.status === 'indexed',
+        }));
+    }
+    catch {
+        return [];
+    }
+}
+export async function checkServerConnection() {
+    const config = await loadConfig();
+    try {
+        const response = await fetch(`${config.serverUrl}/health`, {
+            signal: AbortSignal.timeout(5000),
+        });
+        const connected = response.ok;
+        if (sessionState) {
+            sessionState.connected = connected;
+        }
+        return connected;
+    }
+    catch {
+        if (sessionState) {
+            sessionState.connected = false;
+        }
+        return false;
+    }
+}
+export function requireProject() {
+    if (!sessionState?.project) {
+        throw new Error('No project selected. Use "archicore projects select <id>" first.');
+    }
+    return sessionState.project;
+}
+export function requireConnection() {
+    if (!sessionState?.connected) {
+        throw new Error('Not connected to ArchiCore server. Make sure the server is running.');
+    }
+}
+//# sourceMappingURL=session.js.map

package/dist/cli.d.ts

@@ -0,0 +1,8 @@
+#!/usr/bin/env node
+/**
+ * ArchiCore CLI
+ *
+ * AI Software Architect - Interactive CLI
+ */
+import 'dotenv/config';
+//# sourceMappingURL=cli.d.ts.map