@loghead/core 0.1.19 → 0.1.20

package/src/services/ollama.ts

@@ -1,39 +0,0 @@
-import { Ollama } from "ollama";
-
-export class OllamaService {
-    private client: Ollama;
-    private model: string;
-
-    constructor(host = "http://localhost:11434", model = "qwen3-embedding:0.6b") {
-        this.client = new Ollama({ host });
-        this.model = model;
-    }
-
-    async generateEmbedding(prompt: string): Promise<number[]> {
-        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);
-        }
-    }
-}

package/src/tests/db.test.ts

@@ -1,63 +0,0 @@
-import { assertEquals, assertExists } from "@std/assert";
-import { migrate } from "../db/migrate.ts";
-
-// Set up environment to use in-memory DB before importing client
-Deno.env.set("LOGHEAD_DB_PATH", ":memory:");
-
-// Dynamic import to ensure env var is set before module loads
-// We trigger the side-effect of client.ts (creating DB connection)
-await import("../db/client.ts");
-const { DbService } = await import("../services/db.ts");
-
-Deno.test("DbService - Project Management", async (t) => {
-    // @ts-ignore: Dynamic import returns any
-    const service = new DbService();
-
-    // Initialize DB schema
-    migrate(false);
-
-    await t.step("createProject creates a project", () => {
-        const project = service.createProject("Test Project");
-        assertExists(project.id);
-        assertEquals(project.name, "Test Project");
-    });
-
-    await t.step("listProjects returns projects", () => {
-        const projects = service.listProjects();
-        assertExists(projects.find(p => p.name === "Test Project"));
-    });
-
-    await t.step("deleteProject deletes a project", () => {
-        const projects = service.listProjects();
-        const project = projects.find(p => p.name === "Test Project");
-        if (project) {
-            service.deleteProject(project.id);
-
-            const remaining = service.listProjects();
-            assertEquals(remaining.find(p => p.name === "Test Project"), undefined);
-        }
-    });
-});
-
-Deno.test("DbService - Stream Management", async (t) => {
-    // @ts-ignore: Dynamic import returns any
-    const service = new DbService();
-
-    // Create a fresh project for this test suite
-    const project = service.createProject("Stream Project");
-
-    await t.step("createStream creates a stream", () => {
-        const stream = service.createStream(project.id, "terminal", "My Stream", { foo: "bar" });
-        assertExists(stream.id);
-        assertEquals(stream.name, "My Stream");
-        assertEquals(stream.type, "terminal");
-        // @ts-ignore: Property access
-        assertEquals(stream.config, { foo: "bar" });
-    });
-
-    await t.step("listStreams returns streams", () => {
-        const streams = service.listStreams(project.id);
-        assertEquals(streams.length, 1);
-        assertEquals(streams[0].name, "My Stream");
-    });
-});

package/src/types.ts

@@ -1,31 +0,0 @@
-
-export interface Project {
-    id: string;
-    name: string;
-    created_at?: string;
-    streams?: Stream[];
-}
-
-export interface Stream {
-    id: string;
-    project_id: string;
-    type: string;
-    name: string;
-    config: Record<string, unknown> | string;
-    created_at?: string;
-}
-
-export interface Log {
-    id: string;
-    stream_id: string;
-    content: string;
-    timestamp: string;
-    metadata: Record<string, unknown> | string;
-}
-
-export interface SearchResult {
-    content: string;
-    timestamp: string;
-    similarity?: number;
-    metadata?: Record<string, unknown>;
-}

package/src/ui/main.ts

