@vee-stack/delta-cli 2.0.4 → 2.0.5

package/dist/core/completion.js

@@ -0,0 +1,294 @@
+/**
+ * Tab Autocomplete System for Delta CLI
+ * Provides shell completion for commands, flags, and options
+ */
+// Completion items database
+export const completionDatabase = {
+    commands: [
+        { name: 'help', alias: ['/?', '/h'], desc: 'Show help' },
+        { name: 'analyze', alias: ['/a', '/analyze'], desc: 'Code analysis' },
+        { name: 'init', alias: ['/i', '/init'], desc: 'Initialize project' },
+        { name: 'status', alias: ['/st', '/status'], desc: 'Check status' },
+        { name: 'login', alias: ['/login'], desc: 'Authenticate' },
+        { name: 'logout', alias: ['/logout'], desc: 'Sign out' },
+        { name: 'whoami', alias: ['/me', '/whoami'], desc: 'User info' },
+        { name: 'config', alias: ['/config'], desc: 'Configuration' },
+        { name: 'dashboard', alias: ['/ui', '/dashboard'], desc: 'Interactive UI' },
+        { name: 'sync', alias: ['/sync'], desc: 'Cloud sync' },
+        { name: 'deploy', alias: ['/deploy'], desc: 'Deploy project' },
+        { name: 'plugins', alias: ['/plugins'], desc: 'Manage plugins' },
+    ],
+    globalFlags: [
+        { name: '--json', desc: 'Output as JSON' },
+        { name: '--provider', values: ['local', 'remote', 'ai'], desc: 'Execution provider' },
+        { name: '--theme', values: ['delta', 'cyber', 'sunset', 'neon', 'ocean', 'fire'], desc: 'Color theme' },
+        { name: '--verbose', desc: 'Verbose logging' },
+        { name: '--no-color', desc: 'Disable colors' },
+        { name: '--interactive', alias: '-i', desc: 'Interactive mode' },
+        { name: '--version', alias: '-v', desc: 'Show version' },
+        { name: '--help', alias: '-h', desc: 'Show help' },
+    ],
+    commandFlags: {
+        analyze: [
+            { name: '--format', values: ['json', 'html', 'markdown', 'sarif'], desc: 'Output format' },
+            { name: '--output', values: ['./delta-reports'], desc: 'Output directory' },
+            { name: '--include', desc: 'Include patterns' },
+            { name: '--exclude', desc: 'Exclude patterns' },
+            { name: '--max-size', desc: 'Max file size' },
+            { name: '--upload', desc: 'Upload to cloud' },
+            { name: '--share', desc: 'Generate shareable link' },
+            { name: '--project-name', desc: 'Project name' },
+            { name: '--ai-insights', desc: 'AI insights' },
+            { name: '--security-scan', desc: 'Security scan' },
+            { name: '--performance', desc: 'Performance analysis' },
+        ],
+        init: [
+            { name: '--template', values: ['default', 'nextjs', 'react', 'node', 'python'], desc: 'Project template' },
+            { name: '--force', alias: '-f', desc: 'Overwrite existing' },
+            { name: '--git', desc: 'Initialize git' },
+        ],
+        status: [
+            { name: '--diagnostics', desc: 'Full diagnostics' },
+            { name: '--fix', desc: 'Auto-fix issues' },
+        ],
+        login: [
+            { name: '--method', values: ['oauth', 'pat', 'github', 'google'], desc: 'Auth method' },
+            { name: '--token', desc: 'PAT token' },
+        ],
+        config: [
+            { name: '--get', desc: 'Get config value' },
+            { name: '--set', desc: 'Set config value' },
+            { name: '--list', alias: '-l', desc: 'List all config' },
+            { name: '--reset', desc: 'Reset to default' },
+        ],
+    },
+};
+// Generate shell completion script
+export function generateCompletionScript(shell) {
+    const cliName = 'delta';
+    switch (shell) {
+        case 'bash':
+            return generateBashCompletion(cliName);
+        case 'zsh':
+            return generateZshCompletion(cliName);
+        case 'fish':
+            return generateFishCompletion(cliName);
+        case 'powershell':
+            return generatePowershellCompletion(cliName);
+        default:
+            throw new Error(`Unsupported shell: ${shell}`);
+    }
+}
+function generateBashCompletion(cliName) {
+    const commands = completionDatabase.commands.map(c => c.name).join(' ');
+    const slashCommands = completionDatabase.commands.flatMap(c => c.alias).filter(a => a.startsWith('/')).join(' ');
+    return `#!/bin/bash
+# Delta CLI Bash Completion
+# Source this file: source <(delta completion bash)
+
+_${cliName}_completions() {
+  local cur prev opts
+  COMPREPLY=()
+  cur="\${COMP_WORDS[COMP_CWORD]}"
+  prev="\${COMP_WORDS[COMP_CWORD-1]}"
+  
+  # Commands list
+  local commands="${commands} ${slashCommands}"
+  local global_flags="--json --provider --theme --verbose --no-color --interactive --version --help -i -v -h"
+  
+  # Complete commands
+  if [[ \${COMP_CWORD} -eq 1 ]]; then
+    COMPREPLY=( $(compgen -W "\${commands} \${global_flags}" -- \${cur}) )
+    return 0
+  fi
+  
+  # Complete flags based on command
+  case "\${COMP_WORDS[1]}" in
+    analyze|/a|/analyze)
+      opts="--format --output --include --exclude --max-size --upload --share --project-name --ai-insights --security-scan --performance --json --provider"
+      ;;
+    init|/i|/init)
+      opts="--template --force --git --json --provider -f"
+      ;;
+    status|/st|/status)
+      opts="--diagnostics --fix --json"
+      ;;
+    login|/login)
+      opts="--method --token --json"
+      ;;
+    config|/config)
+      opts="--get --set --list --reset -l --json"
+      ;;
+    *)
+      opts="\${global_flags}"
+      ;;
+  esac
+  
+  # Complete flag values
+  case "\${prev}" in
+    --provider)
+      COMPREPLY=( $(compgen -W "local remote ai" -- \${cur}) )
+      return 0
+      ;;
+    --theme)
+      COMPREPLY=( $(compgen -W "delta cyber sunset neon ocean fire" -- \${cur}) )
+      return 0
+      ;;
+    --format)
+      COMPREPLY=( $(compgen -W "json html markdown sarif" -- \${cur}) )
+      return 0
+      ;;
+    --template)
+      COMPREPLY=( $(compgen -W "default nextjs react node python" -- \${cur}) )
+      return 0
+      ;;
+    --method)
+      COMPREPLY=( $(compgen -W "oauth pat github google" -- \${cur}) )
+      return 0
+      ;;
+  esac
+  
+  COMPREPLY=( $(compgen -W "\${opts}" -- \${cur}) )
+  return 0
+}
+
+complete -F _${cliName}_completions ${cliName}
+`;
+}
+function generateZshCompletion(cliName) {
+    return `#compdef ${cliName}
+# Delta CLI Zsh Completion
+
+_${cliName}() {
+  local curcontext="$curcontext" state line
+  typeset -A opt_args
+  
+  _arguments -C \\
+    '(-h --help)'{-h,--help}'[Show help]' \\
+    '(-v --version)'{-v,--version}'[Show version]' \\
+    '(-i --interactive)'{-i,--interactive}'[Interactive mode]' \\
+    '--json[Output as JSON]' \\
+    '--provider[Execution provider]:provider:(local remote ai)' \\
+    '--theme[Color theme]:theme:(delta cyber sunset neon ocean fire)' \\
+    '--verbose[Verbose logging]' \\
+    '--no-color[Disable colors]' \\
+    '1: :->command' \\
+    '*:: :->args'
+  
+  case "$state" in
+    command)
+      _values 'commands' \\
+        'help[Show help]' \\
+        'analyze[Code analysis]' \\
+        'init[Initialize project]' \\
+        'status[Check status]' \\
+        'login[Authenticate]' \\
+        'logout[Sign out]' \\
+        'whoami[User info]' \\
+        'config[Configuration]' \\
+        'dashboard[Interactive UI]' \\
+        'sync[Cloud sync]' \\
+        'deploy[Deploy project]' \\
+        'plugins[Manage plugins]'
+      ;;
+    args)
+      case "$line[1]" in
+        analyze)
+          _arguments \\
+            '--format[Output format]:format:(json html markdown sarif)' \\
+            '--output[Output directory]' \\
+            '--include[Include patterns]' \\
+            '--exclude[Exclude patterns]' \\
+            '--upload[Upload to cloud]' \\
+            '--share[Generate shareable link]' \\
+            '--project-name[Project name]'
+          ;;
+        init)
+          _arguments \\
+            '--template[Project template]:template:(default nextjs react node python)' \\
+            '(-f --force)'{-f,--force}'[Overwrite existing]' \\
+            '--git[Initialize git]'
+          ;;
+        status)
+          _arguments \\
+            '--diagnostics[Full diagnostics]' \\
+            '--fix[Auto-fix issues]'
+          ;;
+      esac
+      ;;
+  esac
+}
+
+_${cliName} "$@"
+`;
+}
+function generateFishCompletion(cliName) {
+    return `# Delta CLI Fish Completion
+
+# Commands
+complete -c ${cliName} -f
+complete -c ${cliName} -n '__fish_use_subcommand' -a 'help' -d 'Show help'
+complete -c ${cliName} -n '__fish_use_subcommand' -a 'analyze' -d 'Code analysis'
+complete -c ${cliName} -n '__fish_use_subcommand' -a 'init' -d 'Initialize project'
+complete -c ${cliName} -n '__fish_use_subcommand' -a 'status' -d 'Check status'
+complete -c ${cliName} -n '__fish_use_subcommand' -a 'login' -d 'Authenticate'
+complete -c ${cliName} -n '__fish_use_subcommand' -a 'logout' -d 'Sign out'
+
+# Global flags
+complete -c ${cliName} -l json -d 'Output as JSON'
+complete -c ${cliName} -l provider -d 'Execution provider' -xa 'local remote ai'
+complete -c ${cliName} -l theme -d 'Color theme' -xa 'delta cyber sunset neon ocean fire'
+complete -c ${cliName} -l verbose -d 'Verbose logging'
+complete -c ${cliName} -l no-color -d 'Disable colors'
+complete -c ${cliName} -s i -l interactive -d 'Interactive mode'
+complete -c ${cliName} -s v -l version -d 'Show version'
+complete -c ${cliName} -s h -l help -d 'Show help'
+`;
+}
+function generatePowershellCompletion(cliName) {
+    return `# Delta CLI PowerShell Completion
+# Add to $PROFILE: . delta completion powershell | Out-String | Invoke-Expression
+
+Register-ArgumentCompleter -Native -CommandName ${cliName} -ScriptBlock {
+  param($wordToComplete, $commandAst, $cursorPosition)
+  
+  $commands = @('help', 'analyze', 'init', 'status', 'login', 'logout', 'whoami', 'config', 'dashboard', 'sync', 'deploy', 'plugins')
+  $slashCommands = @('/help', '/h', '/analyze', '/a', '/init', '/i', '/status', '/st', '/login', '/logout', '/me', '/whoami', '/config', '/ui', '/sync', '/deploy', '/plugins')
+  
+  $command = $commandAst.CommandElements[1].Value
+  
+  if ($commandAst.CommandElements.Count -eq 1 -or 
+      ($commandAst.CommandElements.Count -eq 2 -and $wordToComplete -ne '')) {
+    $commands + $slashCommands | Where-Object { $_ -like "$wordToComplete*" } | ForEach-Object {
+      [System.Management.Automation.CompletionResult]::new($_, $_, 'ParameterValue', $_)
+    }
+    return
+  }
+  
+  switch ($command) {
+    { $_ -in 'analyze', '/a', '/analyze' } {
+      $flags = @('--format', '--output', '--include', '--exclude', '--upload', '--share', '--json', '--provider')
+      $flags | Where-Object { $_ -like "$wordToComplete*" } | ForEach-Object {
+        [System.Management.Automation.CompletionResult]::new($_, $_, 'ParameterName', $_)
+      }
+    }
+    { $_ -in 'init', '/i', '/init' } {
+      $flags = @('--template', '--force', '--git', '--json')
+      $flags | Where-Object { $_ -like "$wordToComplete*" } | ForEach-Object {
+        [System.Management.Automation.CompletionResult]::new($_, $_, 'ParameterName', $_)
+      }
+    }
+  }
+}
+`;
+}
+// Install completion for current shell
+export async function installCompletion(shell) {
+    const detectedShell = shell || process.env.SHELL?.split('/').pop() || 'bash';
+    console.log(`Installing completion for ${detectedShell}...\n`);
+    const script = generateCompletionScript(detectedShell);
+    console.log('Add this to your shell config:\n');
+    console.log(script);
+    console.log('\nOr run: eval "$(delta completion ' + detectedShell + ')"');
+}
+//# sourceMappingURL=completion.js.map

