@loghead/core 0.1.1 → 0.1.3

package/dist/api/server.js

@@ -0,0 +1,111 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.startApiServer = startApiServer;
+const express_1 = __importDefault(require("express"));
+const cors_1 = __importDefault(require("cors"));
+const auth_1 = require("../services/auth");
+const chalk_1 = __importDefault(require("chalk"));
+const auth = new auth_1.AuthService();
+async function startApiServer(db) {
+    const app = (0, express_1.default)();
+    const port = process.env.PORT || 4567;
+    app.use((0, cors_1.default)());
+    app.use(express_1.default.json());
+    await auth.initialize();
+    console.log(chalk_1.default.bold.green(`✔ Loghead Core API Server running on http://localhost:${port}`));
+    app.post("/api/ingest", async (req, res) => {
+        try {
+            const authHeader = req.headers.authorization;
+            if (!authHeader || !authHeader.startsWith("Bearer ")) {
+                return res.status(401).send("Unauthorized: Missing token");
+            }
+            const token = authHeader.split(" ")[1];
+            const payload = await auth.verifyToken(token);
+            if (!payload || !payload.streamId) {
+                return res.status(401).send("Unauthorized: Invalid token");
+            }
+            const { streamId, logs } = req.body;
+            if (streamId !== payload.streamId) {
+                return res.status(403).send("Forbidden: Token does not match streamId");
+            }
+            if (!logs) {
+                return res.status(400).send("Missing logs");
+            }
+            const logEntries = Array.isArray(logs) ? logs : [logs];
+            for (const log of logEntries) {
+                let content = "";
+                let metadata = {};
+                if (typeof log === "string") {
+                    content = log;
+                }
+                else if (typeof log === "object") {
+                    content = log.content || JSON.stringify(log);
+                    metadata = log.metadata || {};
+                }
+                if (content) {
+                    await db.addLog(streamId, content, metadata);
+                }
+            }
+            res.json({ success: true, count: logEntries.length });
+        }
+        catch (e) {
+            console.error("Ingest error:", e);
+            res.status(500).json({ error: String(e) });
+        }
+    });
+    app.get("/api/projects", (req, res) => {
+        const projects = db.listProjects();
+        res.json(projects);
+    });
+    app.post("/api/projects", (req, res) => {
+        const projects = db.listProjects();
+        res.json(projects);
+    });
+    app.get("/api/streams", (req, res) => {
+        const projectId = req.query.projectId;
+        if (projectId) {
+            const streams = db.listStreams(projectId);
+            res.json(streams);
+        }
+        else {
+            res.status(400).send("Missing projectId");
+        }
+    });
+    app.post("/api/streams", (req, res) => {
+        const projectId = req.body.projectId;
+        if (projectId) {
+            const streams = db.listStreams(projectId);
+            res.json(streams);
+        }
+        else {
+            res.status(400).send("Missing projectId");
+        }
+    });
+    app.post("/api/streams/create", async (req, res) => {
+        const body = req.body;
+        const stream = await db.createStream(body.projectId, body.type, body.name, {});
+        res.json(stream);
+    });
+    app.get("/api/logs", async (req, res) => {
+        const streamId = req.query.streamId;
+        if (!streamId) {
+            return res.status(400).send("Missing streamId");
+        }
+        const limit = parseInt(req.query.limit || "50");
+        const query = req.query.q;
+        let logs;
+        if (query) {
+            logs = await db.searchLogs(streamId, query, limit);
+        }
+        else {
+            logs = db.getRecentLogs(streamId, limit);
+        }
+        res.json(logs);
+    });
+    app.listen(port, () => {
+        // listening
+    });
+}

package/dist/cli_main.js

