continuous-improvement 3.12.3 → 3.16.0

package/bin/plan-pack.mjs

@@ -0,0 +1,77 @@
+#!/usr/bin/env node
+/**
+ * plan-pack (`ci-plan-pack`).
+ *
+ * Turn a plan doc into a commentable review packet a colleague can mark up.
+ *
+ *   node bin/plan-pack.mjs <plan.md>            write <plan>.review.md
+ *   node bin/plan-pack.mjs <plan.md> --stdout   print the packet to stdout
+ *   node bin/plan-pack.mjs <plan.md> --gh-issue write the packet, then print a
+ *                                               ready-to-run `gh issue create`
+ *                                               command (does NOT auto-post)
+ */
+import { readFileSync, writeFileSync } from "node:fs";
+import { extname } from "node:path";
+import { pathToFileURL } from "node:url";
+import { buildReviewPacket } from "../lib/plan-review-packet.mjs";
+function getErrorMessage(error) {
+    return error instanceof Error ? error.message : String(error);
+}
+function reviewPathFor(source) {
+    const ext = extname(source);
+    return ext ? `${source.slice(0, -ext.length)}.review${ext}` : `${source}.review.md`;
+}
+function packetTitle(packet) {
+    const match = /^# Review packet: (.*)$/m.exec(packet);
+    return match ? match[1].trim() : "Plan review";
+}
+const HELP = `
+plan-pack (ci-plan-pack) - turn a plan doc into a commentable review packet
+
+Usage: ci-plan-pack <plan.md> [--stdout] [--gh-issue]
+
+Options:
+  --stdout      Print the packet to stdout instead of writing a file
+  --gh-issue    Write the packet, then print a 'gh issue create' command
+                (does not post anything - you run it)
+
+Examples:
+  ci-plan-pack docs/plans/2026-06-15-plan-pack.md
+  ci-plan-pack docs/plans/2026-06-15-plan-pack.md --stdout
+`;
+function main() {
+    const args = process.argv.slice(2);
+    if (args.length === 0 || args.includes("--help") || args.includes("-h")) {
+        console.log(HELP);
+        process.exit(args.length === 0 ? 1 : 0);
+    }
+    const toStdout = args.includes("--stdout");
+    const ghIssue = args.includes("--gh-issue");
+    const source = args.find((a) => !a.startsWith("-"));
+    if (!source) {
+        throw new Error("Usage: ci-plan-pack <plan.md> [--stdout] [--gh-issue]");
+    }
+    const markdown = readFileSync(source, "utf8");
+    const packet = buildReviewPacket(markdown, { source });
+    if (toStdout) {
+        process.stdout.write(packet.endsWith("\n") ? packet : `${packet}\n`);
+        return;
+    }
+    const outPath = reviewPathFor(source);
+    writeFileSync(outPath, packet.endsWith("\n") ? packet : `${packet}\n`);
+    console.log(`Wrote review packet: ${outPath}`);
+    if (ghIssue) {
+        const title = packetTitle(packet);
+        console.log("\nTo open it for comments on GitHub, run:");
+        console.log(`  gh issue create --title "${title}" --body-file "${outPath}"`);
+    }
+}
+if (process.argv[1] && import.meta.url === pathToFileURL(process.argv[1]).href) {
+    try {
+        main();
+    }
+    catch (error) {
+        console.error(`Error: ${getErrorMessage(error)}`);
+        process.exit(1);
+    }
+}

package/bin/unified-cli.mjs

@@ -1,33 +1,26 @@
 #!/usr/bin/env node
 /**
- * Unified Continuous Improvement CLI.
+ * CLI-Anything command (`ci`).
  *
- * Comprehensive command-line interface for the unified plugin that combines
- * CLI-Anything, Compound Engineering, and PM-Skills.
+ * Thin front-end over the CLIAnything library: turns a repository into an
+ * agent-native CLI wrapper that a language model can drive.
+ *
+ * The former Compound Engineering and PM-Skills tools (and the unified-plugin
+ * orchestrator that combined all three) were removed in 3.13.0 - Compound
+ * Engineering overlapped the Mulahazah instinct engine and PM-Skills overlapped
+ * the out-of-band phuryn/pm-skills marketplace install. See CHANGELOG [3.13.0].
  */
 import { existsSync, readFileSync } from "node:fs";
 import { join } from "node:path";
