@vee-stack/delta-cli 2.0.8 → 2.0.10

package/dist/commands/analyze.d.ts

@@ -0,0 +1,12 @@
+interface AnalyzeOptions {
+    format: string;
+    output: string;
+    include?: string;
+    exclude?: string;
+    maxSize: string;
+    upload: boolean;
+    projectName?: string;
+}
+export declare function analyzeCommand(projectPath: string, options: AnalyzeOptions): Promise<void>;
+export {};
+//# sourceMappingURL=analyze.d.ts.map

package/dist/commands/auth-new.d.ts

@@ -0,0 +1,6 @@
+export declare function loginCommand(options: {
+    method?: string;
+    token?: string;
+}): Promise<void>;
+export declare function logoutCommand(): Promise<void>;
+//# sourceMappingURL=auth-new.d.ts.map

package/dist/commands/auth.d.ts

@@ -0,0 +1,17 @@
+interface LoginOptions {
+    token?: string;
+}
+interface AuthConfig {
+    apiUrl: string;
+    lastUsedAt?: string;
+}
+declare const CONFIG_FILE: string;
+declare function loadConfig(): Promise<Partial<AuthConfig>>;
+declare function saveConfig(config: AuthConfig): Promise<void>;
+export declare const authCommands: {
+    login(options: LoginOptions): Promise<void>;
+};
+export declare const loginCommand: (options: LoginOptions) => Promise<void>;
+export { loadConfig, saveConfig, CONFIG_FILE };
+export type { AuthConfig };
+//# sourceMappingURL=auth.d.ts.map

package/dist/commands/config.d.ts

@@ -0,0 +1,8 @@
+interface ConfigOptions {
+    get?: string;
+    set?: string;
+    list?: boolean;
+}
+export declare function configCommand(options: ConfigOptions): Promise<void>;
+export {};
+//# sourceMappingURL=config.d.ts.map

package/dist/commands/deploy.d.ts

@@ -0,0 +1,5 @@
+export declare function deployCommand(_options: {
+    build?: boolean;
+    domain?: string;
+}): Promise<void>;
+//# sourceMappingURL=deploy.d.ts.map

package/dist/commands/init.d.ts

@@ -0,0 +1,7 @@
+interface InitOptions {
+    template?: string;
+    force?: boolean;
+}
+export declare function initCommand(projectPath: string, options: InitOptions): Promise<void>;
+export {};
+//# sourceMappingURL=init.d.ts.map

package/dist/commands/logout.d.ts

@@ -0,0 +1,2 @@
+export declare function logoutCommand(): Promise<void>;
+//# sourceMappingURL=logout.d.ts.map

package/dist/commands/plugins.d.ts

@@ -0,0 +1,7 @@
+export declare function pluginsCommand(options: {
+    list?: boolean;
+    install?: string;
+    uninstall?: string;
+    search?: string;
+}): Promise<void>;
+//# sourceMappingURL=plugins.d.ts.map

package/dist/commands/status.d.ts

@@ -0,0 +1,5 @@
+export declare function statusCommand(projectPath: string, _options?: {
+    diagnostics?: boolean;
+    fix?: boolean;
+}): Promise<void>;
+//# sourceMappingURL=status.d.ts.map

package/dist/commands/sync.d.ts

@@ -0,0 +1,5 @@
+export declare function syncCommand(_options: {
+    watch?: boolean;
+    force?: boolean;
+}): Promise<void>;
+//# sourceMappingURL=sync.d.ts.map

package/dist/commands/whoami.d.ts

@@ -0,0 +1,4 @@
+export declare function whoamiCommand(_options?: {
+    format?: string;
+}): Promise<void>;
+//# sourceMappingURL=whoami.d.ts.map

package/dist/components/Dashboard.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Enhanced Dashboard Component
+ * Visual dashboard with project status, analysis reports, and charts
+ */
+import React from 'react';
+export declare const EnhancedDashboard: React.FC;
+export default EnhancedDashboard;
+//# sourceMappingURL=Dashboard.d.ts.map

package/dist/components/DeltaApp.d.ts

@@ -0,0 +1,13 @@
+import React from 'react';
+export declare const DeltaLogo: React.FC;
+export declare const DeltaApp: React.FC;
+export declare const LoadingScreen: React.FC<{
+    message?: string;
+}>;
+export declare const ErrorDisplay: React.FC<{
+    error: Error;
+}>;
+export declare const SuccessMessage: React.FC<{
+    message: string;
+}>;
+//# sourceMappingURL=DeltaApp.d.ts.map

