codehere 0.8.0 → 1.0.2

package/dist/application/use-cases/write-pass.js

@@ -1,277 +0,0 @@
-/**
- * Write-Pass (W-PASS) primitive · v0.9 S6 · the WRITE counterpart to S1's
- * context-source READ primitive.
- *
- * Demo v12 lines 2030-2050. Every time an agent wants to make a stateful
- * call to a third-party tool (Linear status update, GitHub PR comment,
- * Notion page edit, etc.) it emits a `WritePassIntent`. Codehere mediates:
- *
- *   1. Intent       · agent → codehere · {target, method, payload, reason}
- *   2. Approval     · user → codehere · approve / edit / cancel
- *   3. Mediated send · codehere → third-party · captures response
- *   4. Audit        · chained entry for each step
- *
- * Why this primitive exists: AI 2027 forecasts agentic AI doing autonomous
- * multi-tool writes by mid-2027. Without W-PASS we either (a) hand the
- * agent raw API keys + tokens — every write is invisible to the human,
- * audit-impossible — or (b) ban writes entirely and lose half the value.
- * W-PASS is the middle path: writes happen, but every payload is human-
- * mediated and chain-recorded.
- *
- * This file is PURE LOGIC · no fs, no fetch. CLI + HTTP + UI wrap it.
- */
-import { randomUUID, createHash } from 'crypto';
-/** Errors raised by W-PASS primitive functions. */
-export class WritePassError extends Error {
-    code;
-    constructor(code, message) {
-        super(`[w-pass] ${code}: ${message}`);
-        this.code = code;
-    }
-}
-/* ──────────────────────────────────────────────────────────────────────── */
-/* Pure helpers                                                              */
-/* ──────────────────────────────────────────────────────────────────────── */
-/** Generate a fresh W-PASS id · stable across the intent → decision → send cycle. */
-export function newPassId() {
-    return randomUUID();
-}
-/** Allowed URL schemes for W-PASS targets · matches context-source's namespace
- *  (we want symmetry: read via context-source, write via write-pass, same identifiers). */
-const ALLOWED_SCHEMES = new Set(['linear', 'github', 'figma', 'drawio', 'notion']);
-/**
- * Validate that an intent is well-formed before showing it to the user.
- * Refuse anything we can't audit (unknown scheme, unsupported method, empty
- * reason, etc.). Throws WritePassError with a precise code.
- */
-export function validateIntent(intent) {
-    if (typeof intent !== 'object' || intent === null) {
-        throw new WritePassError('invalid_intent', 'intent must be an object');
-    }
-    const it = intent;
-    if (typeof it.id !== 'string' || it.id.length === 0) {
-        throw new WritePassError('invalid_intent', 'id required');
-    }
-    if (typeof it.sessionId !== 'string' || it.sessionId.length === 0) {
-        throw new WritePassError('invalid_intent', 'sessionId required');
-    }
-    if (typeof it.target !== 'string' || it.target.length === 0) {
-        throw new WritePassError('invalid_intent', 'target required');
-    }
-    const schemeMatch = it.target.match(/^([a-z][a-z0-9+.-]*):\/\//);
-    if (!schemeMatch) {
-        throw new WritePassError('invalid_intent', `target must be a URL with a scheme · got "${it.target}"`);
-    }
-    if (!ALLOWED_SCHEMES.has(schemeMatch[1])) {
-        throw new WritePassError('unsupported_target', `scheme "${schemeMatch[1]}" not allowed · supported: ${[...ALLOWED_SCHEMES].sort().join(', ')}`);
-    }
-    if (typeof it.method !== 'string') {
-        throw new WritePassError('invalid_intent', 'method required');
-    }
-    const m = it.method.toUpperCase();
-    if (m !== 'POST' && m !== 'PUT' && m !== 'PATCH' && m !== 'DELETE') {
-        throw new WritePassError('unsupported_method', `method "${it.method}" not allowed for W-PASS (use context-source for GET)`);
-    }
-    if (typeof it.reason !== 'string' || it.reason.trim().length === 0) {
-        throw new WritePassError('invalid_intent', 'reason required · must be a non-empty one-line "why"');
-    }
-    if (typeof it.emittedAt !== 'number' || !Number.isFinite(it.emittedAt)) {
-        throw new WritePassError('invalid_intent', 'emittedAt required (epoch ms)');
-    }
-    // payload may be any JSON value · we don't constrain shape here · the user
-    // sees it verbatim and decides.
-    return {
-        id: it.id,
-        sessionId: it.sessionId,
-        target: it.target,
-        method: m,
-        payload: it.payload,
-        reason: it.reason,
-        emittedAt: it.emittedAt,
-        emittedBy: typeof it.emittedBy === 'string' ? it.emittedBy : undefined,
-    };
-}
-/** Validate a decision belongs to its intent and carries the fields required for its kind. */
-export function validateDecision(decision, intent) {
-    if (typeof decision !== 'object' || decision === null) {
-        throw new WritePassError('invalid_decision', 'decision must be an object');
-    }
-    const d = decision;
-    if (d.passId !== intent.id) {
-        throw new WritePassError('invalid_decision', `decision.passId "${d.passId}" doesn't match intent.id "${intent.id}"`);
-    }
-    const kind = d.kind;
-    if (kind !== 'approve' && kind !== 'edit' && kind !== 'cancel') {
-        throw new WritePassError('invalid_decision', `kind must be approve | edit | cancel · got "${d.kind}"`);
-    }
-    if (kind === 'edit' && d.editedPayload === undefined) {
-        throw new WritePassError('invalid_decision', 'edit requires editedPayload');
-    }
-    if (typeof d.decidedAt !== 'number' || !Number.isFinite(d.decidedAt)) {
-        throw new WritePassError('invalid_decision', 'decidedAt required (epoch ms)');
-    }
-    return {
-        passId: intent.id,
-        kind,
-        editedPayload: kind === 'edit' ? d.editedPayload : undefined,
-        note: typeof d.note === 'string' ? d.note : undefined,
-        decidedAt: d.decidedAt,
-    };
-}
-/**
- * Apply a decision to an intent and produce the next status.
- * Pure · no I/O. The caller (daemon route) does the network call and produces
- * a `WritePassResponse` which then transitions 'approved'/'edited' → 'sent'.
- */
-export function applyDecision(intent, decision) {
-    if (decision.kind === 'cancel') {
-        return { kind: 'cancelled', intent, decision };
-    }
-    if (decision.kind === 'edit') {
-        return { kind: 'edited', intent, decision, effectivePayload: decision.editedPayload };
-    }
-    return { kind: 'approved', intent, decision };
-}
-/**
- * After codehere does the mediated send, record the response and transition
- * to 'sent' (2xx/3xx) or 'failed' (everything else).
- */
-export function applyResponse(status, response) {
-    const effectivePayload = status.kind === 'edited' ? status.effectivePayload : status.intent.payload;
-    const ok = response.status >= 200 && response.status < 400;
-    return ok
-        ? { kind: 'sent', intent: status.intent, decision: status.decision, effectivePayload, response }
-        : { kind: 'failed', intent: status.intent, decision: status.decision, effectivePayload, response };
-}
-/* ──────────────────────────────────────────────────────────────────────── */
-/* Audit-line shaping                                                        */
-/* ──────────────────────────────────────────────────────────────────────── */
-/**
- * Deterministic JSON for hashing into the audit chain. Same canonical-form
- * rules as thread-export's canonicalize · keys sorted, undefined dropped,
- * non-finite numbers refused. We want two machines that re-serialize the
- * same intent to compute the same hash.
- */
-export function canonicalizeForAudit(value) {
-    if (value === null)
-        return 'null';
-    if (typeof value === 'number') {
-        if (!Number.isFinite(value))
-            throw new Error(`cannot canonicalize non-finite number: ${value}`);
-        return JSON.stringify(value);
-    }
-    if (typeof value === 'string' || typeof value === 'boolean')
-        return JSON.stringify(value);
-    if (Array.isArray(value)) {
-        return '[' + value.map(canonicalizeForAudit).join(',') + ']';
-    }
-    if (typeof value === 'object') {
-        const obj = value;
-        const keys = Object.keys(obj).sort();
-        const parts = keys
-            .filter((k) => obj[k] !== undefined)
-            .map((k) => JSON.stringify(k) + ':' + canonicalizeForAudit(obj[k]));
-        return '{' + parts.join(',') + '}';
-    }
-    if (value === undefined)
-        return 'null';
-    throw new Error(`cannot canonicalize type: ${typeof value}`);
-}
-/** SHA-256 hash of canonicalize(value) · 16-char hex prefix for inline display. */
-export function shortContentHash(value) {
-    return createHash('sha256').update(canonicalizeForAudit(value)).digest('hex').slice(0, 16);
-}
-/** Render a status transition as an audit-chain entry. Caller appends it. */
-export function statusToAuditLine(s) {
-    const sessionId = s.intent.sessionId;
-    const timestamp = new Date('response' in s ? s.response.receivedAt : 'decision' in s ? s.decision.decidedAt : s.intent.emittedAt).toISOString();
-    const baseSummary = {
-        passId: s.intent.id,
-        target: s.intent.target,
-        method: s.intent.method,
-        reason: s.intent.reason,
-        payloadHash: shortContentHash(s.intent.payload),
-    };
-    switch (s.kind) {
-        case 'pending':
-            return {
-                toolName: 'WritePass.intent',
-                toolInput: canonicalizeForAudit(baseSummary),
-                riskScore: 0,
-                blocked: false,
-                findings: 0,
-                criticalFindings: 0,
-                sessionId,
-                timestamp,
-            };
-        case 'approved':
-            return {
-                toolName: 'WritePass.approved',
-                toolInput: canonicalizeForAudit({ ...baseSummary, note: s.decision.note }),
-                riskScore: 0,
-                blocked: false,
-                findings: 0,
-                criticalFindings: 0,
-                sessionId,
-                timestamp,
-            };
-        case 'edited':
-            return {
-                toolName: 'WritePass.edited',
-                toolInput: canonicalizeForAudit({
-                    ...baseSummary,
-                    editedPayloadHash: shortContentHash(s.effectivePayload),
-                    note: s.decision.note,
-                }),
-                riskScore: 0,
-                blocked: false,
-                findings: 0,
-                criticalFindings: 0,
-                sessionId,
-                timestamp,
-            };
-        case 'cancelled':
-            return {
-                toolName: 'WritePass.cancelled',
-                toolInput: canonicalizeForAudit({ ...baseSummary, note: s.decision.note }),
-                riskScore: 0,
-                blocked: true,
-                findings: 0,
-                criticalFindings: 0,
-                sessionId,
-                timestamp,
-            };
-        case 'sent':
-            return {
-                toolName: 'WritePass.sent',
-                toolInput: canonicalizeForAudit({
-                    ...baseSummary,
-                    effectivePayloadHash: shortContentHash(s.effectivePayload),
-                    responseStatus: s.response.status,
-                }),
-                riskScore: 0,
-                blocked: false,
-                findings: 0,
-                criticalFindings: 0,
-                sessionId,
-                timestamp,
-            };
-        case 'failed':
-            return {
-                toolName: 'WritePass.failed',
-                toolInput: canonicalizeForAudit({
-                    ...baseSummary,
-                    effectivePayloadHash: shortContentHash(s.effectivePayload),
-                    responseStatus: s.response.status,
-                    error: s.response.error,
-                }),
-                riskScore: 0,
-                blocked: false,
-                findings: 1,
-                criticalFindings: 0,
-                sessionId,
-                timestamp,
-            };
-    }
-}
-//# sourceMappingURL=write-pass.js.map

package/dist/domain/entities/task.js

@@ -1,61 +0,0 @@
-/**
- * Domain Entity: CodehereTask
- * Task and workflow entities for the 4-mode interaction model
- *
- * Phase 1: v0.5.0-alpha
- * See: .internal/ARCHITECTURE.md (internal docs)
- */
-/**
- * Task Mode - The interaction mode that created this task
- */
-export var TaskMode;
-(function (TaskMode) {
-    TaskMode["SUGGEST"] = "suggest";
-    TaskMode["PLAN"] = "plan";
-    TaskMode["RUN"] = "run";
-    TaskMode["REVIEW"] = "review";
-})(TaskMode || (TaskMode = {}));
-/**
- * Task Status - Current lifecycle state
- */
-export var TaskStatus;
-(function (TaskStatus) {
-    TaskStatus["CREATED"] = "created";
-    TaskStatus["PLANNED"] = "planned";
-    TaskStatus["RUNNING"] = "running";
-    TaskStatus["COMPLETED"] = "completed";
-    TaskStatus["FAILED"] = "failed";
-    TaskStatus["NEEDS_REVIEW"] = "needs_review";
-    TaskStatus["APPROVED"] = "approved";
-    TaskStatus["REJECTED"] = "rejected";
-    TaskStatus["CANCELLED"] = "cancelled";
-})(TaskStatus || (TaskStatus = {}));
-/**
- * Risk Tier - Risk level for operation
- */
-export var RiskTier;
-(function (RiskTier) {
-    RiskTier["T1"] = "t1";
-    RiskTier["T2"] = "t2";
-    RiskTier["T3"] = "t3";
-})(RiskTier || (RiskTier = {}));
-/**
- * Environment Mode - Data access boundaries
- */
-export var EnvironmentMode;
-(function (EnvironmentMode) {
-    EnvironmentMode["LOCAL"] = "local";
-    EnvironmentMode["ORG"] = "org";
-    EnvironmentMode["INTERNET"] = "internet";
-})(EnvironmentMode || (EnvironmentMode = {}));
-/**
- * Review Status
- */
-export var ReviewStatus;
-(function (ReviewStatus) {
-    ReviewStatus["NOT_REQUIRED"] = "not_required";
-    ReviewStatus["PENDING"] = "pending";
-    ReviewStatus["APPROVED"] = "approved";
-    ReviewStatus["REJECTED"] = "rejected";
-})(ReviewStatus || (ReviewStatus = {}));
-//# sourceMappingURL=task.js.map

package/dist/domain/services/codebase-detector.js

@@ -1,91 +0,0 @@
-/**
- * Domain Service: CodebaseDetector
- * Detects and identifies codebase root directory
- */
-import { existsSync } from 'fs';
-import { join, dirname, resolve } from 'path';
-/**
- * Find codebase root (git root, package.json parent, or current directory)
- */
-export function findCodebaseRoot(startPath = process.cwd()) {
-    const resolvedStart = resolve(startPath);
-    const currentDir = resolvedStart;
-    // Try to find git root first
-    const gitRoot = findGitRoot(currentDir);
-    if (gitRoot) {
-        return {
-            rootPath: gitRoot,
-            codebaseId: generateCodebaseId(gitRoot),
-            type: 'git',
-        };
-    }
-    // Try to find package.json
-    const packageRoot = findPackageRoot(currentDir);
-    if (packageRoot) {
-        return {
-            rootPath: packageRoot,
-            codebaseId: generateCodebaseId(packageRoot),
-            type: 'package',
-        };
-    }
-    // Fallback to current directory
-    return {
-        rootPath: currentDir,
-        codebaseId: generateCodebaseId(currentDir),
-        type: 'directory',
-    };
-}
-/**
- * Generate stable codebase ID from path
- * Uses absolute path normalized for cross-platform compatibility
- */
-function generateCodebaseId(path) {
-    // Normalize path (handle Windows/Unix differences)
-    const normalized = resolve(path).replace(/\\/g, '/');
-    // Use path as ID (stable identifier)
-    // For production, could hash this for shorter IDs
-    return normalized;
-}
-/**
- * Find git root directory
- */
-function findGitRoot(startPath) {
-    let currentDir = startPath;
-    const root = currentDir.split(/[/\\]/)[0];
-    while (currentDir !== root) {
-        if (existsSync(join(currentDir, '.git'))) {
-            return currentDir;
-        }
-        const parentDir = dirname(currentDir);
-        if (parentDir === currentDir) {
-            break;
-        }
-        currentDir = parentDir;
-    }
-    return null;
-}
-/**
- * Find package.json root directory
- */
-function findPackageRoot(startPath) {
-    let currentDir = startPath;
-    const root = currentDir.split(/[/\\]/)[0];
-    while (currentDir !== root) {
-        if (existsSync(join(currentDir, 'package.json'))) {
-            return currentDir;
-        }
-        const parentDir = dirname(currentDir);
-        if (parentDir === currentDir) {
-            break;
-        }
-        currentDir = parentDir;
-    }
-    return null;
-}
-/**
- * Get codebase info for a given file path
- */
-export function getCodebaseForFile(filepath) {
-    return findCodebaseRoot(dirname(filepath));
-}
-//# sourceMappingURL=codebase-detector.js.map

package/dist/error-handler.js

@@ -1,251 +0,0 @@
-/**
- * Enterprise-Grade Error Handling & Recovery System
- * Ensures 24/7 operation with automatic recovery
- */
-export var ErrorType;
-(function (ErrorType) {
-    ErrorType["RETRYABLE"] = "RETRYABLE";
-    ErrorType["FATAL"] = "FATAL";
-    ErrorType["RATE_LIMIT"] = "RATE_LIMIT";
-    ErrorType["NETWORK"] = "NETWORK";
-    ErrorType["API_ERROR"] = "API_ERROR";
-    ErrorType["VALIDATION"] = "VALIDATION";
-    ErrorType["POLICY"] = "POLICY";
-})(ErrorType || (ErrorType = {}));
-export class EnterpriseError extends Error {
-    errorType;
-    context;
-    retryable;
-    constructor(message, errorType, context, retryable = false) {
-        super(message);
-        this.errorType = errorType;
-        this.context = context;
-        this.retryable = retryable;
-        this.name = 'EnterpriseError';
-    }
-}
-/**
- * Classify error type for appropriate handling
- */
-export function classifyError(error) {
-    if (error instanceof EnterpriseError) {
-        return error.errorType;
-    }
-    // Check for 429 status code directly (Cohere SDK errors)
-    if (error && typeof error === 'object') {
-        const err = error;
-        if (err.statusCode === 429 || err.status === 429) {
-            return ErrorType.RATE_LIMIT;
-        }
-        // Check error name/class
-        const errorName = err.constructor?.name || err.name || '';
-        if (errorName.includes('TooManyRequests') || errorName === 'TooManyRequestsError') {
-            return ErrorType.RATE_LIMIT;
-        }
-        // Check body/message for trial key quota messages
-        const body = err.body || err.message || '';
-        if (typeof body === 'string' && body.includes('Trial key') && body.includes('1000 API calls')) {
-            return ErrorType.RATE_LIMIT;
-        }
-    }
-    const errorMessage = error instanceof Error ? error.message : String(error);
-    const lowerMessage = errorMessage.toLowerCase();
-    // Rate limiting - check message content
-    if (lowerMessage.includes('rate limit') ||
-        lowerMessage.includes('429') ||
-        lowerMessage.includes('too many requests') ||
-        lowerMessage.includes('toomanyrequests') ||
-        (lowerMessage.includes('trial key') && lowerMessage.includes('1000'))) {
-        return ErrorType.RATE_LIMIT;
-    }
-    // Network errors
-    if (lowerMessage.includes('network') || lowerMessage.includes('timeout') || lowerMessage.includes('econnrefused')) {
-        return ErrorType.NETWORK;
-    }
-    // API errors
-    if (lowerMessage.includes('api') || lowerMessage.includes('cohere')) {
-        return ErrorType.API_ERROR;
-    }
-    // Validation errors
-    if (lowerMessage.includes('validation') || lowerMessage.includes('invalid')) {
-        return ErrorType.VALIDATION;
-    }
-    // Default to retryable
-    return ErrorType.RETRYABLE;
-}
-/**
- * Check if error is retryable
- * Rate limit errors (429) should NOT be retried - they indicate quota exceeded
- */
-export function isRetryable(error) {
-    // Check for 429 status code directly - don't retry monthly quota limits
-    if (error && typeof error === 'object') {
-        const err = error;
-        // Cohere SDK error structure
-        if (err.statusCode === 429 || err.status === 429) {
-            return false; // Monthly quota exceeded - retrying won't help
-        }
-        // Check error name/class (Cohere SDK uses TooManyRequestsError)
-        const errorName = err.constructor?.name || err.name || '';
-        if (errorName.includes('TooManyRequests') || errorName === 'TooManyRequestsError') {
-            return false;
-        }
-        // Check error message for trial key limit message
-        const errorMsg = err.message || String(err);
-        if (errorMsg.includes('Trial key') && errorMsg.includes('1000 API calls')) {
-            return false; // Monthly quota exceeded
-        }
-    }
-    const errorType = classifyError(error);
-    // Don't retry rate limit errors - they indicate quota/limit exceeded
-    if (errorType === ErrorType.RATE_LIMIT) {
-        return false;
-    }
-    return [ErrorType.RETRYABLE, ErrorType.NETWORK, ErrorType.API_ERROR].includes(errorType);
-}
-/**
- * Calculate exponential backoff delay
- */
-export function calculateBackoff(attempt, baseDelay = 1000, maxDelay = 60000) {
-    const delay = Math.min(baseDelay * Math.pow(2, attempt), maxDelay);
-    // Add jitter to prevent thundering herd
-    const jitter = Math.random() * 0.3 * delay;
-    return Math.floor(delay + jitter);
-}
-/**
- * Retry with exponential backoff
- */
-export async function retryWithBackoff(operation, options = {}) {
-    const { maxRetries = 5, baseDelay = 1000, maxDelay = 60000, operationName = 'operation', onRetry } = options;
-    let lastError;
-    for (let attempt = 0; attempt <= maxRetries; attempt++) {
-        try {
-            return await operation();
-        }
-        catch (error) {
-            lastError = error;
-            // Don't retry on fatal errors
-            if (!isRetryable(error)) {
-                throw new EnterpriseError(`Fatal error in ${operationName}: ${error instanceof Error ? error.message : String(error)}`, classifyError(error), {
-                    operation: operationName,
-                    attempt,
-                    maxRetries,
-                    timestamp: new Date().toISOString(),
-                    errorType: classifyError(error),
-                    originalError: error instanceof Error ? error : new Error(String(error)),
-                }, false);
-            }
-            // Last attempt, throw error
-            if (attempt === maxRetries) {
-                break;
-            }
-            // Calculate delay and wait
-            const delay = calculateBackoff(attempt, baseDelay, maxDelay);
-            if (onRetry) {
-                onRetry(attempt + 1, error);
-            }
-            await new Promise((resolve) => setTimeout(resolve, delay));
-        }
-    }
-    // All retries exhausted
-    throw new EnterpriseError(`Operation ${operationName} failed after ${maxRetries} retries: ${lastError instanceof Error ? lastError.message : String(lastError)}`, classifyError(lastError), {
-        operation: operationName,
-        attempt: maxRetries,
-        maxRetries,
-        timestamp: new Date().toISOString(),
-        errorType: classifyError(lastError),
-        originalError: lastError instanceof Error ? lastError : new Error(String(lastError)),
-    }, false);
-}
-/**
- * Circuit breaker pattern for API calls
- */
-export class CircuitBreaker {
-    threshold;
-    timeout;
-    resetTimeout;
-    failures = 0;
-    lastFailureTime = 0;
-    state = 'CLOSED';
-    constructor(threshold = 5, timeout = 60000, // 1 minute
-    resetTimeout = 30000) {
-        this.threshold = threshold;
-        this.timeout = timeout;
-        this.resetTimeout = resetTimeout;
-    }
-    async execute(operation) {
-        // Check if circuit should be reset
-        if (this.state === 'OPEN') {
-            const timeSinceLastFailure = Date.now() - this.lastFailureTime;
-            if (timeSinceLastFailure > this.resetTimeout) {
-                this.state = 'HALF_OPEN';
-            }
-            else {
-                throw new EnterpriseError('Circuit breaker is OPEN. Service unavailable.', ErrorType.API_ERROR, {
-                    operation: 'circuit_breaker',
-                    timestamp: new Date().toISOString(),
-                    errorType: ErrorType.API_ERROR,
-                    originalError: new Error('Circuit breaker open'),
-                }, false);
-            }
-        }
-        try {
-            const result = await operation();
-            // Success - reset failures if in HALF_OPEN
-            if (this.state === 'HALF_OPEN') {
-                this.state = 'CLOSED';
-                this.failures = 0;
-            }
-            else if (this.failures > 0) {
-                this.failures = 0;
-            }
-            return result;
-        }
-        catch (error) {
-            this.failures++;
-            this.lastFailureTime = Date.now();
-            // Open circuit if threshold exceeded
-            if (this.failures >= this.threshold) {
-                this.state = 'OPEN';
-            }
-            throw error;
-        }
-    }
-    getState() {
-        return this.state;
-    }
-    reset() {
-        this.failures = 0;
-        this.state = 'CLOSED';
-        this.lastFailureTime = 0;
-    }
-}
-/**
- * Global circuit breaker for Cohere API
- */
-export const cohereCircuitBreaker = new CircuitBreaker(5, 60000, 30000);
-/**
- * Graceful error handler with recovery strategies
- */
-export function handleError(error, context) {
-    const errorType = classifyError(error);
-    const errorMessage = error instanceof Error ? error.message : String(error);
-    const fullContext = {
-        operation: context.operation || 'unknown',
-        filepath: context.filepath,
-        attempt: context.attempt,
-        maxRetries: context.maxRetries,
-        timestamp: new Date().toISOString(),
-        errorType,
-        originalError: error instanceof Error ? error : new Error(errorMessage),
-        metadata: context.metadata,
-    };
-    // Log error with full context
-    console.error('Enterprise Error:', {
-        message: errorMessage,
-        type: errorType,
-        context: fullContext,
-    });
-    throw new EnterpriseError(errorMessage, errorType, fullContext, isRetryable(error));
-}
-//# sourceMappingURL=error-handler.js.map