package/dist/core/contracts.js

@@ -0,0 +1,6 @@
+/**
+ * Core Contracts - Interface definitions for Delta CLI
+ * AI-Ready Architecture: Separate CLI from Business Logic
+ */
+export {};
+//# sourceMappingURL=contracts.js.map

package/dist/core/engine.js

@@ -0,0 +1,124 @@
+/**
+ * Delta Engine - Core Execution Engine
+ * Mediator between CLI and Execution Providers
+ */
+import { ExitCode, getExitCode } from './exit-codes.js';
+export class DeltaEngine {
+    providers = new Map();
+    config;
+    policy;
+    listeners = [];
+    version = '2.0.0';
+    constructor(config, policy) {
+        this.config = config;
+        this.policy = policy;
+    }
+    // Register an execution provider
+    registerProvider(provider) {
+        this.providers.set(provider.name, provider);
+    }
+    // Get registered provider
+    getProvider(name) {
+        return this.providers.get(name);
+    }
+    // Execute a task through the engine
+    async execute(request) {
+        const startTime = Date.now();
+        // Emit start event
+        this.emit({ type: 'task:start', request });
+        try {
+            // Validate request with policy (includes capability check)
+            const validation = this.policy.validate(request);
+            if (!validation.valid) {
+                const exitCode = validation.exitCode || ExitCode.VALIDATION_ERROR;
+                throw Object.assign(new Error(validation.reason || 'Task validation failed'), { code: exitCode === ExitCode.POLICY_BLOCKED ? 'POLICY_BLOCKED' : 'VALIDATION_ERROR', exitCode });
+            }
+            // Transform request if needed (includes non-TTY detection)
+            const transformedRequest = this.policy.transform?.(request) || request;
+            // Select appropriate provider using policy
+            const provider = this.policy.selectProvider(transformedRequest, this.providers);
+            if (!provider) {
+                throw Object.assign(new Error(`No provider available for task type '${transformedRequest.type}'`), { code: 'NO_PROVIDER', exitCode: ExitCode.POLICY_BLOCKED });
+            }
+            // Check provider availability
+            const available = await provider.isAvailable();
+            if (!available) {
+                throw Object.assign(new Error(`Provider '${provider.name}' is not available`), { code: 'PROVIDER_UNAVAILABLE', exitCode: ExitCode.NETWORK_ERROR });
+            }
+            // Execute task
+            this.emit({ type: 'task:progress', request: transformedRequest, progress: 0.5 });
+            const response = await provider.execute(transformedRequest);
+            // Enrich response with engine metadata
+            const enrichedResponse = {
+                ...response,
+                meta: {
+                    ...response.meta,
+                    command: request.command,
+                    duration: Date.now() - startTime,
+                    timestamp: new Date().toISOString(),
+                    version: this.version,
+                    coldStart: Date.now() - startTime - response.meta.duration,
+                    provider: provider.name,
+                },
+            };
+            // Emit completion
+            this.emit({
+                type: 'task:complete',
+                request: transformedRequest,
+                response: enrichedResponse
+            });
+            return enrichedResponse;
+        }
+        catch (error) {
+            // Emit error
+            this.emit({
+                type: 'task:error',
+                request,
+                error: error instanceof Error ? error : new Error(String(error))
+            });
+            return {
+                success: false,
+                exitCode: getExitCode(error),
+                meta: {
+                    command: request.command,
+                    duration: Date.now() - startTime,
+                    timestamp: new Date().toISOString(),
+                    version: this.version,
+                    provider: 'engine',
+                },
+                error: {
+                    code: error instanceof Error && 'code' in error
+                        ? error.code
+                        : 'EXECUTION_ERROR',
+                    message: error instanceof Error ? error.message : String(error),
+                },
+            };
+        }
+    }
+    // Subscribe to engine events
+    on(_event, listener) {
+        this.listeners.push(listener);
+    }
+    // Emit event to all listeners
+    emit(event) {
+        this.listeners.forEach(listener => listener(event));
+    }
+    // Get engine status
+    getStatus() {
+        return {
+            version: this.version,
+            providers: Array.from(this.providers.keys()),
+            defaultProvider: this.config.defaultProvider,
+        };
+    }
+}
+// Singleton instance
+let engineInstance = null;
+export function createEngine(config, policy) {
+    engineInstance = new DeltaEngine(config, policy);
+    return engineInstance;
+}
+export function getEngine() {
+    return engineInstance;
+}
+//# sourceMappingURL=engine.js.map