@@ -1,197 +0,0 @@
-import { DbService } from "../services/db";
-import { AuthService } from "../services/auth";
-import inquirer from "inquirer";
-import chalk from "chalk";
-
-let title = `
- █████                         █████                             █████
-▒▒███                         ▒▒███                             ▒▒███ 
- ▒███         ██████   ███████ ▒███████    ██████   ██████    ███████ 
- ▒███        ███▒▒███ ███▒▒███ ▒███▒▒███  ███▒▒███ ▒▒▒▒▒███  ███▒▒███ 
- ▒███       ▒███ ▒███▒███ ▒███ ▒███ ▒███ ▒███████   ███████ ▒███ ▒███ 
- ▒███      █▒███ ▒███▒███ ▒███ ▒███ ▒███ ▒███▒▒▒   ███▒▒███ ▒███ ▒███ 
- ███████████▒▒██████ ▒▒███████ ████ █████▒▒██████ ▒▒████████▒▒████████
-▒▒▒▒▒▒▒▒▒▒▒  ▒▒▒▒▒▒   ▒▒▒▒▒███▒▒▒▒ ▒▒▒▒▒  ▒▒▒▒▒▒   ▒▒▒▒▒▒▒▒  ▒▒▒▒▒▒▒▒ 
-                      ███ ▒███                                        
-                     ▒▒██████                                         
-                      ▒▒▒▒▒▒                                          `;
-
-export async function startTui(db: DbService, token: string) {
-    const port = process.env.PORT || 4567;
-    const showHeader = () => {
-        console.clear();
-        console.log(chalk.bold(title));
-        console.log(chalk.bold(`\nServer URL :`) + " " + chalk.dim(`http://localhost:${port}`));
-        console.log(chalk.bold(`MCP Token  :`) + " " + chalk.dim(token) + "\n");
-    };
-
-    while (true) {
-        showHeader();
-        const projects = db.listProjects();
-
-        const projectChoices: (inquirer.Separator | { name: string; value: string })[] = projects.map(p => ({ name: p.name, value: p.id }));
-        projectChoices.push(new inquirer.Separator());
-        projectChoices.push({ name: chalk.green("+ Create Project"), value: "create_project" });
-        projectChoices.push({ name: chalk.red("Exit"), value: "exit" });
-
-        const { projectId } = await inquirer.prompt([{
-            type: "list",
-            name: "projectId",
-            message: "Select a project",
-            choices: projectChoices,
-            pageSize: 10,
-            prefix: "💡"
-        }]);
-
-        if (projectId === "exit") break;
-
-        if (projectId === "create_project") {
-            const { name } = await inquirer.prompt([{
-                type: "input",
-                name: "name",
-                message: "Project Name:",
-                prefix: "💡"
-            }]);
-            if (name) {
-                db.createProject(name);
-            }
-            continue;
-        }
-
-        // List streams for project
-        while (true) {
-            showHeader();
-            const project = projects.find(p => p.id === projectId);
-            console.log(chalk.bold.blue(`Project: ${project?.name}\n`));
-
-            const streams = db.listStreams(projectId);
-
-            const streamChoices: (inquirer.Separator | { name: string; value: string })[] = streams.map(s => ({
-                name: `${s.name} (${s.type})`,
-                value: s.id
-            }));
-            streamChoices.push(new inquirer.Separator());
-            streamChoices.push({ name: chalk.green("+ Create Stream"), value: "create_stream" });
-            streamChoices.push({ name: chalk.yellow("Back"), value: "back" });
-
-            const { streamId } = await inquirer.prompt([{
-                type: "list",
-                name: "streamId",
-                message: "Select a stream",
-                choices: streamChoices,
-                pageSize: 10,
-                prefix: "💡"
-            }]);
-
-            if (streamId === "back") break;
-
-            if (streamId === "create_stream") {
-                showHeader();
-                console.log(chalk.bold.blue(`Project: ${project?.name}`));
-                console.log(chalk.bold.blue(`  └─ Create Stream\n`));
-
-                const { name, type } = await inquirer.prompt([
-                    {
-                        type: "input",
-                        name: "name",
-                        message: "Stream name:",
-                        prefix: "💡"
-                    },
-                    {
-                        type: "list",
-                        name: "type",
-                        message: "Stream type:",
-                        choices: ["browser", "terminal", "docker", "opentelemetry"],
-                        prefix: "💡"
-                    }
-                ]);
-
-                if (name && type) {
-                    // For now, empty config
-                    const s = await db.createStream(projectId, type, name, {});
-                    console.log(chalk.green(`\nStream created!`));
-                    console.log(chalk.bold.yellow(`Token: ${s.token}\n`));
-
-                    await inquirer.prompt([{
-                        type: "input",
-                        name: "continue",
-                        message: "Press enter to continue...",
-                        prefix: "💡"
-                    }]);
-                }
-                continue;
-            }
-
-            // Stream Actions
-            while (true) {
-                showHeader();
-                const stream = streams.find(s => s.id === streamId);
-                console.log(chalk.bold.blue(`Project: ${project?.name}`));
-                console.log(chalk.bold.blue(`  └─ Stream: ${stream?.name} (${stream?.type})\n`));
-
-                const { action } = await inquirer.prompt([{
-                    type: "list",
-                    name: "action",
-                    message: "Action",
-                    choices: [
-                        { name: "View logs", value: "view_logs" },
-                        { name: "Get token", value: "get_token" },
-                        { name: "Delete stream", value: "delete_stream" },
-                        { name: chalk.yellow("Back"), value: "back" }
-                    ],
-                    prefix: "💡"
-                }]);
-
-                if (action === "back") break;
-
-                if (action === "get_token") {
-                    const auth = new AuthService();
-                    const token = await auth.createStreamToken(streamId);
-                    console.log(chalk.green(`\nToken for ${stream?.name}:`));
-                    console.log(chalk.bold.yellow(`${token}\n`));
-
-                    await inquirer.prompt([{
-                        type: "input",
-                        name: "continue",
-                        message: "Press enter to continue...",
-                        prefix: "💡"
-                    }]);
-                }
-
-                if (action === "delete_stream") {
-                    const { confirm } = await inquirer.prompt([{
-                        type: "confirm",
-                        name: "confirm",
-                        message: `Are you sure you want to delete stream ${stream?.name}?`
-                    }]);
-                    if (confirm) {
-                        db.deleteStream(streamId);
-                        break; // Go back to stream list
-                    }
-                }
-
-                if (action === "view_logs") {
-                    console.clear();
-                    console.log(chalk.bold.green(`Logs for ${stream?.name}:\n`));
-
-                    const logs = db.getRecentLogs(streamId, 20);
-                    if (logs.length === 0) {
-                        console.log("No logs recorded yet.");
-                    } else {
-                        [...logs].reverse().forEach(log => {
-                            console.log(`${chalk.dim(log.timestamp)}  ${log.content}`);
-                        });
-                    }
-
-                    console.log("\n");
-                    await inquirer.prompt([{
-                        type: "input",
-                        name: "return",
-                        message: "Press enter to return...",
-                        prefix: "💡"
-                    }]);
-                }
-            }
-        }
-    }
-}

