codeep 1.2.10 → 1.2.12

package/dist/utils/agent.js

@@ -3,7 +3,7 @@
  */
 import { existsSync, readFileSync } from 'fs';
 import { join } from 'path';
-import { recordTokenUsage, extractOpenAIUsage, extractAnthropicUsage } from './tokenTracker.js';
+import { recordTokenUsage, extractOpenAIUsage, extractAnthropicUsage } from './tokenTracker';
 // Debug logging helper - only logs when CODEEP_DEBUG=1
 const debug = (...args) => {
     if (process.env.CODEEP_DEBUG === '1') {
@@ -38,13 +38,13 @@ function calculateDynamicTimeout(prompt, iteration, baseTimeout) {
     const calculatedTimeout = baseTimeout * multiplier;
     return Math.min(Math.max(calculatedTimeout, 120000), 300000);
 }
-import { parseToolCalls, executeTool, createActionLog, formatToolDefinitions, getOpenAITools, getAnthropicTools, parseOpenAIToolCalls, parseAnthropicToolCalls } from './tools.js';
-import { config, getApiKey } from '../config/index.js';
-import { getProviderBaseUrl, getProviderAuthHeader, supportsNativeTools } from '../config/providers.js';
-import { startSession, endSession, undoLastAction, undoAllActions, getCurrentSession, getRecentSessions, formatSession } from './history.js';
-import { runAllVerifications, formatErrorsForAgent, hasVerificationErrors, getVerificationSummary } from './verify.js';
-import { gatherSmartContext, formatSmartContext, extractTargetFile } from './smartContext.js';
-import { planTasks, formatTaskPlan } from './taskPlanner.js';
+import { parseToolCalls, executeTool, createActionLog, formatToolDefinitions, getOpenAITools, getAnthropicTools, parseOpenAIToolCalls, parseAnthropicToolCalls } from './tools';
+import { config, getApiKey } from '../config/index';
+import { getProviderBaseUrl, getProviderAuthHeader, supportsNativeTools } from '../config/providers';
+import { startSession, endSession, undoLastAction, undoAllActions, getCurrentSession, getRecentSessions, formatSession } from './history';
+import { runAllVerifications, formatErrorsForAgent, hasVerificationErrors, getVerificationSummary } from './verify';
+import { gatherSmartContext, formatSmartContext, extractTargetFile } from './smartContext';
+import { planTasks, formatTaskPlan } from './taskPlanner';
 const DEFAULT_OPTIONS = {
     maxIterations: 100, // Increased for large tasks
     maxDuration: 20 * 60 * 1000, // 20 minutes
@@ -919,7 +919,7 @@ export async function runAgent(prompt, projectContext, options = {}) {
                 }
                 else {
                     // Actually execute the tool
-                    toolResult = executeTool(toolCall, projectContext.root || process.cwd());
+                    toolResult = await executeTool(toolCall, projectContext.root || process.cwd());
                 }
                 opts.onToolResult?.(toolResult, toolCall);
                 // Log action
@@ -1010,7 +1010,7 @@ export async function runAgent(prompt, projectContext, options = {}) {
                         const fixResults = [];
                         for (const toolCall of fixToolCalls) {
                             opts.onToolCall?.(toolCall);
-                            const toolResult = executeTool(toolCall, projectContext.root || process.cwd());
+                            const toolResult = await executeTool(toolCall, projectContext.root || process.cwd());
                             opts.onToolResult?.(toolResult, toolCall);
                             const actionLog = createActionLog(toolCall, toolResult);
                             actions.push(actionLog);

package/dist/utils/agent.test.js

@@ -11,7 +11,7 @@ vi.mock('fs', async (importOriginal) => {
 });
 import { existsSync, readFileSync } from 'fs';
 import { join } from 'path';
-import { loadProjectRules, formatAgentResult } from './agent.js';
+import { loadProjectRules, formatAgentResult } from './agent';
 // Cast mocked functions for convenience
 const mockExistsSync = existsSync;
 const mockReadFileSync = readFileSync;

package/dist/utils/codeReview.js

@@ -3,7 +3,7 @@
  */
 import { existsSync, readFileSync, readdirSync } from 'fs';
 import { join, extname, relative } from 'path';
-import { getChangedFiles } from './git.js';
+import { getChangedFiles } from './git';
 // Common code patterns that indicate issues
 const CODE_PATTERNS = [
     // Security issues

package/dist/utils/context.js

@@ -4,7 +4,7 @@
 import { existsSync, readFileSync, writeFileSync, mkdirSync, readdirSync, unlinkSync } from 'fs';
 import { join, basename } from 'path';
 import { homedir } from 'os';
-import { logger } from './logger.js';
+import { logger } from './logger';
 // Context storage directory
 const CONTEXT_DIR = join(homedir(), '.codeep', 'contexts');
 /**

package/dist/utils/git.test.js

@@ -3,7 +3,7 @@ import { execSync } from 'child_process';
 import { mkdirSync, rmSync, writeFileSync } from 'fs';
 import { join } from 'path';
 import { tmpdir } from 'os';
-import { isGitRepository, getGitStatus, getGitDiff, getChangedFiles, suggestCommitMessage, createCommit, stageAll, formatDiffForDisplay, } from './git.js';
+import { isGitRepository, getGitStatus, getGitDiff, getChangedFiles, suggestCommitMessage, createCommit, stageAll, formatDiffForDisplay, } from './git';
 // Create a temp directory for git tests
 const TEST_DIR = join(tmpdir(), 'codeep-git-test-' + Date.now());
 const NON_GIT_DIR = join(tmpdir(), 'codeep-non-git-test-' + Date.now());

package/dist/utils/gitignore.test.js

@@ -5,7 +5,7 @@ vi.mock('fs', () => ({
     readFileSync: vi.fn(),
 }));
 import { existsSync, readFileSync } from 'fs';
-import { loadIgnoreRules, isIgnored } from './gitignore.js';
+import { loadIgnoreRules, isIgnored } from './gitignore';
 const mockExistsSync = existsSync;
 const mockReadFileSync = readFileSync;
 beforeEach(() => {

package/dist/utils/keychain.js

@@ -1,5 +1,5 @@
 import keytar from 'keytar';
-import { logger } from './logger.js';
+import { logger } from './logger';
 const SERVICE_NAME = 'codeep';
 class KeychainStorage {
     getAccountName(providerId) {

package/dist/utils/project.test.js

@@ -2,7 +2,7 @@ import { describe, it, expect, beforeEach, afterEach } from 'vitest';
 import { mkdirSync, rmSync, writeFileSync } from 'fs';
 import { join } from 'path';
 import { tmpdir } from 'os';
-import { isProjectDirectory, getProjectType, scanDirectory, generateTreeStructure, readProjectFile, deleteProjectFile, writeProjectFile, } from './project.js';
+import { isProjectDirectory, getProjectType, scanDirectory, generateTreeStructure, readProjectFile, deleteProjectFile, writeProjectFile, } from './project';
 const TEST_DIR = join(tmpdir(), 'codeep-project-test-' + Date.now());
 describe('project utilities', () => {
     beforeEach(() => {

package/dist/utils/ratelimit.js

@@ -1,7 +1,7 @@
 /**
  * Rate limiting utility to prevent API abuse
  */
-import { config } from '../config/index.js';
+import { config } from '../config/index';
 class RateLimiter {
     requests = [];
     config;

package/dist/utils/ratelimit.test.js

@@ -1,5 +1,5 @@
 import { describe, it, expect, beforeEach, vi } from 'vitest';
-import { checkApiRateLimit, checkCommandRateLimit, resetRateLimits, getRateLimitStatus, } from './ratelimit.js';
+import { checkApiRateLimit, checkCommandRateLimit, resetRateLimits, getRateLimitStatus, } from './ratelimit';
 describe('ratelimit utilities', () => {
     beforeEach(() => {
         // Reset rate limiters before each test

package/dist/utils/retry.test.js

@@ -1,5 +1,5 @@
 import { describe, it, expect, vi } from 'vitest';
-import { withRetry, isNetworkError, isTimeoutError, fetchWithTimeout, } from './retry.js';
+import { withRetry, isNetworkError, isTimeoutError, fetchWithTimeout, } from './retry';
 describe('retry utilities', () => {
     describe('isNetworkError', () => {
         it('should detect fetch TypeError', () => {

package/dist/utils/smartContext.js

@@ -3,7 +3,7 @@
  */
 import { existsSync, readFileSync, statSync } from 'fs';
 import { join, dirname, basename, extname, relative } from 'path';
-import { loadIgnoreRules, isIgnored } from './gitignore.js';
+import { loadIgnoreRules, isIgnored } from './gitignore';
 // Max context size (characters)
 const MAX_CONTEXT_SIZE = 50000;
 const MAX_FILES = 15;

package/dist/utils/smartContext.test.js

@@ -1,5 +1,5 @@
 import { describe, it, expect } from 'vitest';
-import { extractTargetFile, formatSmartContext, } from './smartContext.js';
+import { extractTargetFile, formatSmartContext, } from './smartContext';
 // ---------------------------------------------------------------------------
 // Helper to build a SmartContextResult quickly
 // ---------------------------------------------------------------------------

package/dist/utils/taskPlanner.js

@@ -1,8 +1,8 @@
 /**
  * Task Planning - breaks down complex tasks into subtasks
  */
-import { config, getApiKey } from '../config/index.js';
-import { getProviderBaseUrl, getProviderAuthHeader } from '../config/providers.js';
+import { config, getApiKey } from '../config/index';
+import { getProviderBaseUrl, getProviderAuthHeader } from '../config/providers';
 /**
  * Ask AI to break down a complex task into subtasks
  */

package/dist/utils/tools.d.ts

@@ -199,10 +199,70 @@ export declare const AGENT_TOOLS: {
             };
         };
     };
+    web_search: {
+        name: string;
+        description: string;
+        parameters: {
+            query: {
+                type: string;
+                description: string;
+                required: boolean;
+            };
+            domain_filter: {
+                type: string;
+                description: string;
+                required: boolean;
+            };
+            recency: {
+                type: string;
+                description: string;
+                required: boolean;
+            };
+        };
+    };
+    web_read: {
+        name: string;
+        description: string;
+        parameters: {
+            url: {
+                type: string;
+                description: string;
+                required: boolean;
+            };
+            format: {
+                type: string;
+                description: string;
+                required: boolean;
+            };
+        };
+    };
+    github_read: {
+        name: string;
+        description: string;
+        parameters: {
+            repo: {
+                type: string;
+                description: string;
+                required: boolean;
+            };
+            action: {
+                type: string;
+                description: string;
+                required: boolean;
+            };
+            query: {
+                type: string;
+                description: string;
+                required: boolean;
+            };
+            path: {
+                type: string;
+                description: string;
+                required: boolean;
+            };
+        };
+    };
 };
-/**
- * Format tool definitions for system prompt (text-based fallback)
- */
 export declare function formatToolDefinitions(): string;
 /**
  * Get tools in OpenAI Function Calling format
@@ -230,7 +290,7 @@ export declare function parseToolCalls(response: string): ToolCall[];
 /**
  * Execute a tool call
  */
-export declare function executeTool(toolCall: ToolCall, projectRoot: string): ToolResult;
+export declare function executeTool(toolCall: ToolCall, projectRoot: string): Promise<ToolResult>;
 /**
  * Create action log from tool result
  */

package/dist/utils/tools.js

@@ -9,9 +9,87 @@ const debug = (...args) => {
     }
 };
 import { join, dirname, relative, resolve, isAbsolute } from 'path';
-import { executeCommand } from './shell.js';
-import { recordWrite, recordEdit, recordDelete, recordMkdir, recordCommand } from './history.js';
-import { loadIgnoreRules, isIgnored } from './gitignore.js';
+import { executeCommand } from './shell';
+import { recordWrite, recordEdit, recordDelete, recordMkdir, recordCommand } from './history';
+import { loadIgnoreRules, isIgnored } from './gitignore';
+import { config, getApiKey } from '../config/index';
+import { getProviderMcpEndpoints } from '../config/providers';
+// Z.AI MCP tool names (available when user has any Z.AI API key)
+const ZAI_MCP_TOOLS = ['web_search', 'web_read', 'github_read'];
+// Z.AI provider IDs that have MCP endpoints
+const ZAI_PROVIDER_IDS = ['z.ai', 'z.ai-cn'];
+/**
+ * Find a Z.AI provider that has an API key configured.
+ * Returns the provider ID and API key, or null if none found.
+ * Prefers the active provider if it's Z.AI, otherwise checks all Z.AI providers.
+ */
+function getZaiMcpConfig() {
+    // First check if active provider is Z.AI
+    const activeProvider = config.get('provider');
+    if (ZAI_PROVIDER_IDS.includes(activeProvider)) {
+        const key = getApiKey(activeProvider);
+        const endpoints = getProviderMcpEndpoints(activeProvider);
+        if (key && endpoints?.webSearch && endpoints?.webReader && endpoints?.zread) {
+            return { providerId: activeProvider, apiKey: key, endpoints: endpoints };
+        }
+    }
+    // Otherwise check all Z.AI providers for a configured key
+    for (const pid of ZAI_PROVIDER_IDS) {
+        const key = getApiKey(pid);
+        const endpoints = getProviderMcpEndpoints(pid);
+        if (key && endpoints?.webSearch && endpoints?.webReader && endpoints?.zread) {
+            return { providerId: pid, apiKey: key, endpoints: endpoints };
+        }
+    }
+    return null;
+}
+/**
+ * Check if Z.AI MCP tools are available (user has any Z.AI API key)
+ */
+function hasZaiMcpAccess() {
+    return getZaiMcpConfig() !== null;
+}
+/**
+ * Call a Z.AI MCP endpoint via JSON-RPC 2.0
+ */
+async function callZaiMcp(endpoint, toolName, args, apiKey) {
+    const controller = new AbortController();
+    const timeout = setTimeout(() => controller.abort(), 60000);
+    try {
+        const response = await fetch(endpoint, {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json',
+                'Accept': 'application/json',
+                'Authorization': `Bearer ${apiKey}`,
+            },
+            body: JSON.stringify({
+                jsonrpc: '2.0',
+                id: Date.now().toString(),
+                method: 'tools/call',
+                params: { name: toolName, arguments: args },
+            }),
+            signal: controller.signal,
+        });
+        if (!response.ok) {
+            const errorText = await response.text().catch(() => '');
+            throw new Error(`MCP error ${response.status}: ${errorText || response.statusText}`);
+        }
+        const data = await response.json();
+        if (data.error) {
+            throw new Error(data.error.message || JSON.stringify(data.error));
+        }
+        // MCP returns result.content as array of {type, text} blocks
+        const content = data.result?.content;
+        if (Array.isArray(content)) {
+            return content.map((c) => c.text || '').join('\n');
+        }
+        return typeof data.result === 'string' ? data.result : JSON.stringify(data.result);
+    }
+    finally {
+        clearTimeout(timeout);
+    }
+}
 // Tool definitions for system prompt
 export const AGENT_TOOLS = {
     read_file: {
@@ -91,13 +169,51 @@ export const AGENT_TOOLS = {
             url: { type: 'string', description: 'The URL to fetch content from', required: true },
         },
     },
+    web_search: {
+        name: 'web_search',
+        description: 'Search the web for real-time information. Returns titles, URLs, and summaries. Requires a Z.AI API key.',
+        parameters: {
+            query: { type: 'string', description: 'Search query', required: true },
+            domain_filter: { type: 'string', description: 'Limit results to specific domain (e.g. github.com)', required: false },
+            recency: { type: 'string', description: 'Time filter: oneDay, oneWeek, oneMonth, oneYear, noLimit', required: false },
+        },
+    },
+    web_read: {
+        name: 'web_read',
+        description: 'Fetch and parse a web page into clean readable text/markdown. Better than fetch_url for documentation and articles. Requires a Z.AI API key.',
+        parameters: {
+            url: { type: 'string', description: 'The URL to read', required: true },
+            format: { type: 'string', description: 'Output format: markdown or text (default: markdown)', required: false },
+        },
+    },
+    github_read: {
+        name: 'github_read',
+        description: 'Search documentation/code or read files from a public GitHub repository. Requires a Z.AI API key.',
+        parameters: {
+            repo: { type: 'string', description: 'GitHub repository in owner/repo format (e.g. facebook/react)', required: true },
+            action: { type: 'string', description: 'Action: search, tree, or read_file', required: true },
+            query: { type: 'string', description: 'Search query (for action=search)', required: false },
+            path: { type: 'string', description: 'File path (for action=read_file) or directory path (for action=tree)', required: false },
+        },
+    },
 };
 /**
  * Format tool definitions for system prompt (text-based fallback)
  */
+/**
+ * Get filtered tool entries (excludes Z.AI-only tools when not using Z.AI provider)
+ */
+function getFilteredToolEntries() {
+    const hasMcp = hasZaiMcpAccess();
+    return Object.entries(AGENT_TOOLS).filter(([name]) => {
+        if (ZAI_MCP_TOOLS.includes(name))
+            return hasMcp;
+        return true;
+    });
+}
 export function formatToolDefinitions() {
     const lines = [];
-    for (const [name, tool] of Object.entries(AGENT_TOOLS)) {
+    for (const [name, tool] of getFilteredToolEntries()) {
         lines.push(`### ${name}`);
         lines.push(tool.description);
         lines.push('Parameters:');
@@ -113,7 +229,7 @@ export function formatToolDefinitions() {
  * Get tools in OpenAI Function Calling format
  */
 export function getOpenAITools() {
-    return Object.entries(AGENT_TOOLS).map(([name, tool]) => {
+    return getFilteredToolEntries().map(([name, tool]) => {
         const properties = {};
         const required = [];
         for (const [param, info] of Object.entries(tool.parameters)) {
@@ -153,7 +269,7 @@ export function getOpenAITools() {
  * Get tools in Anthropic Tool Use format
  */
 export function getAnthropicTools() {
-    return Object.entries(AGENT_TOOLS).map(([name, tool]) => {
+    return getFilteredToolEntries().map(([name, tool]) => {
         const properties = {};
         const required = [];
         for (const [param, info] of Object.entries(tool.parameters)) {
@@ -609,7 +725,7 @@ function validatePath(path, projectRoot) {
 /**
  * Execute a tool call
  */
-export function executeTool(toolCall, projectRoot) {
+export async function executeTool(toolCall, projectRoot) {
     // Normalize tool name to handle case variations (WRITE_FILE -> write_file)
     const tool = normalizeToolName(toolCall.tool);
     const parameters = toolCall.parameters;
@@ -899,6 +1015,90 @@ export function executeTool(toolCall, projectRoot) {
                     return { success: false, output: '', error: result.stderr || 'Failed to fetch URL', tool, parameters };
                 }
             }
+            // === Z.AI MCP Tools ===
+            case 'web_search': {
+                const mcpConfig = getZaiMcpConfig();
+                if (!mcpConfig) {
+                    return { success: false, output: '', error: 'web_search requires a Z.AI API key. Configure one via /provider z.ai', tool, parameters };
+                }
+                const query = parameters.query;
+                if (!query) {
+                    return { success: false, output: '', error: 'Missing required parameter: query', tool, parameters };
+                }
+                const args = { search_query: query };
+                if (parameters.domain_filter)
+                    args.search_domain_filter = parameters.domain_filter;
+                if (parameters.recency)
+                    args.search_recency_filter = parameters.recency;
+                const result = await callZaiMcp(mcpConfig.endpoints.webSearch, 'webSearchPrime', args, mcpConfig.apiKey);
+                const output = result.length > 15000 ? result.substring(0, 15000) + '\n\n... (truncated)' : result;
+                return { success: true, output, tool, parameters };
+            }
+            case 'web_read': {
+                const mcpConfig = getZaiMcpConfig();
+                if (!mcpConfig) {
+                    return { success: false, output: '', error: 'web_read requires a Z.AI API key. Configure one via /provider z.ai', tool, parameters };
+                }
+                const url = parameters.url;
+                if (!url) {
+                    return { success: false, output: '', error: 'Missing required parameter: url', tool, parameters };
+                }
+                try {
+                    new URL(url);
+                }
+                catch {
+                    return { success: false, output: '', error: 'Invalid URL format', tool, parameters };
+                }
+                const args = { url };
+                if (parameters.format)
+                    args.return_format = parameters.format;
+                const result = await callZaiMcp(mcpConfig.endpoints.webReader, 'webReader', args, mcpConfig.apiKey);
+                const output = result.length > 15000 ? result.substring(0, 15000) + '\n\n... (truncated)' : result;
+                return { success: true, output, tool, parameters };
+            }
+            case 'github_read': {
+                const mcpConfig = getZaiMcpConfig();
+                if (!mcpConfig) {
+                    return { success: false, output: '', error: 'github_read requires a Z.AI API key. Configure one via /provider z.ai', tool, parameters };
+                }
+                const repo = parameters.repo;
+                const action = parameters.action;
+                if (!repo) {
+                    return { success: false, output: '', error: 'Missing required parameter: repo', tool, parameters };
+                }
+                if (!repo.includes('/')) {
+                    return { success: false, output: '', error: 'Invalid repo format. Use owner/repo (e.g. facebook/react)', tool, parameters };
+                }
+                if (!action || !['search', 'tree', 'read_file'].includes(action)) {
+                    return { success: false, output: '', error: 'Invalid action. Must be: search, tree, or read_file', tool, parameters };
+                }
+                let mcpToolName;
+                const args = { repo_name: repo };
+                if (action === 'search') {
+                    mcpToolName = 'search_doc';
+                    const query = parameters.query;
+                    if (!query) {
+                        return { success: false, output: '', error: 'Missing required parameter: query (for action=search)', tool, parameters };
+                    }
+                    args.query = query;
+                }
+                else if (action === 'tree') {
+                    mcpToolName = 'get_repo_structure';
+                    if (parameters.path)
+                        args.dir_path = parameters.path;
+                }
+                else {
+                    mcpToolName = 'read_file';
+                    const filePath = parameters.path;
+                    if (!filePath) {
+                        return { success: false, output: '', error: 'Missing required parameter: path (for action=read_file)', tool, parameters };
+                    }
+                    args.file_path = filePath;
+                }
+                const result = await callZaiMcp(mcpConfig.endpoints.zread, mcpToolName, args, mcpConfig.apiKey);
+                const output = result.length > 15000 ? result.substring(0, 15000) + '\n\n... (truncated)' : result;
+                return { success: true, output, tool, parameters };
+            }
             default:
                 return { success: false, output: '', error: `Unknown tool: ${tool}`, tool, parameters };
         }
@@ -1014,11 +1214,16 @@ export function createActionLog(toolCall, result) {
         create_directory: 'mkdir',
         find_files: 'search',
         fetch_url: 'fetch',
+        web_search: 'fetch',
+        web_read: 'fetch',
+        github_read: 'fetch',
     };
     const target = toolCall.parameters.path ||
         toolCall.parameters.command ||
         toolCall.parameters.pattern ||
         toolCall.parameters.url ||
+        toolCall.parameters.query ||
+        toolCall.parameters.repo ||
         'unknown';
     // For write/edit actions, include FULL content in details for live code view
     let details;

package/dist/utils/tools.test.js

@@ -1,5 +1,5 @@
 import { describe, it, expect } from 'vitest';
-import { getOpenAITools, getAnthropicTools, parseToolCalls, parseOpenAIToolCalls, parseAnthropicToolCalls, createActionLog, AGENT_TOOLS, } from './tools.js';
+import { getOpenAITools, getAnthropicTools, parseToolCalls, parseOpenAIToolCalls, parseAnthropicToolCalls, createActionLog, AGENT_TOOLS, } from './tools';
 // ─── CONSTANTS ───────────────────────────────────────────────────────────────
 const ALL_TOOL_NAMES = Object.keys(AGENT_TOOLS);
 // ─── getOpenAITools ──────────────────────────────────────────────────────────

package/dist/utils/validation.test.js

@@ -1,5 +1,5 @@
 import { describe, it, expect } from 'vitest';
-import { validateInput, validateApiKey, validateCommandArgs, validateFilePath, sanitizeOutput, } from './validation.js';
+import { validateInput, validateApiKey, validateCommandArgs, validateFilePath, sanitizeOutput, } from './validation';
 describe('validation utilities', () => {
     describe('validateInput', () => {
         it('should reject empty input', () => {

package/dist/utils/verify.js

@@ -4,7 +4,7 @@
  */
 import { existsSync, readFileSync } from 'fs';
 import { join } from 'path';
-import { executeCommand } from './shell.js';
+import { executeCommand } from './shell';
 const DEFAULT_OPTIONS = {
     runBuild: true,
     runTest: true,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "codeep",
-  "version": "1.2.10",
+  "version": "1.2.12",
   "description": "AI-powered coding assistant built for the terminal. Multiple LLM providers, project-aware context, and a seamless development workflow.",
   "type": "module",
   "main": "dist/index.js",

package/bin/codeep.js

@@ -1,2 +0,0 @@
-#!/usr/bin/env node
-import '../dist/renderer/main.js';

package/dist/app.d.ts

@@ -1,2 +0,0 @@
-import React from 'react';
-export declare const App: React.FC;