@vee-stack/delta-cli 2.0.8 → 2.0.10

package/dist/adapters/analysis.adapter.d.ts

@@ -0,0 +1,29 @@
+/**
+ * CLI Analysis Adapter
+ * @description Bridges CLI commands with Domain Layer analysis engine
+ * @package apps/cli
+ */
+import { analyze, type AnalysisOptions, type CoreAnalysisResult } from '@delta/domain';
+export type { AnalysisOptions, CoreAnalysisResult as AnalysisResult, } from '@delta/domain';
+/**
+ * Analyze a project using Domain Layer engine
+ * Replaces local validators with unified Domain analysis
+ */
+export declare function analyzeProject(projectPath: string, options?: Partial<AnalysisOptions>): Promise<CoreAnalysisResult>;
+/**
+ * Generate report from analysis results
+ */
+export declare function generateAnalysisReport(result: CoreAnalysisResult, format?: 'json' | 'html' | 'markdown'): Promise<{
+    id: string;
+    content: string;
+    format: string;
+}>;
+/**
+ * Create analysis session for progress tracking
+ */
+export declare function createAnalysisSession(config: any, policies: any): import("@delta/domain/core/analysis/engine").AnalysisSession;
+/**
+ * Direct engine access for advanced use cases
+ */
+export { analyze as runDirectAnalysis };
+//# sourceMappingURL=analysis.adapter.d.ts.map

package/dist/analyzer/commands/analyze.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Analyze Command
+ * @description Main analysis command using Domain Layer engine
+ */
+interface AnalyzeOptions {
+    language: string;
+    output: string;
+    depth: string;
+    config?: string;
+    strict: boolean;
+}
+export declare function analyzeCommand(projectPath: string, options: AnalyzeOptions): Promise<void>;
+export {};
+//# sourceMappingURL=analyze.d.ts.map

package/dist/analyzer/commands/config.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Config Command
+ * @description Manage analyzer configuration
+ */
+interface ConfigOptions {
+    init?: boolean;
+    show?: boolean;
+    set?: string;
+}
+export declare function configCommand(options: ConfigOptions): Promise<void>;
+export {};
+//# sourceMappingURL=config.d.ts.map

package/dist/analyzer/commands/report.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Report Command
+ * @description Generate report from previous analysis
+ */
+interface ReportOptions {
+    template: string;
+    output?: string;
+}
+export declare function reportCommand(analysisFile: string, options: ReportOptions): Promise<void>;
+export {};
+//# sourceMappingURL=report.d.ts.map

package/dist/analyzer/generators/report.generator.d.ts

@@ -0,0 +1,43 @@
+/**
+ * Report Generator
+ * @description Generates analysis reports in various formats
+ */
+interface AnalysisResult {
+    project: {
+        name: string;
+        path: string;
+        language: string;
+        fileCount: number;
+    };
+    timestamp: string;
+    overall: {
+        score: number;
+        percentage: number;
+        grade: string;
+        compliant: boolean;
+    };
+    scores: Record<string, {
+        score: number;
+        maxScore: number;
+        percentage: number;
+        weight: number;
+    }>;
+    violations: Array<{
+        id: string;
+        axis: string;
+        severity: string;
+        message: string;
+    }>;
+    recommendations: Array<{
+        axis: string;
+        priority: string;
+        description: string;
+        action: string;
+    }>;
+}
+export declare class ReportGenerator {
+    static generateHTML(result: AnalysisResult): string;
+    static generateMarkdown(result: AnalysisResult): string;
+}
+export {};
+//# sourceMappingURL=report.generator.d.ts.map

package/dist/analyzer/index.d.ts

@@ -0,0 +1,8 @@
+#!/usr/bin/env node
+/**
+ * Delta CLI Analyzer
+ * @description Analyze projects against Delta Constitution
+ * @version 1.0.0
+ */
+export {};
+//# sourceMappingURL=index.d.ts.map