package/src/utils/startup.ts

@@ -1,52 +0,0 @@
-import chalk from "chalk";
-import { OllamaService } from "../services/ollama";
-import { migrate } from "../db/migrate";
-
-export async function ensureInfrastructure() {
-    console.log(chalk.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 {
-            migrate(false);
-        } catch (e) {
-            console.log(chalk.yellow("\n   ➤ Migration failed..."));
-            throw e;
-        }
-    });
-
-    // 3. Check Ollama Model
-    await checkStep("Checking embedding model (qwen3-embedding)...", async () => {
-        const ollama = new OllamaService();
-        await ollama.ensureModel();
-    });
-
-    console.log(`${chalk.green("✔")} System preflight checks complete`);
-}
-
-async function checkStep(name: string, action: () => Promise<void>) {
-    // Print pending state
-    process.stdout.write(`${chalk.cyan("○")} ${name}`);
-
-    try {
-        await action();
-        // Clear line and print success
-        process.stdout.write(`\r${chalk.green("✔")} ${name}      \n`);
-    } catch (e) {
-        process.stdout.write(`\r${chalk.red("✖")} ${name}\n`);
-        console.error(chalk.red(`   Error: ${e instanceof Error ? e.message : e}`));
-        process.exit(1);
-    }
-}

package/tests/embedding_perf.ts

@@ -1,62 +0,0 @@
-import { OllamaService } from "../src/services/ollama";
-import { performance } from "perf_hooks";
-
-async function runTest() {
-    console.log("Starting Embedding Performance Test...");
-
-    const service = new OllamaService();
-
-    // Ensure model exists first so pull time doesn't affect metrics
-    console.log("Checking model availability...");
-    await service.ensureModel();
-
-    const testString = "This is a test log message that simulates a typical log entry in a production system. It contains some details about an error or an event that occurred.";
-    const iterations = 10;
-    const latencies: number[] = [];
-
-    console.log(`Running ${iterations} iterations...`);
-
-    for (let i = 0; i < iterations; i++) {
-        const start = performance.now();
-        try {
-            await service.generateEmbedding(testString);
-            const end = performance.now();
-            const duration = end - start;
-            latencies.push(duration);
-            console.log(`Iteration ${i + 1}: ${duration.toFixed(2)}ms`);
-        } catch (e) {
-            console.error(`Iteration ${i + 1} failed:`, e);
-        }
-    }
-
-    if (latencies.length > 0) {
-        const warmUp = latencies[0];
-        const results = latencies.slice(1); // Remove warm-up
-
-        console.log("\n--- Results ---");
-        console.log(`Total Iterations: ${latencies.length}`);
-        console.log(`Warm-up Time: ${warmUp.toFixed(2)}ms`);
-
-        if (results.length > 0) {
-            const min = Math.min(...results);
-            const max = Math.max(...results);
-
-            // Calculate Median
-            results.sort((a, b) => a - b);
-            const mid = Math.floor(results.length / 2);
-            const median = results.length % 2 !== 0
-                ? results[mid]
-                : (results[mid - 1] + results[mid]) / 2;
-
-            console.log(`Min Latency (excl. warmup): ${min.toFixed(2)}ms`);
-            console.log(`Avg Latency (excl. warmup): ${median.toFixed(2)}ms`);
-            console.log(`Max Latency (excl. warmup): ${max.toFixed(2)}ms`);
-        } else {
-            console.log("Not enough iterations to calculate stats (need > 1).");
-        }
-    } else {
-        console.log("\nNo successful iterations.");
-    }
-}
-
-runTest().catch(console.error);

package/tsconfig.json

@@ -1,15 +0,0 @@
-{
-  "compilerOptions": {
-    "target": "ES2022",
-    "module": "CommonJS",
-    "moduleResolution": "node",
-    "outDir": "./dist",
-    "rootDir": "./src",
-    "strict": true,
-    "esModuleInterop": true,
-    "skipLibCheck": true,
-    "forceConsistentCasingInFileNames": true
-  },
-  "include": ["src/**/*"],
-  "exclude": ["node_modules", "**/*.test.ts"]
-}