package/dist/components/UnifiedManager.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Delta Unified Manager - Professional TUI Dashboard
+ * World-class integrated terminal interface
+ * Design matching GUI screenshot with sidebar, cards, and logs
+ * Features: Keyboard Shortcuts, Log Filtering, Persistent State, Plugin System
+ */
+import React from 'react';
+export declare const UnifiedManager: React.FC;
+export default UnifiedManager;
+//# sourceMappingURL=UnifiedManager.d.ts.map

package/dist/core/audit.d.ts

@@ -0,0 +1,60 @@
+/**
+ * Audit Logger for Delta CLI
+ * Tracks all commands, results, and performance metrics
+ * Enterprise-grade logging for compliance and debugging
+ */
+import type { TaskResponse } from './contracts.js';
+export interface AuditEntry {
+    id: string;
+    timestamp: string;
+    command: string;
+    args: string[];
+    options: Record<string, unknown>;
+    exitCode: number;
+    success: boolean;
+    duration: number;
+    provider: string;
+    user?: string;
+    project?: string;
+    error?: {
+        code: string;
+        message: string;
+    };
+    metadata?: {
+        nodeVersion: string;
+        platform: string;
+        cwd: string;
+        ci: boolean;
+    };
+}
+export interface AuditConfig {
+    enabled: boolean;
+    logLevel: 'minimal' | 'standard' | 'verbose';
+    retentionDays: number;
+    maxEntries: number;
+    includeMetadata: boolean;
+    remoteEndpoint?: string;
+}
+export declare class AuditLogger {
+    private config;
+    private initialized;
+    constructor();
+    initialize(): Promise<void>;
+    logCommand(command: string, args: string[], options: Record<string, unknown>, response: TaskResponse, startTime: number): Promise<void>;
+    getRecentEntries(limit?: number): Promise<AuditEntry[]>;
+    getStats(): Promise<{
+        totalCommands: number;
+        successRate: number;
+        avgDuration: number;
+        mostUsed: string[];
+        lastUsed: string;
+    }>;
+    private appendEntry;
+    private sendRemote;
+    private sanitizeOptions;
+    private generateId;
+    cleanup(): Promise<void>;
+}
+export declare function getAuditLogger(): AuditLogger;
+export declare function resetAuditLogger(): void;
+//# sourceMappingURL=audit.d.ts.map

package/dist/core/completion.d.ts

@@ -0,0 +1,79 @@
+/**
+ * Tab Autocomplete System for Delta CLI
+ * Provides shell completion for commands, flags, and options
+ */
+export declare const completionDatabase: {
+    commands: {
+        name: string;
+        alias: string[];
+        desc: string;
+    }[];
+    globalFlags: ({
+        name: string;
+        desc: string;
+        values?: undefined;
+        alias?: undefined;
+    } | {
+        name: string;
+        values: string[];
+        desc: string;
+        alias?: undefined;
+    } | {
+        name: string;
+        alias: string;
+        desc: string;
+        values?: undefined;
+    })[];
+    commandFlags: {
+        analyze: ({
+            name: string;
+            values: string[];
+            desc: string;
+        } | {
+            name: string;
+            desc: string;
+            values?: undefined;
+        })[];
+        init: ({
+            name: string;
+            values: string[];
+            desc: string;
+            alias?: undefined;
+        } | {
+            name: string;
+            alias: string;
+            desc: string;
+            values?: undefined;
+        } | {
+            name: string;
+            desc: string;
+            values?: undefined;
+            alias?: undefined;
+        })[];
+        status: {
+            name: string;
+            desc: string;
+        }[];
+        login: ({
+            name: string;
+            values: string[];
+            desc: string;
+        } | {
+            name: string;
+            desc: string;
+            values?: undefined;
+        })[];
+        config: ({
+            name: string;
+            desc: string;
+            alias?: undefined;
+        } | {
+            name: string;
+            alias: string;
+            desc: string;
+        })[];
+    };
+};
+export declare function generateCompletionScript(shell: 'bash' | 'zsh' | 'fish' | 'powershell'): string;
+export declare function installCompletion(shell?: string): Promise<void>;
+//# sourceMappingURL=completion.d.ts.map

package/dist/core/contracts.d.ts