@@ -0,0 +1,68 @@
+#!/usr/bin/env node
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const yargs_1 = __importDefault(require("yargs"));
+const helpers_1 = require("yargs/helpers");
+const db_1 = require("./services/db");
+const server_1 = require("./api/server");
+const migrate_1 = require("./db/migrate");
+// import { ensureInfrastructure } from "./utils/startup"; // Might need adjustment
+const main_1 = require("./ui/main");
+const db = new db_1.DbService();
+async function main() {
+    const argv = await (0, yargs_1.default)((0, helpers_1.hideBin)(process.argv))
+        .command("init", "Initialize/Migrate database", {}, async () => {
+        console.log("Initializing database...");
+        await (0, migrate_1.migrate)();
+    })
+        .command("start", "Start API Server", {}, async () => {
+        // await ensureInfrastructure();
+        await (0, server_1.startApiServer)(db);
+    })
+        .command("ui", "Start Terminal UI", {}, async () => {
+        await (0, main_1.startTui)(db);
+    })
+        .command("projects <cmd> [name]", "Manage projects", (yargs) => {
+        yargs
+            .command("list", "List projects", {}, () => {
+            const projects = db.listProjects();
+            console.table(projects);
+        })
+            .command("add <name>", "Add project", {}, (argv) => {
+            const p = db.createProject(argv.name);
+            console.log(`Project created: ${p.id}`);
+        });
+    })
+        .command("streams <cmd> [type] [name]", "Manage streams", (yargs) => {
+        yargs
+            .command("list", "List streams", {
+            project: { type: "string", demandOption: true }
+        }, (argv) => {
+            const streams = db.listStreams(argv.project);
+            console.table(streams);
+        })
+            .command("add <type> <name>", "Add stream", {
+            project: { type: "string", demandOption: true },
+            container: { type: "string" }
+        }, async (argv) => {
+            const config = {};
+            if (argv.type === "docker" && argv.container) {
+                config.container = argv.container;
+            }
+            const s = await db.createStream(argv.project, argv.type, argv.name, config);
+            console.log(`Stream created: ${s.id}`);
+            console.log(`Token: ${s.token}`);
+        });
+    })
+        .demandCommand(1)
+        .strict()
+        .help()
+        .parse();
+}
+main().catch(err => {
+    console.error(err);
+    process.exit(1);
+});

package/dist/db/client.js

@@ -0,0 +1,53 @@
+"use strict";
+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;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.db = void 0;
+const better_sqlite3_1 = __importDefault(require("better-sqlite3"));
+const sqliteVec = __importStar(require("sqlite-vec"));
+const dotenv_1 = __importDefault(require("dotenv"));
+dotenv_1.default.config();
+const dbPath = process.env.LOGHEAD_DB_PATH || "loghead.db";
+const db = new better_sqlite3_1.default(dbPath);
+exports.db = db;
+// Load sqlite-vec extension
+try {
+    sqliteVec.load(db);
+}
+catch (e) {
+    console.error("Failed to load sqlite-vec extension:", e);
+}

package/dist/db/migrate.js

@@ -0,0 +1,65 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.migrate = migrate;
+const client_1 = require("./client");
+function migrate(verbose = true) {
+    if (verbose)
+        console.log("Running migrations...");
+    // Enable foreign keys
+    client_1.db.exec("PRAGMA foreign_keys = ON;");
+    // System Config table (for secrets, etc.)
+    client_1.db.exec(`
+    CREATE TABLE IF NOT EXISTS system_config (
+      key TEXT PRIMARY KEY,
+      value TEXT NOT NULL
+    );
+  `);
+    // Projects table
+    client_1.db.exec(`
+    CREATE TABLE IF NOT EXISTS projects (
+      id TEXT PRIMARY KEY,
+      name TEXT NOT NULL,
+      created_at DATETIME DEFAULT CURRENT_TIMESTAMP
+    );
+  `);
+    // Data Streams table
+    client_1.db.exec(`
+    CREATE TABLE IF NOT EXISTS data_streams (
+      id TEXT PRIMARY KEY,
+      project_id TEXT,
+      type TEXT NOT NULL,
+      name TEXT NOT NULL,
+      config TEXT DEFAULT '{}',
+      created_at DATETIME DEFAULT CURRENT_TIMESTAMP,
+      FOREIGN KEY(project_id) REFERENCES projects(id) ON DELETE CASCADE
+    );
+  `);
+    // Logs table
+    client_1.db.exec(`
+    CREATE TABLE IF NOT EXISTS logs (
+      id TEXT PRIMARY KEY,
+      stream_id TEXT,
+      content TEXT NOT NULL,
+      timestamp DATETIME DEFAULT CURRENT_TIMESTAMP,
+      metadata TEXT DEFAULT '{}',
+      FOREIGN KEY(stream_id) REFERENCES data_streams(id) ON DELETE CASCADE
+    );
+  `);
+    // Vector table (using sqlite-vec)
+    // Assuming 1024 dimensions for qwen3-embedding:0.6b (check actual dim)
+    // qwen2.5-0.5b is 1536?
+    // qwen-embedding-0.6b might be 384 or 1024?
+    // Let's assume 1024 as per previous code.
+    try {
+        client_1.db.exec(`
+      CREATE VIRTUAL TABLE IF NOT EXISTS vec_logs USING vec0(
+        embedding float[1024]
+      );
+    `);
+    }
+    catch (e) {
+        console.warn("Failed to create virtual vector table. Is sqlite-vec loaded?", e);
+    }
+    if (verbose)
+        console.log("Migrations complete.");
+}