package/dist/core/exit-codes.js

@@ -0,0 +1,71 @@
+/**
+ * Exit Code Contract - Enterprise-grade error classification
+ * Critical for CI/CD integration and automation
+ */
+export var ExitCode;
+(function (ExitCode) {
+    ExitCode[ExitCode["SUCCESS"] = 0] = "SUCCESS";
+    ExitCode[ExitCode["VALIDATION_ERROR"] = 1] = "VALIDATION_ERROR";
+    ExitCode[ExitCode["NETWORK_ERROR"] = 2] = "NETWORK_ERROR";
+    ExitCode[ExitCode["AUTH_ERROR"] = 3] = "AUTH_ERROR";
+    ExitCode[ExitCode["POLICY_BLOCKED"] = 4] = "POLICY_BLOCKED";
+    ExitCode[ExitCode["EXECUTION_ERROR"] = 5] = "EXECUTION_ERROR";
+    ExitCode[ExitCode["UNKNOWN_ERROR"] = 6] = "UNKNOWN_ERROR";
+})(ExitCode || (ExitCode = {}));
+// Error to Exit Code mapping
+export function getExitCode(error) {
+    const errorStr = typeof error === 'string'
+        ? error
+        : error instanceof Error
+            ? error.message
+            : error.message || String(error);
+    const errorCode = typeof error === 'object' && 'code' in error ? error.code : undefined;
+    // Check error codes first
+    if (errorCode) {
+        switch (errorCode) {
+            case 'VALIDATION_ERROR':
+            case 'INVALID_INPUT':
+            case 'MISSING_ARGUMENT':
+                return ExitCode.VALIDATION_ERROR;
+            case 'AUTH_ERROR':
+            case 'UNAUTHORIZED':
+            case 'TOKEN_EXPIRED':
+                return ExitCode.AUTH_ERROR;
+            case 'NETWORK_ERROR':
+            case 'CONNECTION_FAILED':
+            case 'TIMEOUT':
+                return ExitCode.NETWORK_ERROR;
+            case 'POLICY_BLOCKED':
+            case 'QUOTA_EXCEEDED':
+            case 'PERMISSION_DENIED':
+                return ExitCode.POLICY_BLOCKED;
+            case 'EXECUTION_ERROR':
+                return ExitCode.EXECUTION_ERROR;
+        }
+    }
+    // Check error messages
+    if (errorStr.includes('validation') || errorStr.includes('invalid') || errorStr.includes('required')) {
+        return ExitCode.VALIDATION_ERROR;
+    }
+    if (errorStr.includes('auth') || errorStr.includes('token') || errorStr.includes('unauthorized')) {
+        return ExitCode.AUTH_ERROR;
+    }
+    if (errorStr.includes('network') || errorStr.includes('connection') || errorStr.includes('timeout')) {
+        return ExitCode.NETWORK_ERROR;
+    }
+    if (errorStr.includes('policy') || errorStr.includes('quota') || errorStr.includes('permission')) {
+        return ExitCode.POLICY_BLOCKED;
+    }
+    return ExitCode.EXECUTION_ERROR;
+}
+// Human-readable exit code descriptions
+export const ExitCodeDescription = {
+    [ExitCode.SUCCESS]: 'Success',
+    [ExitCode.VALIDATION_ERROR]: 'Validation error - check your input',
+    [ExitCode.NETWORK_ERROR]: 'Network error - check your connection',
+    [ExitCode.AUTH_ERROR]: 'Authentication error - please login',
+    [ExitCode.POLICY_BLOCKED]: 'Policy blocked - insufficient permissions or quota',
+    [ExitCode.EXECUTION_ERROR]: 'Execution error - task failed during execution',
+    [ExitCode.UNKNOWN_ERROR]: 'Unknown error - please report this issue',
+};
+//# sourceMappingURL=exit-codes.js.map