@@ -0,0 +1,127 @@
+/**
+ * Core Contracts - Interface definitions for Delta CLI
+ * AI-Ready Architecture: Separate CLI from Business Logic
+ */
+import { ExitCode } from './exit-codes.js';
+export type TaskType = 'analyze' | 'init' | 'status' | 'sync' | 'deploy' | 'config' | 'auth' | 'plugin';
+export interface ProviderCapabilities {
+    commands: TaskType[];
+    features: {
+        json: boolean;
+        streaming: boolean;
+        caching: boolean;
+        ai: boolean;
+    };
+    constraints?: {
+        maxFileSize?: number;
+        maxFiles?: number;
+        requiresAuth?: boolean;
+    };
+}
+export interface TaskRequest {
+    type: TaskType;
+    command: string;
+    payload: Record<string, unknown>;
+    options: {
+        json?: boolean;
+        nonInteractive?: boolean;
+        provider?: 'local' | 'remote' | 'ai';
+        [key: string]: unknown;
+    };
+}
+export interface TaskResponse {
+    success: boolean;
+    exitCode: ExitCode;
+    meta: {
+        command: string;
+        duration: number;
+        timestamp: string;
+        version: string;
+        coldStart?: number;
+        provider: string;
+    };
+    data?: Record<string, unknown>;
+    error?: {
+        code: string;
+        message: string;
+        details?: Record<string, unknown>;
+    };
+}
+export interface ExecutionProvider {
+    readonly name: string;
+    readonly version: string;
+    readonly capabilities: ProviderCapabilities;
+    isAvailable(): Promise<boolean>;
+    execute(request: TaskRequest): Promise<TaskResponse>;
+}
+export interface AIProvider extends ExecutionProvider {
+    generate?(input: string, context?: Record<string, unknown>): Promise<string>;
+    analyzeCode?(code: string, language: string): Promise<{
+        insights: string[];
+        suggestions: string[];
+        score: number;
+    }>;
+}
+export interface EngineConfig {
+    defaultProvider: 'local' | 'remote';
+    providers: {
+        local: LocalProviderConfig;
+        remote?: RemoteProviderConfig;
+        ai?: AIProviderConfig;
+    };
+    features: {
+        cache: boolean;
+        offlineMode: boolean;
+        autoUpdate: boolean;
+    };
+}
+export interface LocalProviderConfig {
+    enabled: boolean;
+    maxFileSize: number;
+    excludePatterns: string[];
+    cacheDir?: string;
+}
+export interface RemoteProviderConfig {
+    enabled: boolean;
+    apiUrl: string;
+    timeout: number;
+    retryAttempts: number;
+}
+export interface AIProviderConfig {
+    enabled: boolean;
+    provider: 'openai' | 'anthropic' | 'local';
+    model?: string;
+    apiKey?: string;
+}
+export type EngineEvent = {
+    type: 'task:start';
+    request: TaskRequest;
+} | {
+    type: 'task:progress';
+    request: TaskRequest;
+    progress: number;
+} | {
+    type: 'task:complete';
+    request: TaskRequest;
+    response: TaskResponse;
+} | {
+    type: 'task:error';
+    request: TaskRequest;
+    error: Error;
+};
+export type EngineEventListener = (event: EngineEvent) => void;
+export interface ExecutionPolicy {
+    validate(request: TaskRequest): {
+        valid: boolean;
+        reason?: string;
+        exitCode?: ExitCode;
+    };
+    selectProvider(request: TaskRequest, providers: Map<string, ExecutionProvider>): ExecutionProvider | null;
+    transform?(request: TaskRequest): TaskRequest;
+    checkCapabilities?(request: TaskRequest): {
+        allowed: boolean;
+        reason?: string;
+        exitCode?: ExitCode;
+    };
+}
+//# sourceMappingURL=contracts.d.ts.map

package/dist/core/engine.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Delta Engine - Core Execution Engine
+ * Mediator between CLI and Execution Providers
+ */
+import { TaskRequest, TaskResponse, ExecutionProvider, EngineConfig, EngineEvent, EngineEventListener, ExecutionPolicy } from './contracts.js';
+export declare class DeltaEngine {
+    private providers;
+    private config;
+    private policy;
+    private listeners;
+    private version;
+    constructor(config: EngineConfig, policy: ExecutionPolicy);
+    registerProvider(provider: ExecutionProvider): void;
+    getProvider(name: string): ExecutionProvider | undefined;
+    execute(request: TaskRequest): Promise<TaskResponse>;
+    on(_event: EngineEvent['type'], listener: EngineEventListener): void;
+    private emit;
+    getStatus(): {
+        version: string;
+        providers: string[];
+        defaultProvider: string;
+    };
+}
+export declare function createEngine(config: EngineConfig, policy: ExecutionPolicy): DeltaEngine;
+export declare function getEngine(): DeltaEngine | null;
+//# sourceMappingURL=engine.d.ts.map