package/dist/services/auth.js

@@ -0,0 +1,48 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AuthService = void 0;
+const jsonwebtoken_1 = __importDefault(require("jsonwebtoken"));
+const client_1 = require("../db/client");
+const crypto_1 = require("crypto");
+class AuthService {
+    secretKey = null;
+    async initialize() {
+        if (this.secretKey)
+            return;
+        // Try to load secret from DB
+        const row = client_1.db.prepare("SELECT value FROM system_config WHERE key = 'jwt_secret'").get();
+        let rawSecret = row?.value;
+        if (!rawSecret) {
+            // Generate new secret
+            rawSecret = (0, crypto_1.randomBytes)(64).toString('hex');
+            client_1.db.prepare("INSERT INTO system_config (key, value) VALUES ('jwt_secret', ?)").run(rawSecret);
+        }
+        this.secretKey = rawSecret;
+    }
+    async createStreamToken(streamId) {
+        await this.initialize();
+        if (!this.secretKey)
+            throw new Error("Auth not initialized");
+        const token = jsonwebtoken_1.default.sign({ sub: streamId, iss: "loghead" }, this.secretKey, { algorithm: "HS512" });
+        return token;
+    }
+    async verifyToken(token) {
+        await this.initialize();
+        if (!this.secretKey)
+            throw new Error("Auth not initialized");
+        try {
+            const payload = jsonwebtoken_1.default.verify(token, this.secretKey, { issuer: "loghead", algorithms: ["HS512"] });
+            if (!payload.sub)
+                return null;
+            return { streamId: payload.sub };
+        }
+        catch (e) {
+            console.error("Token verification failed:", e);
+            return null;
+        }
+    }
+}
+exports.AuthService = AuthService;

package/dist/services/db.js