package/dist/core/hooks.js

@@ -0,0 +1,181 @@
+/**
+ * Hooks & Notifications System
+ * Post-command hooks for Slack, Teams, Webhooks
+ * Enterprise CI/CD integration
+ */
+import { promises as fs } from 'fs';
+import { homedir } from 'os';
+import { join } from 'path';
+const HOOKS_FILE = join(homedir(), '.delta', 'hooks.json');
+export class HookManager {
+    hooks = [];
+    loaded = false;
+    async load() {
+        if (this.loaded)
+            return;
+        try {
+            const data = await fs.readFile(HOOKS_FILE, 'utf-8');
+            this.hooks = JSON.parse(data);
+        }
+        catch {
+            this.hooks = [];
+        }
+        this.loaded = true;
+    }
+    async save() {
+        await fs.mkdir(join(homedir(), '.delta'), { recursive: true });
+        await fs.writeFile(HOOKS_FILE, JSON.stringify(this.hooks, null, 2), 'utf-8');
+    }
+    async addHook(hook) {
+        const newHook = {
+            ...hook,
+            id: `hook-${Date.now()}`,
+        };
+        this.hooks.push(newHook);
+        await this.save();
+        return newHook;
+    }
+    async removeHook(id) {
+        this.hooks = this.hooks.filter(h => h.id !== id);
+        await this.save();
+    }
+    async listHooks() {
+        await this.load();
+        return this.hooks;
+    }
+    async toggleHook(id) {
+        const hook = this.hooks.find(h => h.id === id);
+        if (hook) {
+            hook.enabled = !hook.enabled;
+            await this.save();
+        }
+    }
+    async executeHooks(type, command, response, startTime) {
+        await this.load();
+        const matchingHooks = this.hooks.filter(h => h.enabled && h.type === type && (!h.command || h.command === command));
+        const payload = {
+            command,
+            success: response.success,
+            exitCode: response.exitCode || (response.success ? 0 : 1),
+            duration: Date.now() - startTime,
+            timestamp: new Date().toISOString(),
+            project: process.env.DELTA_PROJECT,
+            user: process.env.USER || process.env.USERNAME,
+            error: response.error?.message,
+            summary: this.generateSummary(command, response),
+        };
+        // Execute hooks in parallel
+        await Promise.all(matchingHooks.map(hook => this.sendNotification(hook, payload).catch(() => { })));
+    }
+    async sendNotification(hook, payload) {
+        const body = hook.payload
+            ? this.renderTemplate(hook.payload, payload)
+            : JSON.stringify(payload);
+        const response = await fetch(hook.url, {
+            method: hook.method,
+            headers: {
+                'Content-Type': 'application/json',
+                ...hook.headers,
+            },
+            body: hook.method === 'POST' ? body : undefined,
+        });
+        if (!response.ok) {
+            throw new Error(`Hook failed: ${response.status}`);
+        }
+    }
+    renderTemplate(template, payload) {
+        return template
+            .replace(/\{\{command\}\}/g, payload.command)
+            .replace(/\{\{success\}\}/g, payload.success ? 'success' : 'failed')
+            .replace(/\{\{exitCode\}\}/g, String(payload.exitCode))
+            .replace(/\{\{duration\}\}/g, String(payload.duration))
+            .replace(/\{\{project\}\}/g, payload.project || 'unknown')
+            .replace(/\{\{user\}\}/g, payload.user || 'unknown');
+    }
+    generateSummary(command, response) {
+        switch (command) {
+            case 'analyze':
+                return response.success
+                    ? `Analyzed ${response.data?.filesAnalyzed || 0} files, found ${response.data?.findings || 0} issues`
+                    : 'Analysis failed';
+            case 'deploy':
+                return response.success ? 'Deployment successful' : 'Deployment failed';
+            default:
+                return response.success ? 'Command completed' : 'Command failed';
+        }
+    }
+}
+// Predefined templates for common services
+export const hookTemplates = {
+    slack: (webhookUrl) => ({
+        name: 'Slack Notifications',
+        type: 'post-always',
+        url: webhookUrl,
+        method: 'POST',
+        headers: {},
+        payload: JSON.stringify({
+            text: 'Delta CLI: {{command}} {{success}}',
+            blocks: [
+                {
+                    type: 'section',
+                    text: {
+                        type: 'mrkdwn',
+                        text: '*Delta CLI Notification*',
+                    },
+                },
+                {
+                    type: 'section',
+                    fields: [
+                        { type: 'mrkdwn', text: `*Command:*\n{{command}}` },
+                        { type: 'mrkdwn', text: `*Status:*\n{{success}}` },
+                        { type: 'mrkdwn', text: `*Duration:*\n{{duration}}ms` },
+                        { type: 'mrkdwn', text: `*Project:*\n{{project}}` },
+                    ],
+                },
+            ],
+        }),
+        enabled: true,
+    }),
+    teams: (webhookUrl) => ({
+        name: 'Teams Notifications',
+        type: 'post-always',
+        url: webhookUrl,
+        method: 'POST',
+        headers: {},
+        payload: JSON.stringify({
+            '@type': 'MessageCard',
+            '@context': 'https://schema.org/extensions',
+            summary: 'Delta CLI {{command}}',
+            themeColor: '{{#if success}}00FF00{{else}}FF0000{{/if}}',
+            sections: [
+                {
+                    activityTitle: 'Delta CLI Notification',
+                    facts: [
+                        { name: 'Command', value: '{{command}}' },
+                        { name: 'Status', value: '{{success}}' },
+                        { name: 'Duration', value: '{{duration}}ms' },
+                        { name: 'Project', value: '{{project}}' },
+                    ],
+                },
+            ],
+        }),
+        enabled: true,
+    }),
+    generic: (url) => ({
+        name: 'Webhook',
+        type: 'post-always',
+        url,
+        method: 'POST',
+        headers: {},
+        enabled: true,
+    }),
+};
+// Singleton instance
+let hookManager = null;
+export function getHookManager() {
+    if (!hookManager) {
+        hookManager = new HookManager();
+    }
+    return hookManager;
+}
+//# sourceMappingURL=hooks.js.map

package/dist/core/index.js

@@ -0,0 +1,7 @@
+/**
+ * Core Module - Export all core components
+ */
+export * from './contracts.js';
+export * from './engine.js';
+export * from './policy.js';
+//# sourceMappingURL=index.js.map