package/dist/core/exit-codes.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Exit Code Contract - Enterprise-grade error classification
+ * Critical for CI/CD integration and automation
+ */
+export declare enum ExitCode {
+    SUCCESS = 0,// Everything worked correctly
+    VALIDATION_ERROR = 1,// Invalid input, missing arguments, bad config
+    NETWORK_ERROR = 2,// Connection issues, API unreachable
+    AUTH_ERROR = 3,// Authentication/authorization failure
+    POLICY_BLOCKED = 4,// Blocked by policy (quota, permissions, etc.)
+    EXECUTION_ERROR = 5,// Runtime error during execution
+    UNKNOWN_ERROR = 6
+}
+export declare function getExitCode(error: Error | string | {
+    code?: string;
+    message?: string;
+}): ExitCode;
+export declare const ExitCodeDescription: Record<ExitCode, string>;
+//# sourceMappingURL=exit-codes.d.ts.map

package/dist/core/hooks.d.ts

@@ -0,0 +1,50 @@
+/**
+ * Hooks & Notifications System
+ * Post-command hooks for Slack, Teams, Webhooks
+ * Enterprise CI/CD integration
+ */
+import type { TaskResponse } from './contracts.js';
+export type HookType = 'post-success' | 'post-failure' | 'post-always';
+export interface Hook {
+    id: string;
+    name: string;
+    type: HookType;
+    command?: string;
+    url: string;
+    method: 'POST' | 'GET';
+    headers?: Record<string, string>;
+    payload?: string;
+    enabled: boolean;
+}
+export interface NotificationPayload {
+    command: string;
+    success: boolean;
+    exitCode: number;
+    duration: number;
+    timestamp: string;
+    project?: string;
+    user?: string;
+    error?: string;
+    summary?: string;
+}
+export declare class HookManager {
+    private hooks;
+    private loaded;
+    load(): Promise<void>;
+    save(): Promise<void>;
+    addHook(hook: Omit<Hook, 'id'>): Promise<Hook>;
+    removeHook(id: string): Promise<void>;
+    listHooks(): Promise<Hook[]>;
+    toggleHook(id: string): Promise<void>;
+    executeHooks(type: HookType, command: string, response: TaskResponse, startTime: number): Promise<void>;
+    private sendNotification;
+    private renderTemplate;
+    private generateSummary;
+}
+export declare const hookTemplates: {
+    slack: (webhookUrl: string) => Omit<Hook, "id">;
+    teams: (webhookUrl: string) => Omit<Hook, "id">;
+    generic: (url: string) => Omit<Hook, "id">;
+};
+export declare function getHookManager(): HookManager;
+//# sourceMappingURL=hooks.d.ts.map

package/dist/{apps/cli/src/core/index.js → core/index.d.ts}

@@ -4,4 +4,4 @@
 export * from './contracts.js';
 export * from './engine.js';
 export * from './policy.js';
-//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.d.ts.map

package/dist/core/policy.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Default Execution Policy
+ * Determines how tasks are executed and which provider to use
+ */
+import { TaskRequest, ExecutionPolicy, EngineConfig, ExecutionProvider } from './contracts.js';
+import { ExitCode } from './exit-codes.js';
+export declare class DefaultExecutionPolicy implements ExecutionPolicy {
+    private config;
+    constructor(config: EngineConfig);
+    validate(request: TaskRequest): {
+        valid: boolean;
+        reason?: string;
+        exitCode?: ExitCode;
+    };
+    selectProvider(request: TaskRequest, providers: Map<string, ExecutionProvider>): ExecutionProvider | null;
+    private getPreferredProvider;
+    transform(request: TaskRequest): TaskRequest;
+    checkCapabilities(_request: TaskRequest): {
+        allowed: boolean;
+        reason?: string;
+        exitCode?: ExitCode;
+    };
+}
+//# sourceMappingURL=policy.d.ts.map

package/dist/core/profiles.d.ts