@@ -0,0 +1,157 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DbService = void 0;
+const client_1 = require("../db/client");
+const ollama_1 = require("./ollama");
+const auth_1 = require("./auth");
+const crypto_1 = require("crypto");
+const ollama = new ollama_1.OllamaService();
+const auth = new auth_1.AuthService();
+class DbService {
+    createProject(name) {
+        const id = (0, crypto_1.randomUUID)();
+        client_1.db.prepare("INSERT INTO projects (id, name) VALUES (?, ?)").run(id, name);
+        return this.getProject(id);
+    }
+    getProject(id) {
+        return client_1.db.prepare("SELECT * FROM projects WHERE id = ?").get(id);
+    }
+    deleteProject(id) {
+        client_1.db.prepare("DELETE FROM projects WHERE id = ?").run(id);
+        return true;
+    }
+    listProjects() {
+        console.error("Listing projects...");
+        try {
+            const projects = client_1.db.prepare("SELECT * FROM projects ORDER BY created_at DESC").all();
+            console.error(`Found ${projects.length} projects.`);
+            return projects.map((p) => {
+                const streams = client_1.db.prepare("SELECT * FROM data_streams WHERE project_id = ?").all(p.id);
+                return { ...p, streams };
+            });
+        }
+        catch (e) {
+            console.error("Error in listProjects:", e);
+            throw e;
+        }
+    }
+    async createStream(projectId, type, name, config = {}) {
+        const id = (0, crypto_1.randomUUID)();
+        client_1.db.prepare("INSERT INTO data_streams (id, project_id, type, name, config) VALUES (?, ?, ?, ?, ?)").run(id, projectId, type, name, JSON.stringify(config));
+        const token = await auth.createStreamToken(id);
+        const stream = this.getStream(id);
+        return { ...stream, token };
+    }
+    getStream(id) {
+        const stream = client_1.db.prepare("SELECT * FROM data_streams WHERE id = ?").get(id);
+        if (stream && typeof stream.config === "string") {
+            try {
+                stream.config = JSON.parse(stream.config);
+            }
+            catch { /* ignore */ }
+        }
+        return stream;
+    }
+    deleteStream(id) {
+        client_1.db.prepare("DELETE FROM data_streams WHERE id = ?").run(id);
+        return true;
+    }
+    listStreams(projectId) {
+        const streams = client_1.db.prepare("SELECT * FROM data_streams WHERE project_id = ? ORDER BY created_at DESC").all(projectId);
+        return streams.map((s) => {
+            if (typeof s.config === "string")
+                try {
+                    s.config = JSON.parse(s.config);
+                }
+                catch { /* ignore */ }
+            return s;
+        });
+    }
+    async addLog(streamId, content, metadata = {}) {
+        // Generate embedding
+        let embedding = null;
+        try {
+            embedding = await ollama.generateEmbedding(content);
+        }
+        catch (_e) {
+            // console.warn("Embedding failed", _e);
+        }
+        const id = (0, crypto_1.randomUUID)();
+        const metadataStr = JSON.stringify(metadata);
+        // Manual Transaction
+        const insertTx = client_1.db.transaction(() => {
+            // 1. Insert into logs
+            client_1.db.prepare("INSERT INTO logs (id, stream_id, content, metadata) VALUES (?, ?, ?, ?)").run(id, streamId, content, metadataStr);
+            // 2. Get rowid
+            const rowInfo = client_1.db.prepare("SELECT last_insert_rowid() as rowid").get();
+            const rowid = rowInfo.rowid;
+            // 3. Insert into vec_logs if embedding exists
+            if (embedding && embedding.length > 0) {
+                const vectorJson = JSON.stringify(embedding);
+                client_1.db.prepare("INSERT INTO vec_logs(rowid, embedding) VALUES (?, ?)").run(rowid, vectorJson);
+            }
+        });
+        try {
+            insertTx();
+        }
+        catch (e) {
+            throw e;
+        }
+        return { id };
+    }
+    async searchLogs(streamId, query, limit = 10) {
+        const embedding = await ollama.generateEmbedding(query);
+        if (!embedding)
+            return [];
+        const vectorJson = JSON.stringify(embedding);
+        // KNN Search
+        const rows = client_1.db.prepare(`
+      SELECT l.content, l.timestamp, l.metadata, v.distance
+      FROM vec_logs v
+      JOIN logs l ON l.rowid = v.rowid
+      WHERE v.embedding MATCH ? AND k = ? AND l.stream_id = ?
+      ORDER BY v.distance
+    `).all(vectorJson, limit, streamId);
+        return rows.map((row) => {
+            let meta;
+            try {
+                meta = JSON.parse(row.metadata);
+            }
+            catch { /* ignore */ }
+            return {
+                content: row.content,
+                timestamp: row.timestamp,
+                similarity: 1 - row.distance, // Rough approx
+                metadata: (meta && Object.keys(meta).length > 0) ? meta : undefined
+            };
+        });
+    }
+    getRecentLogs(streamId, limit = 50) {
+        const rows = client_1.db.prepare(`
+      SELECT content, timestamp, metadata FROM logs
+      WHERE stream_id = ?
+      ORDER BY timestamp DESC
+      LIMIT ?
+    `).all(streamId, limit);
+        return rows.map((row) => {
+            let meta = row.metadata;
+            if (typeof meta === "string") {
+                try {
+                    meta = JSON.parse(meta);
+                }
+                catch { /* ignore */ }
+            }
+            return {
+                id: row.id, // Ensure id is included if needed, or update Log type
+                stream_id: streamId,
+                content: row.content,
+                timestamp: row.timestamp,
+                metadata: (typeof meta === "object" && meta && Object.keys(meta).length > 0) ? meta : {}
+            };
+        });
+    }
+    close() {
+        client_1.db.close();
+    }
+}
+exports.DbService = DbService;

package/dist/services/ollama.js

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OllamaService = void 0;
+const ollama_1 = require("ollama");
+class OllamaService {
+    client;
+    model;
+    constructor(host = "http://localhost:11434", model = "qwen3-embedding:0.6b") {
+        this.client = new ollama_1.Ollama({ host });
+        this.model = model;
+    }
+    async generateEmbedding(prompt) {
+        try {
+            const response = await this.client.embeddings({
+                model: this.model,
+                prompt: prompt,
+            });
+            return response.embedding;
+        }
+        catch (error) {
+            console.error("Failed to generate embedding:", error);
+            throw error;
+        }
+    }
+    async ensureModel() {
+        try {
+            const list = await this.client.list();
+            const exists = list.models.some((m) => m.name.includes(this.model));
+            if (!exists) {
+                console.log(`Model ${this.model} not found. Pulling...`);
+                await this.client.pull({ model: this.model });
+                console.log("Model pulled.");
+            }
+        }
+        catch (e) {
+            console.warn("Could not check/pull ollama model:", e);
+        }
+    }
+}
+exports.OllamaService = OllamaService;

package/dist/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/ui/main.js

