@grapine.ai/contextprune 0.1.0 → 0.1.1

package/dist/src/tokenizer/index.js

@@ -0,0 +1,195 @@
+"use strict";
+// src/tokenizer/index.ts
+// Model-aware token counting.
+// Uses tiktoken for OpenAI models.
+// Falls back to character estimation when tokenizer unavailable.
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.countTokens = countTokens;
+exports.estimate = estimate;
+exports.countMessagesTokens = countMessagesTokens;
+exports.getModelMaxTokens = getModelMaxTokens;
+const MODEL_MAX_TOKENS = {
+    // ── Anthropic Claude 4.x ─────────────────────────────────────────────────
+    'claude-opus-4-6': 200000,
+    'claude-sonnet-4-6': 200000,
+    // Claude 4.5 aliases
+    'claude-sonnet-4-5': 200000,
+    'claude-opus-4-5': 200000,
+    'claude-haiku-4-5': 200000,
+    // Claude 3.x
+    'claude-3-5-sonnet-20241022': 200000,
+    'claude-3-5-haiku-20241022': 200000,
+    'claude-3-opus-20240229': 200000,
+    'claude-3-sonnet-20240229': 200000,
+    'claude-3-haiku-20240307': 200000,
+    // ── OpenAI GPT-4o ─────────────────────────────────────────────────────────
+    'gpt-4o': 128000,
+    'gpt-4o-mini': 128000,
+    'gpt-4o-2024-11-20': 128000,
+    'gpt-4o-2024-08-06': 128000,
+    // OpenAI GPT-4
+    'gpt-4-turbo': 128000,
+    'gpt-4-turbo-preview': 128000,
+    'gpt-4': 8192,
+    'gpt-4-32k': 32768,
+    // OpenAI GPT-3.5
+    'gpt-3.5-turbo': 16385,
+    'gpt-3.5-turbo-16k': 16385,
+    // OpenAI o-series
+    'o1': 200000,
+    'o1-preview': 128000,
+    'o1-mini': 128000,
+    'o3': 200000,
+    'o3-mini': 200000,
+    // OpenAI GPT-4.1
+    'gpt-4.1': 1047576,
+    'gpt-4.1-mini': 1047576,
+    'gpt-4.1-nano': 1047576,
+    // ── Google Gemini ─────────────────────────────────────────────────────────
+    'gemini-2.5-pro': 1048576,
+    'gemini-2.5-flash': 1048576,
+    'gemini-2.0-flash': 1048576,
+    'gemini-1.5-pro': 2097152,
+    'gemini-1.5-flash': 1048576,
+    'gemini-1.0-pro': 32760,
+    // ── Meta Llama (via any OpenAI-compatible host) ───────────────────────────
+    'meta-llama/llama-3.3-70b-instruct': 131072,
+    'meta-llama/llama-3.1-70b-instruct': 131072,
+    'meta-llama/llama-3.1-8b-instruct': 131072,
+    'meta-llama/llama-3-70b-instruct': 8192,
+    // Short aliases used by some hosts
+    'llama-3.3-70b-instruct': 131072,
+    'llama-3.1-70b-instruct': 131072,
+    // ── Mistral ───────────────────────────────────────────────────────────────
+    'mistral-large-latest': 131072,
+    'mistral-medium-latest': 131072,
+    'mistral-small-latest': 131072,
+    'mistral-7b-instruct': 32768,
+    'mixtral-8x7b-instruct': 32768,
+    'mixtral-8x22b-instruct': 65536,
+    'codestral-latest': 262144,
+    // ── Groq-hosted models (same weights, Groq context limits) ────────────────
+    'llama3-70b-8192': 8192,
+    'llama3-8b-8192': 8192,
+    'mixtral-8x7b-32768': 32768,
+    'gemma2-9b-it': 8192,
+    // ── Cohere ────────────────────────────────────────────────────────────────
+    'command-r-plus': 128000,
+    'command-r': 128000,
+    'command': 4096,
+    // ── OpenRouter prefixed aliases (provider/model format) ───────────────────
+    'openai/gpt-4o': 128000,
+    'openai/gpt-4o-mini': 128000,
+    'openai/o1': 200000,
+    'openai/o3-mini': 200000,
+    'anthropic/claude-opus-4-6': 200000,
+    'anthropic/claude-sonnet-4-6': 200000,
+    'anthropic/claude-haiku-4-5': 200000,
+    'anthropic/claude-haiku-4.5': 200000, // dot variant
+    'anthropic/claude-sonnet-4-5': 200000,
+    'anthropic/claude-sonnet-4.5': 200000, // dot variant
+    'anthropic/claude-3-5-sonnet': 200000,
+    'anthropic/claude-3-5-haiku': 200000,
+    'anthropic/claude-3-haiku': 200000,
+    'google/gemini-2.5-pro': 1048576,
+    'google/gemini-2.5-flash': 1048576,
+    'google/gemini-2.0-flash': 1048576,
+    'meta-llama/llama-3.3-70b': 131072,
+    'mistralai/mistral-large': 131072,
+    'mistralai/mixtral-8x7b-instruct': 32768,
+    'cohere/command-r-plus': 128000,
+    'deepseek/deepseek-chat': 163840,
+    'deepseek/deepseek-r1': 163840,
+    // ── DeepSeek ─────────────────────────────────────────────────────────────
+    'deepseek-chat': 163840,
+    'deepseek-reasoner': 163840,
+};
+// Approximate: 1 token ≈ 4 characters for English text
+// Used only in the fast-path estimate() function — never in production counts
+const CHARS_PER_TOKEN = 4;
+let tiktokenEncoder = null;
+async function getTiktokenEncoder() {
+    if (tiktokenEncoder)
+        return tiktokenEncoder;
+    try {
+        const { get_encoding } = await Promise.resolve().then(() => __importStar(require('tiktoken')));
+        tiktokenEncoder = get_encoding('cl100k_base'); // works for GPT-4, Claude approximation
+        return tiktokenEncoder;
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Exact token count using model-appropriate tokenizer.
+ * Falls back to character estimation if tokenizer unavailable.
+ */
+async function countTokens(text, model) {
+    const encoder = await getTiktokenEncoder();
+    if (encoder) {
+        try {
+            return encoder.encode(text).length;
+        }
+        catch {
+            // fall through to estimate
+        }
+    }
+    return estimate(text);
+}
+/**
+ * Fast approximate count — used only for UI/real-time displays.
+ * Never use this for compression decisions.
+ */
+function estimate(text) {
+    return Math.ceil(text.length / CHARS_PER_TOKEN);
+}
+/**
+ * Count tokens across an entire messages array.
+ */
+async function countMessagesTokens(messages, model) {
+    let total = 0;
+    for (const msg of messages) {
+        const text = typeof msg.content === 'string'
+            ? msg.content
+            : JSON.stringify(msg.content);
+        total += await countTokens(text, model);
+        total += 4; // per-message overhead (role tokens + formatting)
+    }
+    return total;
+}
+function getModelMaxTokens(model) {
+    return MODEL_MAX_TOKENS[model] ?? 128000;
+}

package/dist/src/types.d.ts

@@ -0,0 +1,161 @@
+export interface ContentBlock {
+    type: 'text' | 'tool_use' | 'tool_result' | 'image';
+    text?: string;
+    id?: string;
+    tool_use_id?: string;
+    name?: string;
+    input?: Record<string, unknown>;
+    content?: string;
+}
+export interface LLMMessage {
+    role: 'system' | 'user' | 'assistant';
+    content: string | ContentBlock[];
+}
+export type MessageClassification = 'SYSTEM_CONSTRAINT' | 'TASK_DEFINITION' | 'TOOL_OUTPUT_ACTIVE' | 'TOOL_OUTPUT_STALE' | 'ERROR_ACTIVE' | 'ERROR_RESOLVED' | 'REASONING_INTERMEDIATE' | 'DECISION_FINAL' | 'USER_CORRECTION' | 'PROGRESS_MARKER' | 'CONVERSATIONAL';
+export type CompressionStrategy = 'PRESERVE' | 'DROP' | 'EXTRACT_RESULT' | 'COLLAPSE_TO_MARKER' | 'SUMMARIZE' | 'DEDUPLICATE';
+export type RelevanceTier = 'CRITICAL' | 'HIGH' | 'MEDIUM' | 'LOW' | 'NEGLIGIBLE';
+export type ConfidenceTier = 'HIGH' | 'MEDIUM' | 'LOW';
+export interface AnnotatedMessage {
+    id: string;
+    originalIndex: number;
+    original: LLMMessage;
+    classification: MessageClassification;
+    classificationConfidence: number;
+    classificationMethod: 'rule' | 'heuristic';
+    relevanceScore: number;
+    relevanceFactors: {
+        recencyScore: number;
+        referenceCount: number;
+        taskProximity: number;
+        isPinned: boolean;
+    };
+    tokenCount: number;
+    compressedTokenCount?: number;
+    compressionStrategy: CompressionStrategy;
+    compressionApplied: boolean;
+    compressedContent?: string;
+    resolvedBy?: string;
+    duplicateOf?: string;
+    summarizedInto?: string;
+}
+export interface SessionState {
+    sessionId: string;
+    createdAt: Date;
+    lastUpdatedAt: Date;
+    taskContext: {
+        originalGoal: string | null;
+        currentSubtask: string | null;
+        completedSubtasks: string[];
+        activeConstraints: string[];
+        technologyStack: string[];
+    };
+    tokenBudget: {
+        modelMaxTokens: number;
+        currentUsage: number;
+        utilizationPercent: number;
+        warningThreshold: number;
+        criticalThreshold: number;
+    };
+    messages: Map<string, AnnotatedMessage>;
+    messageOrder: string[];
+    compressionHistory: CompressionEvent[];
+}
+export interface CompressionDecision {
+    messageId: string;
+    originalIndex: number;
+    classification: MessageClassification;
+    strategy: CompressionStrategy;
+    reasoning: string;
+    tokensBefore: number;
+    tokensAfter: number;
+}
+export interface CompressionEvent {
+    eventId: string;
+    timestamp: Date;
+    trigger: 'manual' | 'threshold' | 'api_call';
+    messagesEvaluated: number;
+    messagesCompressed: number;
+    messagesDropped: number;
+    messagesPreserved: number;
+    tokensBefore: number;
+    tokensAfter: number;
+    tokensSaved: number;
+    savingsPercent: number;
+    decisions: CompressionDecision[];
+}
+export interface CompressionOptions {
+    warningThreshold?: number;
+    criticalThreshold?: number;
+    preserveCorrections?: boolean;
+    compressionMode?: 'auto' | 'manual' | 'suggest-only';
+    useLLMSummarization?: boolean;
+    actualInputTokens?: number;
+}
+export interface ContextInput {
+    messages: LLMMessage[];
+    model: string;
+    options?: CompressionOptions;
+}
+export interface CompressedContext {
+    messages: LLMMessage[];
+    summary: {
+        tokensBefore: number;
+        tokensAfter: number;
+        tokensSaved: number;
+        savingsPercent: number;
+        messagesRemoved: number;
+        compressionTriggered: boolean;
+    };
+    sessionId: string;
+}
+export interface ContextAnalysis {
+    sessionId: string;
+    annotatedMessages: AnnotatedMessage[];
+    breakdown: {
+        byClassification: Partial<Record<MessageClassification, {
+            count: number;
+            tokens: number;
+            percentOfTotal: number;
+        }>>;
+        byCompressionStrategy: Partial<Record<CompressionStrategy, {
+            count: number;
+            tokensBefore: number;
+            tokensAfter: number;
+        }>>;
+    };
+    topConsumers: Array<{
+        messageId: string;
+        originalIndex: number;
+        classification: MessageClassification;
+        tokenCount: number;
+        percentOfTotal: number;
+        compressionOpportunity: 'high' | 'medium' | 'low' | 'none';
+        reason: string;
+    }>;
+    recommendation: {
+        shouldCompress: boolean;
+        urgency: 'none' | 'suggested' | 'recommended' | 'critical';
+        projectedSavings: number;
+        projectedSavingsPercent: number;
+        message: string;
+    };
+    sessionState: SessionState;
+    compressionHistory: CompressionEvent[];
+    sessionBrief: string;
+}
+export interface ValidationWarning {
+    type: string;
+    message: string;
+    messageId?: string;
+}
+export interface ValidationBlocker {
+    type: string;
+    message: string;
+    recoveryAction: 'RESTORE_MESSAGE' | 'ABORT_COMPRESSION';
+    messageId?: string;
+}
+export interface ValidationResult {
+    passed: boolean;
+    warnings: ValidationWarning[];
+    blockers: ValidationBlocker[];
+}

package/dist/src/types.js

@@ -0,0 +1,5 @@
+"use strict";
+// src/types.ts
+// Canonical types for ContextPrune. Every file imports from here.
+// Do not redefine types locally.
+Object.defineProperty(exports, "__esModule", { value: true });

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

@@ -0,0 +1,4 @@
+import type { LLMMessage } from '../types';
+export declare function generateId(): string;
+export declare function extractText(message: LLMMessage): string;
+export declare function extractKeywords(text: string): string[];

package/dist/src/utils/index.js

@@ -0,0 +1,48 @@
+"use strict";
+// src/utils/index.ts
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateId = generateId;
+exports.extractText = extractText;
+exports.extractKeywords = extractKeywords;
+const crypto_1 = require("crypto");
+function generateId() {
+    return (0, crypto_1.randomUUID)();
+}
+function extractText(message) {
+    if (typeof message.content === 'string')
+        return message.content;
+    return message.content
+        .map((b) => {
+        if (b.type === 'text')
+            return b.text ?? '';
+        if (b.type === 'thinking')
+            return b.thinking ?? '';
+        if (b.type === 'tool_use')
+            return JSON.stringify(b.input ?? {});
+        if (b.type === 'tool_result') {
+            const c = b.content;
+            if (typeof c === 'string')
+                return c;
+            if (Array.isArray(c))
+                return c.map((x) => x.text ?? '').join('\n');
+        }
+        return '';
+    })
+        .filter(Boolean)
+        .join('\n');
+}
+const STOP_WORDS = new Set([
+    'the', 'a', 'an', 'and', 'or', 'but', 'in', 'on', 'at', 'to', 'for', 'of', 'with',
+    'by', 'from', 'is', 'are', 'was', 'were', 'be', 'been', 'being', 'have', 'has',
+    'had', 'do', 'does', 'did', 'will', 'would', 'could', 'should', 'may', 'might',
+    'that', 'this', 'it', 'i', 'you', 'we', 'they', 'he', 'she', 'what', 'which',
+    'not', 'as', 'if', 'so', 'up', 'out', 'get', 'use', 'can', 'just', 'then', 'than',
+]);
+function extractKeywords(text) {
+    return text
+        .toLowerCase()
+        .replace(/[^a-z0-9_./\s-]/g, ' ')
+        .split(/\s+/)
+        .filter((w) => w.length > 3 && !STOP_WORDS.has(w))
+        .slice(0, 30);
+}

package/dist/src/validation/coherence.d.ts

@@ -0,0 +1,3 @@
+import type { AnnotatedMessage, LLMMessage, SessionState, CompressionDecision, ValidationResult, ValidationBlocker } from '../types';
+export declare function validate(original: AnnotatedMessage[], compressed: LLMMessage[], decisions: CompressionDecision[], _sessionState: SessionState): ValidationResult;
+export declare function restoreMessages(original: AnnotatedMessage[], compressed: LLMMessage[], blockers: ValidationBlocker[]): LLMMessage[];

package/dist/src/validation/coherence.js

@@ -0,0 +1,87 @@
+"use strict";
+// src/validation/coherence.ts
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validate = validate;
+exports.restoreMessages = restoreMessages;
+const utils_1 = require("../utils");
+function validate(original, compressed, decisions, _sessionState) {
+    const warnings = [];
+    const blockers = [];
+    // Check 1: Constraints not dropped
+    const constraints = original.filter((m) => m.classification === 'SYSTEM_CONSTRAINT' || m.classification === 'USER_CORRECTION');
+    for (const c of constraints) {
+        const decision = decisions.find((d) => d.messageId === c.id);
+        if (decision?.strategy === 'DROP' || decision?.strategy === 'DEDUPLICATE') {
+            blockers.push({
+                type: 'CONSTRAINT_DROPPED',
+                message: `Critical: ${c.classification} at turn ${c.originalIndex} was dropped.`,
+                recoveryAction: 'RESTORE_MESSAGE',
+                messageId: c.id,
+            });
+        }
+    }
+    // Check 2: Task definition preserved
+    const taskDef = original.find((m) => m.classification === 'TASK_DEFINITION');
+    if (taskDef) {
+        const d = decisions.find((dec) => dec.messageId === taskDef.id);
+        if (d?.strategy === 'DROP') {
+            blockers.push({
+                type: 'TASK_DEFINITION_DROPPED',
+                message: 'Critical: task definition was dropped.',
+                recoveryAction: 'RESTORE_MESSAGE',
+                messageId: taskDef.id,
+            });
+        }
+    }
+    // Check 3: Active errors preserved
+    const activeErrors = original.filter((m) => m.classification === 'ERROR_ACTIVE');
+    for (const err of activeErrors) {
+        const d = decisions.find((dec) => dec.messageId === err.id);
+        if (d && d.strategy !== 'PRESERVE') {
+            blockers.push({
+                type: 'ACTIVE_ERROR_COMPRESSED',
+                message: `Active error at turn ${err.originalIndex} was not preserved.`,
+                recoveryAction: 'RESTORE_MESSAGE',
+                messageId: err.id,
+            });
+        }
+    }
+    // Check 4: Non-empty output
+    if (compressed.length === 0) {
+        blockers.push({
+            type: 'EMPTY_OUTPUT',
+            message: 'Compression produced empty context. Aborting.',
+            recoveryAction: 'ABORT_COMPRESSION',
+        });
+    }
+    // Warning: low savings
+    const totalTokens = original.reduce((s, m) => s + m.tokenCount, 0);
+    const totalSaved = decisions.reduce((s, d) => s + (d.tokensBefore - d.tokensAfter), 0);
+    if (totalSaved / totalTokens < 0.10 && original.length > 10) {
+        warnings.push({
+            type: 'LOW_SAVINGS',
+            message: `Only ${Math.round((totalSaved / totalTokens) * 100)}% savings achieved. Context may be genuinely dense.`,
+        });
+    }
+    return { passed: blockers.length === 0, warnings, blockers };
+}
+function restoreMessages(original, compressed, blockers) {
+    const toRestore = blockers
+        .filter((b) => b.recoveryAction === 'RESTORE_MESSAGE' && b.messageId)
+        .map((b) => original.find((m) => m.id === b.messageId))
+        .filter((m) => m !== undefined);
+    if (toRestore.length === 0)
+        return compressed;
+    const result = [...compressed];
+    for (const message of toRestore) {
+        const compressedTexts = result.map((m) => (0, utils_1.extractText)(m));
+        const insertAfter = compressedTexts.reduce((best, _, i) => {
+            const orig = original.find((m) => (0, utils_1.extractText)(m.original) === compressedTexts[i]);
+            if (orig && orig.originalIndex < message.originalIndex)
+                return i;
+            return best;
+        }, -1);
+        result.splice(insertAfter + 1, 0, message.original);
+    }
+    return result;
+}

package/license.md

@@ -0,0 +1,14 @@
+## END USER LICENSE AGREEMENT (EULA)
+
+**1. Grant of License:** Grapine.AI ("Licensor") grants you a non-exclusive, royalty-free, non-transferable license to use the compiled version of this package for any purpose, including commercial applications.
+
+**2. Restrictions:** You shall not:
+- Decompile, reverse engineer, or disassemble the software to attempt to derive the source code.
+- Modify, alter, or create derivative works of the software.
+- Redistribute the package as a standalone product without prior written consent.
+
+**3. Ownership:** All intellectual property rights, including the source code, remain the exclusive property of the Licensor.
+
+**4. Disclaimer of Warranty:** THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED.
+
+**5. Limitation of Liability:** In no event shall the Licensor be liable for any damages arising out of the use or inability to use this software.

package/package.json

@@ -1,41 +1,76 @@
-{
-  "name": "@grapine.ai/contextprune",
-  "version": "0.1.0",
-  "description": "Intelligent context window management for LLM applications",
-  "main": "dist/src/index.js",
-  "types": "dist/src/index.d.ts",
-  "bin": {
-    "contextprune": "dist/cli/index.js"
-  },
-  "scripts": {
-    "build": "tsc",
-    "dev": "tsx watch src/index.ts",
-    "test": "vitest",
-    "test:run": "vitest run",
-    "lint": "tsc --noEmit",
-    "cli": "tsx cli/index.ts"
-  },
-  "keywords": [
-    "llm",
-    "context",
-    "compression",
-    "ai",
-    "tokens"
-  ],
-  "license": "MIT",
-  "dependencies": {
-    "tiktoken": "^1.0.15",
-    "commander": "^11.0.0",
-    "chalk": "^5.3.0",
-    "ora": "^7.0.1",
-    "open": "^9.1.0"
-  },
-  "devDependencies": {
-    "typescript": "^5.3.0",
-    "@types/node": "^20.0.0",
-    "vitest": "^1.0.0",
-    "tsx": "^4.0.0"
-  },
-  "author": "",
-  "type": "commonjs"
-}
+{
+  "name": "@grapine.ai/contextprune",
+  "version": "0.1.1",
+  "description": "Garbage collection for LLM context windows.",
+  "author": "Grapine AI <hello@grapine.ai>",
+  "homepage": "https://www.contextprune.com",
+  "main": "dist/src/index.js",
+  "types": "dist/src/index.d.ts",
+  "bin": {
+    "contextprune": "./dist/cli/index.js"
+  },
+  "scripts": {
+    "build": "tsc -p tsconfig.prod.json && node -e \"require('fs').cpSync('cli/dashboard', 'dist/cli/dashboard', {recursive:true})\"",
+    "dev": "tsx watch src/index.ts",
+    "test": "vitest",
+    "test:run": "vitest run",
+    "lint": "tsc --noEmit",
+    "cli": "tsx cli/index.ts"
+  },
+  "keywords": [
+    "llm",
+    "context",
+    "compression",
+    "ai",
+    "tokens",
+    "context-window",
+    "context",
+    "contextprune",
+    "contextmanagement",
+    "anthropic",
+    "openai",
+    "claude",
+    "agent",
+    "agentic",
+    "pruning",
+    "summarization"
+  ],
+  "license": "SEE LICENSE IN LICENSE.md",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/grapine-ai/contextprune-examples-ts"
+  },
+  "bugs": {
+    "url": "https://github.com/grapine-ai/contextprune-examples-ts/issues"
+  },
+  "files": [
+    "dist/",
+    "README.md",
+    "license.md"
+  ],
+  "exports": {
+    ".": {
+      "require": "./dist/src/index.js",
+      "import": "./dist/src/index.mjs",
+      "types": "./dist/src/index.d.ts"
+    }
+  },
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "dependencies": {
+    "@anthropic-ai/sdk": "^0.78.0",
+    "chalk": "^5.3.0",
+    "commander": "^11.0.0",
+    "open": "^9.1.0",
+    "openai": "^6.27.0",
+    "ora": "^7.0.1",
+    "tiktoken": "^1.0.15"
+  },
+  "devDependencies": {
+    "@types/node": "^20.0.0",
+    "tsx": "^4.0.0",
+    "typescript": "^5.3.0",
+    "vitest": "^1.0.0"
+  }
+}

package/index.js

@@ -1 +0,0 @@
-module.exports = {};