@@ -0,0 +1,45 @@
+/**
+ * Profile Management System
+ * Manage multiple environments: dev, staging, prod
+ * Auto-select provider and settings based on active profile
+ */
+export type ProfileName = 'dev' | 'staging' | 'prod' | 'local' | string;
+export interface ProfileConfig {
+    name: ProfileName;
+    provider: 'local' | 'remote' | 'ai';
+    apiUrl?: string;
+    apiKey?: string;
+    timeout: number;
+    retries: number;
+    features: {
+        analytics: boolean;
+        caching: boolean;
+        autoSync: boolean;
+    };
+    env: Record<string, string>;
+}
+export interface ProfilesData {
+    activeProfile: ProfileName;
+    profiles: Record<ProfileName, ProfileConfig>;
+}
+export declare class ProfileManager {
+    private data;
+    private loaded;
+    constructor();
+    load(): Promise<void>;
+    save(): Promise<void>;
+    getActiveProfile(): ProfileConfig;
+    getProfile(name: ProfileName): ProfileConfig | undefined;
+    setActiveProfile(name: ProfileName): Promise<void>;
+    createProfile(name: ProfileName, config: Partial<ProfileConfig>): Promise<void>;
+    deleteProfile(name: ProfileName): Promise<void>;
+    listProfiles(): Array<{
+        name: ProfileName;
+        active: boolean;
+        provider: string;
+    }>;
+    applyToEnvironment(): void;
+    getProviderForCommand(command: string): 'local' | 'remote' | 'ai';
+}
+export declare function getProfileManager(): ProfileManager;
+//# sourceMappingURL=profiles.d.ts.map

package/dist/core/wizard.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Interactive Wizard Mode
+ * Step-by-step guided experience for complex commands
+ */
+export interface WizardStep {
+    name: string;
+    message: string;
+    type: 'text' | 'select' | 'multiselect' | 'confirm' | 'toggle';
+    choices?: Array<{
+        title: string;
+        value: string;
+        description?: string;
+    }>;
+    initial?: string | boolean;
+    validate?: (value: string) => boolean | string;
+}
+export interface InitWizardResult {
+    projectName: string;
+    projectPath: string;
+    template: string;
+    initializeGit: boolean;
+    installDependencies: boolean;
+    features: string[];
+}
+export declare function runInitWizard(): Promise<InitWizardResult>;
+export declare function executeWizardActions(result: InitWizardResult): Promise<void>;
+export declare function runQuickWizard(command: string): Promise<Record<string, unknown> | null>;
+//# sourceMappingURL=wizard.d.ts.map

package/dist/interactive/index.d.ts

@@ -0,0 +1,5 @@
+export declare function runInteractiveMode(options: {
+    port?: string;
+    mode?: 'app' | 'manager';
+}): Promise<void>;
+//# sourceMappingURL=index.d.ts.map

package/dist/plugins/GitStatusPlugin.d.ts

@@ -0,0 +1,25 @@
+/**
+ * GitStatusPlugin - MVP Plugin Example
+ * Displays git repository status in the sidebar
+ * Demonstrates Plugin System capabilities
+ */
+import type { DeltaPlugin, PluginCommand, DashboardWidget, PluginContext } from '@delta/domain';
+export declare class GitStatusPlugin implements DeltaPlugin {
+    id: string;
+    name: string;
+    version: string;
+    description: string;
+    private context;
+    private branch;
+    private status;
+    private aheadBehind;
+    constructor(context: PluginContext);
+    onActivate(): void;
+    onDeactivate(): void;
+    registerCommands(): PluginCommand[];
+    registerDashboardWidgets(): DashboardWidget[];
+    private updateGitStatus;
+    private renderWidget;
+}
+export default GitStatusPlugin;
+//# sourceMappingURL=GitStatusPlugin.d.ts.map

package/dist/providers/ai-provider.d.ts

@@ -0,0 +1,21 @@
+/**
+ * AI Provider (Placeholder)
+ * Reserved for future AI integration without breaking existing architecture
+ */
+import { TaskRequest, TaskResponse, AIProvider, ProviderCapabilities, AIProviderConfig } from '../core/contracts.js';
+export declare class AIProviderPlaceholder implements AIProvider {
+    readonly name = "ai";
+    readonly version = "2.0.0-placeholder";
+    readonly capabilities: ProviderCapabilities;
+    private config;
+    constructor(config: AIProviderConfig);
+    isAvailable(): Promise<boolean>;
+    execute(request: TaskRequest): Promise<TaskResponse>;
+    generate(input: string, _context?: Record<string, unknown>): Promise<string>;
+    analyzeCode(_code: string, _language: string): Promise<{
+        insights: string[];
+        suggestions: string[];
+        score: number;
+    }>;
+}
+//# sourceMappingURL=ai-provider.d.ts.map