@parseme/cli 0.0.3 → 0.0.4

package/dist/{config.js → core/config.js}

@@ -3,28 +3,35 @@ import { readFile, writeFile } from 'fs/promises';
 import { join, extname } from 'path';
 export class ParsemeConfig {
     config;
+    userConfig;
     constructor(config = {}) {
+        this.userConfig = { ...config }; // Store original user config
         this.config = this.mergeWithDefaults(config);
     }
-    static async fromFileWithOptions(configPath, cliOptions = {}) {
-        const configFromFile = await ParsemeConfig.fromFile(configPath);
+    static async fromFileWithOptions(configPath, cliOptions = {}, options = { showWarnings: true }) {
+        const configFromFile = await ParsemeConfig.fromFile(configPath, options);
         const mergedConfig = {
             ...configFromFile.get(),
             ...cliOptions, // CLI options take priority
         };
         return new ParsemeConfig(mergedConfig);
     }
-    static async fromFile(configPath) {
+    static async fromFile(configPath, options = {
+        showWarnings: true,
+        throwOnNotFound: false,
+    }) {
         const defaultPaths = [
-            'parseme.config.ts',
-            'parseme.config.js',
             'parseme.config.json',
-            '.parsemerc.ts',
-            '.parsemerc.js',
             '.parsemerc.json',
             '.parsemerc',
+            'parseme.config.ts',
+            '.parsemerc.ts',
+            'parseme.config.js',
+            '.parsemerc.js',
         ];
         const paths = configPath ? [configPath] : defaultPaths;
+        let tsWarning = null;
+        let configLoadError = null;
         for (const path of paths) {
             try {
                 const ext = extname(path);
@@ -32,17 +39,18 @@ export class ParsemeConfig {
                     // Dynamic import for JS/TS config files
                     const fullPath = path.startsWith('/') ? path : join(process.cwd(), path);
                     if (ext === '.ts') {
-                        // For TypeScript files, try to import directly first
-                        // This works if the user has transpiled their TS config to JS or is using tsx/ts-node
-                        try {
-                            const module = await import(fullPath);
-                            const config = module.default || module;
-                            return new ParsemeConfig(config);
-                        }
-                        catch {
-                            // If direct import fails, suggest using .js instead
-                            console.warn(`Could not load TypeScript config file: ${path}`);
-                            console.warn(`Consider using a .js config file or ensure tsx/ts-node is available`);
+                        // For TypeScript files, check if file exists first
+                        if (existsSync(fullPath)) {
+                            try {
+                                const module = await import(fullPath);
+                                const config = module.default || module;
+                                return new ParsemeConfig(config);
+                            }
+                            catch (error) {
+                                // File exists but can't be loaded - save warning
+                                tsWarning = path;
+                                configLoadError = { path, error: error };
+                            }
                         }
                     }
                     else {
@@ -54,20 +62,56 @@ export class ParsemeConfig {
                 }
                 else {
                     // JSON config files
-                    const content = await readFile(path, 'utf-8');
+                    const fullPath = path.startsWith('/') ? path : join(process.cwd(), path);
+                    const content = await readFile(fullPath, 'utf-8');
                     const config = JSON.parse(content);
                     return new ParsemeConfig(config);
                 }
             }
-            catch {
+            catch (error) {
+                // If file exists, save the error
+                const fullPath = path.startsWith('/') ? path : join(process.cwd(), path);
+                if (existsSync(fullPath)) {
+                    configLoadError = { path, error: error };
+                }
                 // Continue to next path
             }
         }
+        // Handle case when config file was found but couldn't be loaded
+        if (configLoadError) {
+            const { path, error } = configLoadError;
+            if (options.throwOnNotFound) {
+                throw new Error(`Configuration file "${path}" found but failed to load: ${error.message}`);
+            }
+            if (options.showWarnings) {
+                console.warn(`Configuration file "${path}" found but failed to load: ${error.message}`);
+            }
+        }
+        else {
+            // Handle case when no config found at all
+            if (options.throwOnNotFound) {
+                throw new Error('No configuration file found. Run "parseme init" to create one.');
+            }
+            if (options.showWarnings) {
+                console.warn('No configuration file found. Run "parseme init" to create one.');
+            }
+        }
+        if (tsWarning && !configLoadError && options.showWarnings) {
+            console.warn(`Could not load TypeScript config file: ${tsWarning}`);
+            console.warn(`Consider using a .js config file or ensure tsx/ts-node is available`);
+        }
         // Return default config if no file found
         return new ParsemeConfig();
     }
     mergeWithDefaults(config) {
         const rootDir = config.rootDir || process.cwd();
+        const supportedFileTypes = ['ts', 'tsx', 'js', 'jsx'];
+        // Validate analyzeFileTypes
+        const fileTypes = config.analyzeFileTypes || ['ts', 'tsx', 'js', 'jsx'];
+        const invalidTypes = fileTypes.filter((type) => !supportedFileTypes.includes(type));
+        if (invalidTypes.length > 0) {
+            throw new Error(`Invalid file types: ${invalidTypes.join(', ')}. Supported types are: ${supportedFileTypes.join(', ')}`);
+        }
         return {
             // Output
             outputPath: config.outputPath || 'PARSEME.md',
@@ -76,17 +120,7 @@ export class ParsemeConfig {
             rootDir,
             maxDepth: config.maxDepth || 10,
             excludePatterns: this.mergeExcludePatterns(config.excludePatterns, rootDir),
-            includePatterns: config.includePatterns || [
-                'src/**/*.ts',
-                'src/**/*.js',
-                'src/**/*.tsx',
-                'src/**/*.jsx',
-                'lib/**/*.ts',
-                'lib/**/*.js',
-                'package.json',
-                'tsconfig.json',
-                'README.md',
-            ],
+            analyzeFileTypes: fileTypes,
             // Git
             includeGitInfo: config.includeGitInfo ?? true,
             // Sections
@@ -132,47 +166,36 @@ export class ParsemeConfig {
             await writeFile(path, configContent);
         }
         else {
-            // Generate JSON config file
-            await writeFile(path, JSON.stringify(this.config, null, 2));
+            // Generate JSON config file - only save user config, not defaults
+            await writeFile(path, JSON.stringify(this.userConfig, null, 2));
         }
     }
     generateJSConfig() {
+        // Only export user-specified config, not defaults
         return `/** @type {import('parseme').ParsemeConfigFile} */
-export default ${JSON.stringify(this.config, null, 2)};
+const config = ${JSON.stringify(this.userConfig, null, 2)};
+
+export default config;
 `;
     }
     generateTSConfig() {
+        // Only export user-specified config, not defaults
         return `import type { ParsemeConfigFile } from 'parseme';
 
-const config: ParsemeConfigFile = ${JSON.stringify(this.config, null, 2)};
+const config: ParsemeConfigFile = ${JSON.stringify(this.userConfig, null, 2)};
 
 export default config;
 `;
     }
     mergeExcludePatterns(configPatterns, rootDir) {
-        const defaultPatterns = [
-            'node_modules/**',
-            'dist/**',
-            'build/**',
-            'coverage/**',
-            '.git/**',
-            '**/*.log',
-            '**/*.tmp',
-            '**/.DS_Store',
-            '**/.*',
-        ];
-        // Priority: Config patterns > .gitignore patterns > Default patterns
-        if (configPatterns) {
-            return configPatterns;
-        }
-        // Try to read .gitignore patterns
+        // Always read .gitignore patterns
         const gitignorePatterns = this.readGitignorePatterns(rootDir);
-        if (gitignorePatterns.length > 0) {
-            // Merge gitignore patterns with critical defaults
-            const criticalDefaults = ['node_modules/**', '.git/**'];
-            return [...new Set([...criticalDefaults, ...gitignorePatterns])];
+        // Merge gitignore patterns with config patterns, they are added to gitignore patterns, not replacing them
+        const excludePatterns = [...gitignorePatterns];
+        if (configPatterns) {
+            excludePatterns.push(...configPatterns);
         }
-        return defaultPatterns;
+        return excludePatterns;
     }
     readGitignorePatterns(rootDir) {
         try {
@@ -184,18 +207,7 @@ export default config;
             return gitignoreContent
                 .split('\n')
                 .map((line) => line.trim())
-                .filter((line) => line && !line.startsWith('#'))
-                .map((pattern) => {
-                // Convert gitignore patterns to glob patterns
-                if (pattern.endsWith('/')) {
-                    return pattern + '**';
-                }
-                if (!pattern.includes('/') && !pattern.includes('*')) {
-                    // Convert simple names to match directory patterns
-                    return pattern + '/**';
-                }
-                return pattern;
-            });
+                .filter((line) => line && !line.startsWith('#'));
         }
         catch {
             return [];

package/dist/{builders → core}/context-builder.d.ts

@@ -1,8 +1,9 @@
-import type { ParsemeConfig } from '../config.js';
-import type { ContextOutput, ProjectInfo, FileAnalysis, GitInfo, GeneratorOptions } from '../types.js';
+import type { ParsemeConfig } from './config.js';
+import type { ContextOutput, ProjectInfo, FileAnalysis, GitInfo, GeneratorOptions } from './types.js';
 interface BuildContext {
     projectInfo: ProjectInfo;
     fileAnalyses: FileAnalysis[];
+    allFiles: string[];
     gitInfo?: GitInfo | null;
     options: GeneratorOptions;
     contextDir?: string;
@@ -18,13 +19,7 @@ export declare class ContextBuilder {
     private buildMultiFile;
     private buildHeader;
     private buildProjectOverview;
-    private buildFrameworkSection;
-    private buildArchitectureSection;
-    private buildRoutesSection;
-    private buildFileStructureSection;
-    private buildDependenciesSection;
     private buildGitSection;
-    private buildFooter;
     private buildSummarySection;
     private buildFilesList;
     private buildDetailedStructure;

package/dist/{builders → core}/context-builder.js

@@ -109,7 +109,6 @@ export class ContextBuilder {
         const contextFiles = {
             structure: '',
             routes: '',
-            dependencies: '',
         };
         // Helper function to merge split files into contextFiles
         const mergeSplitFiles = (result, baseName) => {
@@ -123,8 +122,8 @@ export class ContextBuilder {
                 });
             }
         };
-        // Files list (markdown)
-        contextFiles.files = this.buildFilesList(limitedFileAnalyses);
+        // Files list (markdown) - all files in project, not just analyzed ones
+        contextFiles.files = this.buildFilesList(context.allFiles);
         // Detailed structure (JSON with AST)
         const structureResult = this.buildDetailedStructure(limitedFileAnalyses);
         mergeSplitFiles(structureResult, 'structure');
@@ -134,15 +133,6 @@ export class ContextBuilder {
             const routesResult = this.buildDetailedRoutes(routes, limitedFileAnalyses);
             mergeSplitFiles(routesResult, 'api-endpoints');
         }
-        // Dependencies
-        const dependenciesResult = this.buildDetailedDependencies(projectInfo);
-        mergeSplitFiles(dependenciesResult, 'dependencies');
-        // Framework details
-        if (projectInfo.framework &&
-            projectInfo.framework.name &&
-            projectInfo.framework.name !== 'unknown') {
-            contextFiles.framework = this.buildDetailedFramework(projectInfo.framework);
-        }
         // Git information
         if (gitInfo) {
             contextFiles.gitDiff = this.buildDetailedGit(gitInfo);
@@ -194,68 +184,6 @@ Auto-generated project summary optimized for AI coding agents. This file provide
         }
         return content;
     }
-    buildFrameworkSection(framework) {
-        if (!framework) {
-            return '';
-        }
-        const features = framework.features.length > 0 ? `\n- **Features**: ${framework.features.join(', ')}` : '';
-        return `## Framework: ${framework.name}
-
-- **Version**: ${framework.version || 'Unknown'}${features}`;
-    }
-    buildArchitectureSection(fileAnalyses) {
-        const typeGroups = fileAnalyses.reduce((acc, file) => {
-            if (!acc[file.type]) {
-                acc[file.type] = [];
-            }
-            acc[file.type].push(file);
-            return acc;
-        }, {});
-        const archLines = Object.entries(typeGroups)
-            .map(([type, files]) => `- **${type}**: ${files.length} files`)
-            .join('\n');
-        return `## Architecture Overview
-
-${archLines}`;
-    }
-    buildRoutesSection(routes, _fileAnalyses) {
-        const routesByMethod = routes.reduce((acc, route) => {
-            if (!acc[route.method]) {
-                acc[route.method] = [];
-            }
-            acc[route.method].push(route);
-            return acc;
-        }, {});
-        const routeLines = Object.entries(routesByMethod)
-            .map(([method, methodRoutes]) => {
-            const routeList = methodRoutes
-                .map((route) => `  - \`${route.path}\` → ${route.handler}`)
-                .join('\n');
-            return `- **${method}**:\n${routeList}`;
-        })
-            .join('\n');
-        return `## API Endpoints
-
-${routeLines}`;
-    }
-    buildFileStructureSection(fileAnalyses) {
-        const structure = fileAnalyses.map((file) => `- \`${file.path}\` (${file.type})`).join('\n');
-        return `## File Structure
-
-${structure}`;
-    }
-    buildDependenciesSection(projectInfo) {
-        const deps = Object.keys(projectInfo.dependencies);
-        const devDeps = Object.keys(projectInfo.devDependencies);
-        let content = '## Dependencies\n\n';
-        if (deps.length > 0) {
-            content += `**Production**: ${deps.join(', ')}\n\n`;
-        }
-        if (devDeps.length > 0) {
-            content += `**Development**: ${devDeps.join(', ')}`;
-        }
-        return content;
-    }
     buildGitSection(gitInfo) {
         return `## Git Information
 
@@ -271,12 +199,7 @@ Git diff statistics from the time of generation are available at \`parseme-conte
 \`\`\`bash
 git diff --stat
 \`\`\`
-Compare the output with the baseline in \`parseme-context/gitDiff.json\` to detect any modifications.`;
-    }
-    buildFooter() {
-        return `---
-
-*Generated by PARSEME v1.0.0 on ${new Date().toISOString().split('T')[0]}*`;
+Compare the output with the baseline in \`parseme-context/gitDiff.md\` to detect any modifications.`;
     }
     buildSummarySection(context, linkPath) {
         const { fileAnalyses } = context;
@@ -293,11 +216,11 @@ A comprehensive list of all discovered API endpoints is available at \`${linkPat
         }
         return content;
     }
-    buildFilesList(fileAnalyses) {
+    buildFilesList(allFiles) {
         let content = `# Project Files\n\n`;
-        content += `This is a complete list of all analyzed files in the project.\n\n`;
-        fileAnalyses.forEach((file) => {
-            content += `- ${file.path}\n`;
+        content += `This is a complete list of all files in the project (excluding files matching exclude patterns).\n\n`;
+        allFiles.forEach((file) => {
+            content += `- ${file}\n`;
         });
         return content;
     }

package/dist/{generator.d.ts → core/generator.d.ts}

@@ -1,4 +1,3 @@
-import { type ParsemeConfigFile } from './config.js';
 import type { ContextOutput, GeneratorOptions } from './types.js';
 export declare class ParsemeGenerator {
     private readonly config;
@@ -8,8 +7,6 @@ export declare class ParsemeGenerator {
     private readonly gitAnalyzer;
     private readonly contextBuilder;
     constructor(options?: GeneratorOptions);
-    static fromConfig(configPath?: string): Promise<ParsemeGenerator>;
-    static fromConfigWithOptions(configPath?: string, cliOptions?: Partial<ParsemeConfigFile>): Promise<ParsemeGenerator>;
     generate(outputPath?: string): Promise<ContextOutput>;
     generateToFile(outputPath?: string, contextDir?: string): Promise<void>;
 }

package/dist/{generator.js → core/generator.js}

@@ -4,8 +4,8 @@ import { ASTAnalyzer } from './analyzers/ast-analyzer.js';
 import { FrameworkDetector } from './analyzers/framework-detector.js';
 import { GitAnalyzer } from './analyzers/git-analyzer.js';
 import { ProjectAnalyzer } from './analyzers/project-analyzer.js';
-import { ContextBuilder } from './builders/context-builder.js';
 import { ParsemeConfig } from './config.js';
+import { ContextBuilder } from './context-builder.js';
 export class ParsemeGenerator {
     config;
     projectAnalyzer;
@@ -17,18 +17,10 @@ export class ParsemeGenerator {
         this.config = new ParsemeConfig(options);
         this.projectAnalyzer = new ProjectAnalyzer(this.config);
         this.astAnalyzer = new ASTAnalyzer(this.config);
-        this.frameworkDetector = new FrameworkDetector(this.config);
-        this.gitAnalyzer = new GitAnalyzer(this.config);
+        this.frameworkDetector = new FrameworkDetector();
+        this.gitAnalyzer = new GitAnalyzer();
         this.contextBuilder = new ContextBuilder(this.config);
     }
-    static async fromConfig(configPath) {
-        const config = await ParsemeConfig.fromFile(configPath);
-        return new ParsemeGenerator(config.get());
-    }
-    static async fromConfigWithOptions(configPath, cliOptions = {}) {
-        const config = await ParsemeConfig.fromFileWithOptions(configPath, cliOptions);
-        return new ParsemeGenerator(config.get());
-    }
     async generate(outputPath) {
         const configData = this.config.get();
         // Step 1: Analyze the project structure and metadata
@@ -37,16 +29,19 @@ export class ParsemeGenerator {
         projectInfo.framework = await this.frameworkDetector.detect(projectInfo);
         // Step 3: Analyze all relevant files with AST
         const fileAnalyses = await this.astAnalyzer.analyzeProject(configData.rootDir);
-        // Step 4: Get git information if enabled
+        // Step 4: Get all project files (for file list output)
+        const allFiles = await this.projectAnalyzer.getAllProjectFiles(configData.rootDir);
+        // Step 5: Get git information if enabled
         const gitInfo = configData.includeGitInfo
             ? await this.gitAnalyzer.analyze(configData.rootDir)
             : null;
         // Calculate final output path for link generation
         const finalOutputPath = outputPath || configData.outputPath || join(configData.rootDir, 'PARSEME.md');
-        // Step 5: Build the context output
+        // Step 6: Build the context output
         return this.contextBuilder.build({
             projectInfo,
             fileAnalyses,
+            allFiles,
             gitInfo,
             options: configData,
             contextDir: configData.contextDir,

package/dist/core/types/analyzer-types.d.ts

@@ -0,0 +1,39 @@
+import type { ServiceInfo, ModelInfo, ConfigInfo, MiddlewareInfo, UtilityInfo } from '../analyzers/pattern-detector.js';
+export type { ServiceInfo, ModelInfo, ConfigInfo, MiddlewareInfo, UtilityInfo };
+export interface FileAnalysis {
+    path: string;
+    type: 'route' | 'middleware' | 'model' | 'service' | 'utility' | 'config' | 'test' | 'component';
+    framework?: string;
+    exports: string[];
+    imports: string[];
+    functions: string[];
+    classes: string[];
+    routes?: RouteInfo[];
+    components?: ComponentInfo[];
+    services?: ServiceInfo[];
+    models?: ModelInfo[];
+    configs?: ConfigInfo[];
+    middleware?: MiddlewareInfo[];
+    utilities?: UtilityInfo[];
+}
+export interface RouteInfo {
+    method: string;
+    path: string;
+    handler: string;
+    middleware?: string[];
+    file: string;
+    line: number;
+}
+export interface ComponentInfo {
+    name: string;
+    file: string;
+    line: number;
+}
+export interface GitInfo {
+    branch: string;
+    lastCommit: string;
+    changedFiles: string[];
+    status: 'clean' | 'dirty';
+    origin?: string;
+    diffStat?: string;
+}

package/dist/core/types/analyzer-types.js

@@ -0,0 +1,2 @@
+// Types related to file analysis and AST parsing
+export {};

package/dist/{config.d.ts → core/types/config-types.d.ts}

@@ -1,9 +1,15 @@
-import type { GeneratorOptions } from './types.js';
+export interface GeneratorOptions {
+    rootDir?: string;
+    includeGitInfo?: boolean;
+    maxDepth?: number;
+    excludePatterns?: string[];
+    analyzeFileTypes?: string[];
+}
 export interface ParsemeConfigFile extends GeneratorOptions {
     outputPath?: string;
     contextDir?: string;
     rootDir?: string;
-    includePatterns?: string[];
+    analyzeFileTypes?: string[];
     excludePatterns?: string[];
     maxDepth?: number;
     includeGitInfo?: boolean;
@@ -29,16 +35,3 @@ export interface ParsemeConfigFile extends GeneratorOptions {
         truncateStrategy?: 'truncate' | 'split' | 'summarize';
     };
 }
-export declare class ParsemeConfig {
-    private readonly config;
-    constructor(config?: Partial<ParsemeConfigFile>);
-    static fromFileWithOptions(configPath?: string, cliOptions?: Partial<ParsemeConfigFile>): Promise<ParsemeConfig>;
-    static fromFile(configPath?: string): Promise<ParsemeConfig>;
-    private mergeWithDefaults;
-    get(): ParsemeConfigFile;
-    save(path?: string): Promise<void>;
-    private generateJSConfig;
-    private generateTSConfig;
-    private mergeExcludePatterns;
-    private readGitignorePatterns;
-}

package/dist/core/types/config-types.js

@@ -0,0 +1,2 @@
+// Types related to configuration and generator options
+export {};

package/dist/core/types/generator-types.d.ts

@@ -0,0 +1,8 @@
+export interface ContextOutput {
+    parseme: string;
+    context?: {
+        structure: string;
+        routes: string;
+        [key: string]: string;
+    };
+}

package/dist/core/types/generator-types.js

@@ -0,0 +1,2 @@
+// Types related to generator output and context building
+export {};

package/dist/core/types/index.d.ts

@@ -0,0 +1,4 @@
+export * from './analyzer-types.js';
+export * from './config-types.js';
+export * from './generator-types.js';
+export * from './project-types.js';

package/dist/core/types/index.js

@@ -0,0 +1,5 @@
+// Main types index - re-exports all domain-specific types
+export * from './analyzer-types.js';
+export * from './config-types.js';
+export * from './generator-types.js';
+export * from './project-types.js';

package/dist/core/types/project-types.d.ts

@@ -0,0 +1,30 @@
+import type { RouteInfo, ComponentInfo } from './analyzer-types.js';
+export interface ProjectInfo {
+    name: string;
+    version?: string;
+    description?: string;
+    type: 'typescript' | 'javascript' | 'mixed';
+    category: ProjectCategory;
+    packageManager: 'unknown' | 'npm' | 'yarn' | 'pnpm' | 'bun';
+    framework?: FrameworkInfo;
+    buildTool?: BuildToolInfo;
+    dependencies: Record<string, string>;
+    devDependencies: Record<string, string>;
+    scripts?: Record<string, string>;
+    entryPoints?: string[];
+    outputTargets?: string[];
+}
+export type ProjectCategory = 'backend-api' | 'frontend-web' | 'frontend-mobile' | 'npm-package' | 'monorepo' | 'cli-tool' | 'desktop-app' | 'fullstack' | 'unknown';
+export interface FrameworkInfo {
+    name: string;
+    version?: string;
+    features: string[];
+    routes?: RouteInfo[];
+    components?: ComponentInfo[];
+}
+export interface BuildToolInfo {
+    name: string;
+    version?: string;
+    configFiles: string[];
+    features: string[];
+}

package/dist/core/types/project-types.js

@@ -0,0 +1,2 @@
+// Types related to project information and framework detection
+export {};

package/dist/core/types.d.ts

@@ -0,0 +1 @@
+export * from './types/index.js';

package/dist/core/types.js

@@ -0,0 +1,2 @@
+// Core types for the parseme package - re-exports from organized type modules
+export * from './types/index.js';

package/dist/index.d.ts

@@ -1,4 +1,3 @@
-export { ParsemeGenerator } from './generator.js';
-export { ParsemeConfig } from './config.js';
-export type { GeneratorOptions, ContextOutput, ProjectInfo, FrameworkInfo, RouteInfo, FileAnalysis, GitInfo, } from './types.js';
-export type { ParsemeConfigFile } from './config.js';
+export { ParsemeGenerator } from './core/generator.js';
+export { ParsemeConfig } from './core/config.js';
+export type { GeneratorOptions, ContextOutput, ProjectInfo, FrameworkInfo, RouteInfo, FileAnalysis, GitInfo, ParsemeConfigFile, } from './core/types.js';

package/dist/index.js

@@ -1,3 +1,3 @@
 // Main exports for the parseme package
-export { ParsemeGenerator } from './generator.js';
-export { ParsemeConfig } from './config.js';
+export { ParsemeGenerator } from './core/generator.js';
+export { ParsemeConfig } from './core/config.js';

package/package.json

@@ -1,12 +1,12 @@
 {
   "name": "@parseme/cli",
-  "version": "0.0.3",
+  "version": "0.0.4",
   "description": "Adds a PARSEME.md file—a README.md for AI agents—to your project, providing context and structure for automated tools.",
   "type": "module",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",
   "bin": {
-    "parseme": "dist/cli.js"
+    "parseme": "dist/cli/cli.js"
   },
   "files": [
     "dist",
@@ -24,12 +24,11 @@
     "format:check": "prettier . --ignore-unknown --check",
     "lint": "eslint --config ./eslint.config.js --fix",
     "lint:check": "eslint --config ./eslint.config.js --no-fix --max-warnings 0",
-    "test": "node --test --experimental-test-coverage tests/**/*.test.ts",
+    "test": "node --test --experimental-test-coverage 'tests/**/*.test.ts'",
     "test:unit": "node --test tests/unit/**/*.test.ts",
     "test:integration": "node --test tests/integration/**/*.test.ts",
     "test:watch": "node --test --watch tests/**/*.test.ts",
     "test:coverage": "node --test --experimental-test-coverage tests/**/*.test.ts",
-    "prepare": "npm run build",
     "clean": "rm -rf dist"
   },
   "keywords": [