-import UnifiedContinuousImprovement from "../lib/unified-plugin.mjs";
+import CLIAnything from "../lib/cli-anything.mjs";
 const DEFAULT_CONFIG = {
     workspace: "./ci-workspace",
     verbose: false,
-    defaultMode: "expert",
 };
 function getErrorMessage(error) {
     return error instanceof Error ? error.message : String(error);
 }
-function parseJsonOption(raw) {
-    if (!raw)
-        return undefined;
-    try {
-        return JSON.parse(raw);
-    }
-    catch (error) {
-        throw new Error(`Invalid JSON option: ${getErrorMessage(error)}`);
-    }
-}
 class UnifiedCLI {
-    plugin = null;
     config;
     constructor() {
         this.config = this.loadConfig();
@@ -40,350 +33,48 @@ class UnifiedCLI {
                 return { ...DEFAULT_CONFIG, ...parsed };
             }
             catch {
-                console.warn("Warning: Invalid config file, using defaults");
+                console.warn("Warning: invalid config file, using defaults");
             }
         }
         return { ...DEFAULT_CONFIG };
     }
-    initializePlugin(options) {
-        this.plugin = new UnifiedContinuousImprovement({
-            workspace: options.workspace ?? this.config.workspace,
-            verbose: options.verbose ?? this.config.verbose,
-        });
-        return this.plugin;
-    }
-    requirePlugin() {
-        if (!this.plugin) {
-            throw new Error("CLI plugin not initialized");
-        }
-        return this.plugin;
-    }
     async runCommand(command, args, options = {}) {
-        this.initializePlugin(options);
         switch (command) {
-            case "init":
-                return this.handleInit(args, options);
-            case "workflow":
-                return this.handleWorkflow(args, options);
-            case "research":
-                return this.handleResearch(options);
-            case "planning":
-                return this.handlePlanning(options);
-            case "execution":
-                return this.handleExecution();
-            case "review":
-                return this.handleReview(options);
-            case "status":
-                return this.handleStatus();
-            case "cli":
-                return this.handleCLI(args);
-            case "pm":
-                return this.handlePM(args, options);
-            case "compound":
-                return this.handleCompound(args);
-            case "learnings":
-                return this.handleLearnings(args);
+            case "generate":
+                return this.handleGenerate(args, options);
+            case "list":
+                return this.handleList();
             case "config":
                 return this.handleConfig(args);
             default:
                 throw new Error(`Unknown command: ${command}`);
         }
     }