package/dist/analyzer/scanners/project.scanner.d.ts

@@ -0,0 +1,29 @@
+/**
+ * Project Scanner
+ * @description Scans project structure and extracts metadata
+ */
+export interface ProjectInfo {
+    path: string;
+    name: string;
+    language: string;
+    size: number;
+    fileCount: number;
+    files: string[];
+    directories: string[];
+    imports: ImportInfo[];
+    hasPackageJson: boolean;
+    hasTsConfig: boolean;
+    hasTests: boolean;
+}
+export interface ImportInfo {
+    source: string;
+    target: string;
+    type: 'internal' | 'external';
+}
+export declare class ProjectScanner {
+    static scan(projectPath: string, language: string): Promise<ProjectInfo>;
+    private static scanDirectory;
+    private static isSourceFile;
+    private static extractImports;
+}
+//# sourceMappingURL=project.scanner.d.ts.map

package/dist/analyzer/validators/contracts.validator.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Contracts Validator
+ * @description Validates Contracts rules
+ */
+import { ProjectInfo } from '../scanners/project.scanner';
+interface ValidationOptions {
+    depth: string;
+}
+interface ValidationResult {
+    score: number;
+    maxScore: number;
+    percentage: number;
+    violations: Violation[];
+}
+interface Violation {
+    id: string;
+    severity: 'critical' | 'error' | 'warning' | 'info';
+    message: string;
+    file?: string;
+    line?: number;
+    rule: string;
+}
+export declare class ContractsValidator {
+    static validate(project: ProjectInfo, _options: ValidationOptions): Promise<ValidationResult>;
+}
+export {};
+//# sourceMappingURL=contracts.validator.d.ts.map

package/dist/analyzer/validators/maintainability.validator.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Maintainability Validator
+ * @description Validates Maintainability rules
+ */
+import { ProjectInfo } from '../scanners/project.scanner';
+interface ValidationOptions {
+    depth: string;
+}
+interface ValidationResult {
+    score: number;
+    maxScore: number;
+    percentage: number;
+    violations: Violation[];
+}
+interface Violation {
+    id: string;
+    severity: 'critical' | 'error' | 'warning' | 'info';
+    message: string;
+    file?: string;
+    line?: number;
+    rule: string;
+}
+export declare class MaintainabilityValidator {
+    static validate(project: ProjectInfo, _options: ValidationOptions): Promise<ValidationResult>;
+}
+export {};
+//# sourceMappingURL=maintainability.validator.d.ts.map

package/dist/analyzer/validators/observability.validator.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Observability Validator
+ * @description Validates Observability rules
+ */
+import { ProjectInfo } from '../scanners/project.scanner';
+interface ValidationOptions {
+    depth: string;
+}
+interface ValidationResult {
+    score: number;
+    maxScore: number;
+    percentage: number;
+    violations: Violation[];
+}
+interface Violation {
+    id: string;
+    severity: 'critical' | 'error' | 'warning' | 'info';
+    message: string;
+    file?: string;
+    line?: number;
+    rule: string;
+}
+export declare class ObservabilityValidator {
+    static validate(project: ProjectInfo, _options: ValidationOptions): Promise<ValidationResult>;
+}
+export {};
+//# sourceMappingURL=observability.validator.d.ts.map

package/dist/analyzer/validators/performance.validator.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Performance Validator
+ * @description Validates performance rules
+ */
+import { ProjectInfo } from '../scanners/project.scanner';
+interface ValidationOptions {
+    depth: string;
+}
+interface ValidationResult {
+    score: number;
+    maxScore: number;
+    percentage: number;
+    violations: Violation[];
+}
+interface Violation {
+    id: string;
+    severity: 'critical' | 'error' | 'warning' | 'info';
+    message: string;
+    file?: string;
+    line?: number;
+    rule: string;
+}
+export declare class PerformanceValidator {
+    static validate(project: ProjectInfo, _options: ValidationOptions): Promise<ValidationResult>;
+}
+export {};
+//# sourceMappingURL=performance.validator.d.ts.map

