@loghead/core 0.1.1 → 0.1.3

package/src/types.ts

@@ -0,0 +1,31 @@
+
+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

@@ -0,0 +1,78 @@
+import { DbService } from "../services/db";
+import inquirer from "inquirer";
+import chalk from "chalk";
+
+export async function startTui(db: DbService) {
+    console.clear();
+    console.log(chalk.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.red("Exit"), value: "exit" });
+
+        const { projectId } = await inquirer.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.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.yellow("Back"), value: "back" });
+
+            const { streamId } = await inquirer.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.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.dim(log.timestamp)}  ${log.content}`);
+                });
+            }
+
+            console.log("\nPress Enter to return...");
+            await new Promise<void>(resolve => {
+                process.stdin.once('data', () => resolve());
+            });
+        }
+        console.clear();
+    }
+}

package/src/utils/startup.ts

@@ -0,0 +1,52 @@
+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/tsconfig.json

@@ -0,0 +1,15 @@
+{
+  "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"]
+}