-    async handleInit(args, options) {
-        if (args.length < 2) {
-            throw new Error("Usage: ci init <project-name> <objective> [options]");
-        }
-        const [name, ...objectiveParts] = args;
-        const objective = objectiveParts.join(" ");
-        console.log(`🚀 Initializing project: ${name}`);
-        console.log(`📋 Objective: ${objective}`);
-        const plugin = this.requirePlugin();
-        const result = await plugin.initializeProject({
-            name: name,
-            objective,
-            product: parseJsonOption(options.product) ?? {},
-            industry: options.industry ?? "",
-            targetMarket: parseJsonOption(options.targetMarket) ?? {},
-        });
-        console.log(`✅ Project initialized successfully!`);
-        console.log(`🆔 Project ID: ${result.projectId}`);
-        console.log(`🔗 Session ID: ${result.sessionId}`);
-        console.log(`📊 PM Analysis: ${result.pmAnalysis.totalSkills} skills completed`);
-        console.log(`\n🎯 Next steps:`);
-        result.nextSteps.forEach((step, i) => {
-            console.log(`   ${i + 1}. ${step}`);
-        });
-        return result;
-    }
-    async handleWorkflow(args, options) {
-        if (args.length < 2) {
-            throw new Error("Usage: ci workflow <project-name> <objective> [options]");
+    async handleGenerate(args, options) {
+        const repoPath = args[0];
+        if (!repoPath) {
+            throw new Error("Usage: ci generate <repository-path>");
         }
-        const [name, ...objectiveParts] = args;
-        const objective = objectiveParts.join(" ");
-        console.log(`🚀 Starting complete workflow for: ${name}`);
-        console.log(`📋 Objective: ${objective}`);
-        const progressCallback = (message) => {
-            console.log(`   ⏳ ${message}`);
-        };
-        const plugin = this.requirePlugin();
-        const result = await plugin.executeCompleteWorkflow({
-            name: name,
-            objective,
-            product: parseJsonOption(options.product) ?? {},
-            industry: options.industry ?? "",
-            targetMarket: parseJsonOption(options.targetMarket) ?? {},
-        }, {
-            researchContext: options.repo ? { repositoryPath: options.repo } : {},
-            progressCallback,
+        const cliAnything = new CLIAnything({
+            outputDir: options.workspace ?? this.config.workspace,
+            verbose: options.verbose ?? this.config.verbose,
         });
-        console.log(`🎉 Complete workflow finished!`);
-        console.log(`🆔 Project: ${result.project}`);
-        console.log(`🔗 Session: ${result.sessionId}`);
-        for (const [phase] of Object.entries(result.phases)) {
-            console.log(`\n📊 ${phase.charAt(0).toUpperCase() + phase.slice(1)} Phase:`);
-        }
-        return result;
-    }
-    async handleResearch(options) {
-        console.log(`🔍 Starting research phase...`);
-        const context = {};
-        if (options.repo)
-            context.repositoryPath = options.repo;
-        if (options.context)
-            context.additionalContext = parseJsonOption(options.context);
-        const plugin = this.requirePlugin();
-        const result = await plugin.executeResearchPhase(context);
-        console.log(`✅ Research phase completed!`);
-        console.log(`💡 Generated ${result.brainstorm.ideas.length} ideas`);
-        console.log(`🔍 Identified ${result.brainstorm.risks.length} risks`);
-        if (result.cliTools) {
-            console.log(`🛠️  Generated CLI with ${result.cliTools.commands.length} commands`);
-        }
-        return result;
-    }
-    async handlePlanning(options) {
-        console.log(`📋 Starting planning phase...`);
-        const preferences = parseJsonOption(options.preferences) ?? {};
-        const plugin = this.requirePlugin();
-        const result = await plugin.executePlanningPhase(preferences);
-        console.log(`✅ Planning phase completed!`);
-        console.log(`📈 Created plan with ${result.corePlan.steps.length} steps`);
-        const estimated = result.corePlan.timeline?.estimated;
-        if (estimated)
-            console.log(`⏱️  Timeline: ${estimated}`);
-        console.log(`⚠️  Identified ${result.risks.length} risks`);
-        return result;
-    }
-    async handleExecution() {
-        console.log(`🔧 Starting execution phase...`);
-        const progressCallback = (message) => {
-            console.log(`   ⚡ ${message}`);
-        };
-        const plugin = this.requirePlugin();
-        const result = await plugin.executeWorkingPhase(progressCallback);
-        console.log(`✅ Execution phase completed!`);
-        console.log(`📋 Completed ${result.coreWork.steps.length} steps`);
-        console.log(`🔧 Resolved ${result.issues.length} issues`);
-        console.log(`💡 Applied ${result.solutions.length} solutions`);
-        return result;
-    }
-    async handleReview(options) {
-        console.log(`🔍 Starting review phase...`);
-        const criteria = parseJsonOption(options.criteria);
-        const plugin = this.requirePlugin();
-        const result = await plugin.executeReviewPhase(criteria);
-        console.log(`✅ Review phase completed!`);
-        console.log(`📊 Overall score: ${result.coreReview.review.overallScore}/100`);
-        console.log(`💡 Generated ${result.learnings.length} learnings`);
-        console.log(`📋 Created ${result.recommendations.length} recommendations`);
-        return result;
-    }
-    async handleStatus() {
-        const plugin = this.requirePlugin();
-        const status = await plugin.getProjectStatus();
-        console.log(`📊 Project Status:`);
-        console.log(`   Project: ${status.project ?? "No active project"}`);
-        console.log(`   Session: ${status.sessionId ?? "N/A"}`);
-        console.log(`   Current Phase: ${status.currentPhase ?? "N/A"}`);
-        if (status.progress) {
-            console.log(`   Progress: ${status.progress.completed}/${status.progress.total} (${status.progress.percentage}%)`);
-        }
-        if (status.nextSteps && status.nextSteps.length > 0) {
-            console.log(`\n🎯 Next Steps:`);
-            status.nextSteps.forEach((step, i) => {
-                console.log(`   ${i + 1}. ${step}`);
-            });
-        }
-        return status;
-    }
-    async handleCLI(args) {
-        const [subcommand, ...subArgs] = args;
-        switch (subcommand) {
-            case "generate":
-                if (subArgs.length === 0) {
-                    throw new Error("Usage: ci cli generate <repository-path>");
-                }
-                return this.handleCLIGenerate(subArgs[0]);
-            case "list":
-                return this.handleCLIList();
-            default:
-                throw new Error("Usage: ci cli <generate|list> [args]");
-        }
-    }
-    async handleCLIGenerate(repoPath) {
-        console.log(`🛠️  Generating CLI for: ${repoPath}`);
-        const plugin = this.requirePlugin();
-        const result = await plugin.cliAnything.generateCLI(repoPath);
-        console.log(`✅ CLI generated successfully!`);
-        console.log(`📁 Output: ${result.outputPath}`);
-        console.log(`🔧 Commands: ${result.commands.length}`);
-        console.log(`\n📋 Available Commands:`);
+        const result = await cliAnything.generateCLI(repoPath);
+        console.log(`Generated CLI for: ${repoPath}`);
+        console.log(`  Output: ${result.outputPath}`);
+        console.log(`  Commands: ${result.commands.length}`);
         for (const cmd of result.commands) {
-            console.log(`   ${cmd.name.padEnd(15)} - ${cmd.description}`);
+            console.log(`    ${cmd.name.padEnd(15)} ${cmd.description}`);
         }
         return result;
     }
-    handleCLIList() {
-        console.log(`🛠️  CLI Generation Tool Status: Ready`);
-        console.log(`   Repository Analysis: Supported`);
-        console.log(`   Project Types: Node.js, React, Python, Docker, and more`);
-        console.log(`   Output Format: Executable JavaScript`);
+    handleList() {
+        console.log("CLI-Anything status: ready");
+        console.log("  Repository analysis: supported");
+        console.log("  Project types: Node.js, React, Python, Docker, and more");
+        console.log("  Output format: executable JavaScript");
     }
-    async handlePM(args, options) {
-        const [subcommand, ...subArgs] = args;
-        switch (subcommand) {
-            case "analyze":
-                return this.handlePMAnalyze(options);
-            case "skill":
-                return this.handlePMSkill(subArgs);
-            case "list":
-                return this.handlePMList();
-            default:
-                throw new Error("Usage: ci pm <analyze|skill|list> [args]");
-        }
-    }
-    async handlePMAnalyze(options) {
-        console.log(`📊 Running comprehensive PM analysis...`);
-        const productInfo = {
-            product: parseJsonOption(options.product) ?? {},
-            industry: options.industry ?? "Technology",
-            targetMarket: parseJsonOption(options.targetMarket) ?? {},
-        };
-        const plugin = this.requirePlugin();
-        const result = await plugin.pmSkills.runProductAnalysis(productInfo);
-        console.log(`✅ PM analysis completed!`);
-        console.log(`📊 Summary: ${result.summary.completedSkills}/${result.summary.totalSkills} skills completed`);
-        console.log(`💡 Key insights: ${result.summary.keyInsights.length}`);
-        console.log(`📋 Recommendations: ${result.summary.recommendations.length}`);
-        console.log(`📁 Results saved to: ${result.savedTo}`);
-        return result;
-    }
-    async handlePMSkill(args) {
-        if (args.length === 0) {
-            throw new Error("Usage: ci pm skill <skill-name>");
-        }
-        const [skillName] = args;
-        console.log(`📊 Executing PM skill: ${skillName}`);
-        const input = {
-            product: { name: "Sample Product" },
-            market: { size: "Medium" },
-        };
-        const plugin = this.requirePlugin();
-        const result = await plugin.pmSkills.executeSkill(skillName, input);
-        console.log(`✅ PM skill ${skillName} completed!`);
-        console.log(`📁 Results saved to: ${result.savedTo}`);
-        return result;
-    }
-    handlePMList() {
-        const plugin = this.requirePlugin();
-        const skills = plugin.pmSkills.getAvailableSkills();
-        console.log(`📊 Available PM Skills:`);
-        for (const skill of skills) {
-            console.log(`   ${skill.name.padEnd(20)} - ${skill.description} [${skill.category}]`);
-        }
-    }
-    async handleCompound(args) {
-        const [subcommand, ...subArgs] = args;
-        switch (subcommand) {
-            case "session":
-                return this.handleCompoundSession(subArgs);
-            case "learnings":
-                return this.handleCompoundLearnings();
-            default:
-                throw new Error("Usage: ci compound <session|learnings> [args]");
-        }
-    }
-    async handleCompoundSession(args) {
-        if (args.length < 2) {
-            throw new Error("Usage: ci compound session <project-name> <objective>");
-        }
-        const [name, ...objectiveParts] = args;
-        const objective = objectiveParts.join(" ");
-        console.log(`🔧 Starting compound engineering session...`);
-        const plugin = this.requirePlugin();
-        const session = await plugin.compoundEngineering.startSession(name, objective);
-        console.log(`✅ Session started!`);
-        console.log(`🆔 Session ID: ${session.id}`);
-        console.log(`📋 Objective: ${session.objective}`);
-        console.log(`🔄 Current Phase: ${session.phase}`);
-        return session;
-    }
-    async handleCompoundLearnings() {
-        console.log(`📚 Loading compound engineering learnings...`);
-        const plugin = this.requirePlugin();
-        await plugin.compoundEngineering.loadLearnings();
-        const learnings = plugin.compoundEngineering.getAllLearnings();
-        console.log(`📚 Found ${learnings.length} learnings:`);
-        for (const learning of learnings) {
-            console.log(`   [${learning.confidence.toFixed(2)}] ${learning.summary}`);
-        }
-        return learnings;
-    }
-    async handleLearnings(args) {
-        const [subcommand, ...subArgs] = args;
-        switch (subcommand) {
-            case "search":
-                return this.handleLearningsSearch(subArgs.join(" "));
-            case "all":
-                return this.handleLearningsAll();
-            default:
-                throw new Error("Usage: ci learnings <search|all> [query]");
-        }
-    }
-    async handleLearningsSearch(query) {
-        console.log(`🔍 Searching learnings for: "${query}"`);
-        const plugin = this.requirePlugin();
-        await plugin.compoundEngineering.loadLearnings();
-        const results = plugin.compoundEngineering.searchLearnings(query);
-        console.log(`🔍 Found ${results.length} matching learnings:`);
-        for (const learning of results) {
-            console.log(`   [${learning.confidence.toFixed(2)}] ${learning.summary}`);
-        }
-        return results;
-    }
-    async handleLearningsAll() {
-        console.log(`📚 Loading all learnings...`);
-        const plugin = this.requirePlugin();
-        await plugin.compoundEngineering.loadLearnings();
-        const learnings = plugin.compoundEngineering.getAllLearnings();
-        console.log(`📚 Total learnings: ${learnings.length}`);
-        const grouped = learnings.reduce((groups, learning) => {
-            const type = learning.type || "general";
-            if (!groups[type])
-                groups[type] = [];
-            groups[type].push(learning);
-            return groups;
-        }, {});
-        for (const [type, items] of Object.entries(grouped)) {
-            console.log(`\n   ${type.charAt(0).toUpperCase() + type.slice(1)} (${items.length}):`);
-            for (const learning of items) {
-                console.log(`     [${learning.confidence.toFixed(2)}] ${learning.summary}`);
-            }
-        }
-        return learnings;
-    }
-    async handleConfig(args) {
+    handleConfig(args) {
         const [subcommand, ...subArgs] = args;
         switch (subcommand) {
             case "show":
@@ -395,15 +86,11 @@ class UnifiedCLI {
         }
     }
     handleConfigShow() {
-        console.log(`⚙️  Current Configuration:`);
-        console.log(`   Workspace: ${this.config.workspace}`);
-        console.log(`   Verbose: ${this.config.verbose}`);
-        console.log(`   Default Mode: ${this.config.defaultMode}`);
+        console.log("Current configuration:");
+        console.log(`  Workspace: ${this.config.workspace}`);
+        console.log(`  Verbose: ${this.config.verbose}`);
     }
     handleConfigSet(args) {
-        if (args.length < 2) {
-            throw new Error("Usage: ci config set <key> <value>");
-        }
         const [key, value] = args;
         if (!key || value === undefined) {
             throw new Error("Usage: ci config set <key> <value>");
@@ -414,13 +101,10 @@ class UnifiedCLI {
         else if (key === "verbose") {
             this.config.verbose = value === "true";
         }
-        else if (key === "defaultMode") {
-            this.config.defaultMode = value;
-        }
         else {
             throw new Error(`Unknown config key: ${key}`);
         }
-        console.log(`✅ Configuration updated: ${key} = ${value}`);
+        console.log(`Configuration updated: ${key} = ${value}`);
     }
 }
 function parseGlobalOptions(args) {
@@ -428,34 +112,19 @@ function parseGlobalOptions(args) {
     for (let i = 0; i < args.length; i++) {
         const flag = args[i];
         const next = args[i + 1];
-        const consumeValue = (key) => {
-            if (next === undefined)
-                return;
-            options[key] = next;
-            args.splice(i, 2);
-            i--;
-        };
         switch (flag) {
             case "--workspace":
-                consumeValue("workspace");
+                if (next !== undefined) {
+                    options.workspace = next;
+                    args.splice(i, 2);
+                    i--;
+                }
                 break;
             case "--verbose":
                 options.verbose = true;
                 args.splice(i, 1);
                 i--;
                 break;
-            case "--repo":
-                consumeValue("repo");
-                break;
-            case "--product":
-                consumeValue("product");
-                break;
-            case "--industry":
-                consumeValue("industry");
-                break;
-            case "--target-market":
-                consumeValue("targetMarket");
-                break;
             default:
                 break;
         }
@@ -464,49 +133,25 @@ function parseGlobalOptions(args) {
 }
 async function main() {
     const [, , command, ...args] = process.argv;
-    if (!command || command === "--help" || command === "-h") {
+    if (!command || command === "--help" || command === "-h" || command === "help") {
         console.log(`
-Unified Continuous Improvement CLI
+CLI-Anything (ci) - turn a repository into an agent-native CLI
 
 Usage: ci <command> [args] [options]
 
-Main Commands:
-  init <name> <objective>        Initialize new project with comprehensive analysis
-  workflow <name> <objective>    Run complete end-to-end workflow
-  research                       Execute research phase
-  planning                       Execute planning phase
-  execution                      Execute execution phase
-  review                         Execute review phase
-  status                         Show project status
-
-Tool Commands:
-  cli generate <repo-path>       Generate CLI for repository
-  pm analyze                     Run comprehensive PM analysis
-  pm skill <name>                Execute specific PM skill
-  pm list                        List available PM skills
-  compound session <name> <obj>  Start compound engineering session
-  compound learnings             Show compound engineering learnings
-  learnings search <query>       Search through all learnings
-  learnings all                  Show all learnings
-
-Configuration:
-  config show                    Show current configuration
-  config set <key> <value>       Set configuration value
+Commands:
+  generate <repo-path>      Analyze a repository and generate an agent-native CLI wrapper
+  list                      Show CLI-Anything capabilities
+  config show               Show current configuration
+  config set <key> <value>  Set a configuration value (workspace | verbose)
 
 Global Options:
-  --workspace <dir>              Workspace directory
-  --verbose                      Enable verbose logging
-  --repo <path>                  Repository path for CLI generation
-  --product <json>               Product information as JSON
-  --industry <name>              Industry name
-  --target-market <json>         Target market as JSON
+  --workspace <dir>         Workspace directory (default: ./ci-workspace)
+  --verbose                 Enable verbose logging
 
 Examples:
-  ci init "MyApp" "Build a task management app"
-  ci workflow "MyApp" "Build task management" --repo ./my-app
-  ci cli generate ./my-repo
-  ci pm analyze --industry "SaaS" --target-market '{"segment":"SMB"}'
-  ci learnings search "performance"
+  ci generate ./my-repo
+  ci config set workspace ./out
 `);
         process.exit(0);
     }
@@ -515,18 +160,18 @@ Examples:
     try {
         const result = await cli.runCommand(command, args, options);
         if (options.verbose && result) {
-            console.log(`\n🔍 Detailed result:`);
+            console.log("\nDetailed result:");
             console.log(JSON.stringify(result, null, 2));
         }
     }
     catch (error) {
-        console.error(`❌ Error: ${getErrorMessage(error)}`);
+        console.error(`Error: ${getErrorMessage(error)}`);
         process.exit(1);
     }
 }
 if (import.meta.url === `file://${process.argv[1]}`) {
     main().catch((error) => {
-        console.error(`❌ Fatal error: ${getErrorMessage(error)}`);
+        console.error(`Fatal error: ${getErrorMessage(error)}`);
         process.exit(1);
     });
 }