package/dist/analyzer/validators/security.validator.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Security Validator
+ * @description Validates security rules against project
+ */
+import { ProjectInfo } from '../scanners/project.scanner';
+interface ValidationOptions {
+    depth: string;
+}
+interface ValidationResult {
+    score: number;
+    maxScore: number;
+    percentage: number;
+    violations: Violation[];
+}
+interface Violation {
+    id: string;
+    severity: 'critical' | 'error' | 'warning' | 'info';
+    message: string;
+    file?: string;
+    line?: number;
+    rule: string;
+}
+export declare class SecurityValidator {
+    static validate(project: ProjectInfo, options: ValidationOptions): Promise<ValidationResult>;
+}
+export {};
+//# sourceMappingURL=security.validator.d.ts.map

package/dist/analyzer/validators/soc.validator.d.ts

@@ -0,0 +1,27 @@
+/**
+ * SoC Validator
+ * @description Validates Separation of Concerns rules
+ */
+import { ProjectInfo } from '../scanners/project.scanner';
+interface ValidationOptions {
+    depth: string;
+}
+interface ValidationResult {
+    score: number;
+    maxScore: number;
+    percentage: number;
+    violations: Violation[];
+}
+interface Violation {
+    id: string;
+    severity: 'critical' | 'error' | 'warning' | 'info';
+    message: string;
+    file?: string;
+    line?: number;
+    rule: string;
+}
+export declare class SocValidator {
+    static validate(project: ProjectInfo, _options: ValidationOptions): Promise<ValidationResult>;
+}
+export {};
+//# sourceMappingURL=soc.validator.d.ts.map

package/dist/auth/device-auth.d.ts

@@ -0,0 +1,18 @@
+export declare class DeviceAuthorizationFlow {
+    private apiUrl;
+    private clientId;
+    constructor(apiUrl: string, clientId?: string);
+    startDeviceFlow(): Promise<boolean>;
+    private requestDeviceCode;
+    private displayAuthorizationInstructions;
+    private openBrowser;
+    private executeCommand;
+    private pollForToken;
+    private saveTokens;
+    private showSuccess;
+    private handleError;
+    private makeRequest;
+    private sleep;
+}
+export declare function startDeviceFlow(apiUrl: string): Promise<boolean>;
+//# sourceMappingURL=device-auth.d.ts.map

package/dist/auth/secure-auth.d.ts

@@ -0,0 +1,35 @@
+/**
+ * Secure Authentication System with OAuth2 + Keychain Integration
+ * Features:
+ * - OAuth2 PKCE flow
+ * - Secure token storage in OS keychain
+ * - Automatic token refresh
+ * - Session management
+ * - PAT (Personal Access Token) support for CI/CD
+ */
+export declare class SecureTokenStore {
+    private static saveTokens;
+    private static loadTokens;
+    static saveAccessToken(token: string): Promise<void>;
+    static getAccessToken(): Promise<string | null>;
+    static saveRefreshToken(token: string): Promise<void>;
+    static saveSessionInfo(sessionInfo: {
+        session_id: string;
+        expires_at: string;
+    }): Promise<void>;
+    static getRefreshToken(): Promise<string | null>;
+    static clearTokens(): Promise<void>;
+    static hasTokens(): Promise<boolean>;
+}
+export declare function startOAuthFlow(method?: string): Promise<boolean>;
+export declare function authenticateWithPAT(token: string): Promise<boolean>;
+export declare function refreshAccessToken(): Promise<boolean>;
+export declare function logout(): Promise<void>;
+export declare function getAuthStatus(): Promise<{
+    authenticated: boolean;
+    user?: {
+        email: string;
+        plan: string;
+    };
+}>;
+//# sourceMappingURL=secure-auth.d.ts.map