@@ -0,0 +1,71 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.startTui = startTui;
+const inquirer_1 = __importDefault(require("inquirer"));
+const chalk_1 = __importDefault(require("chalk"));
+async function startTui(db) {
+    console.clear();
+    console.log(chalk_1.default.bold.blue("Loghead Dashboard\n"));
+    while (true) {
+        const projects = db.listProjects();
+        if (projects.length === 0) {
+            console.log("No projects found. Use 'npx loghead projects add <name>' to create one.");
+            break;
+        }
+        const projectChoices = projects.map(p => ({ name: p.name, value: p.id }));
+        projectChoices.push({ name: chalk_1.default.red("Exit"), value: "exit" });
+        const { projectId } = await inquirer_1.default.prompt([{
+                type: "list",
+                name: "projectId",
+                message: "Select a Project",
+                choices: projectChoices
+            }]);
+        if (projectId === "exit")
+            break;
+        // List streams for project
+        while (true) {
+            console.clear();
+            const project = projects.find(p => p.id === projectId);
+            console.log(chalk_1.default.bold.blue(`Project: ${project?.name}\n`));
+            const streams = db.listStreams(projectId);
+            if (streams.length === 0) {
+                console.log("No streams found.");
+            }
+            const streamChoices = streams.map(s => ({
+                name: `${s.name} (${s.type})`,
+                value: s.id
+            }));
+            streamChoices.push({ name: chalk_1.default.yellow("Back"), value: "back" });
+            const { streamId } = await inquirer_1.default.prompt([{
+                    type: "list",
+                    name: "streamId",
+                    message: "Select a Stream to view logs",
+                    choices: streamChoices
+                }]);
+            if (streamId === "back")
+                break;
+            // Show logs (simple tail)
+            console.clear();
+            const stream = streams.find(s => s.id === streamId);
+            console.log(chalk_1.default.bold.green(`Logs for ${stream?.name}:\n`));
+            const logs = db.getRecentLogs(streamId, 20);
+            if (logs.length === 0) {
+                console.log("No logs recorded yet.");
+            }
+            else {
+                // Reverse to show oldest to newest like a log file
+                [...logs].reverse().forEach(log => {
+                    console.log(`${chalk_1.default.dim(log.timestamp)}  ${log.content}`);
+                });
+            }
+            console.log("\nPress Enter to return...");
+            await new Promise(resolve => {
+                process.stdin.once('data', () => resolve());
+            });
+        }
+        console.clear();
+    }
+}

package/dist/utils/startup.js

@@ -0,0 +1,55 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ensureInfrastructure = ensureInfrastructure;
+const chalk_1 = __importDefault(require("chalk"));
+const ollama_1 = require("../services/ollama");
+const migrate_1 = require("../db/migrate");
+async function ensureInfrastructure() {
+    console.log(chalk_1.default.bold.blue("\n🚀Performing system preflight checks..."));
+    // 1. Check Local Ollama
+    await checkStep("Checking local Ollama...", async () => {
+        try {
+            // Node.js fetch needs global fetch or polyfill in Node 18+. 
+            // Assuming Node 18+ which has fetch.
+            const response = await fetch("http://localhost:11434/api/tags");
+            if (!response.ok)
+                throw new Error("Ollama is not running");
+        }
+        catch {
+            throw new Error("Ollama is not accessible at http://localhost:11434. Please install and run Ollama.");
+        }
+    });
+    // 2. Check Database & Migrations (SQLite)
+    await checkStep("Initializing database...", async () => {
+        try {
+            (0, migrate_1.migrate)(false);
+        }
+        catch (e) {
+            console.log(chalk_1.default.yellow("\n   ➤ Migration failed..."));
+            throw e;
+        }
+    });
+    // 3. Check Ollama Model
+    await checkStep("Checking embedding model (qwen3-embedding)...", async () => {
+        const ollama = new ollama_1.OllamaService();
+        await ollama.ensureModel();
+    });
+    console.log(`${chalk_1.default.green("✔")} System preflight checks complete`);
+}
+async function checkStep(name, action) {
+    // Print pending state
+    process.stdout.write(`${chalk_1.default.cyan("○")} ${name}`);
+    try {
+        await action();
+        // Clear line and print success
+        process.stdout.write(`\r${chalk_1.default.green("✔")} ${name}      \n`);
+    }
+    catch (e) {
+        process.stdout.write(`\r${chalk_1.default.red("✖")} ${name}\n`);
+        console.error(chalk_1.default.red(`   Error: ${e instanceof Error ? e.message : e}`));
+        process.exit(1);
+    }
+}