@udara-kavindu/hik-cli 0.1.0

package/README.md

@@ -0,0 +1,17 @@
+# hik-cli
+
+To install dependencies and build the CLI:
+
+```bash
+bun install
+bun run build
+```
+
+To make the `hik` command available locally:
+
+```bash
+bun link
+hik --help
+```
+
+This project was created using `bun init` in bun v1.4.2. [Bun](https://bun.com) is a fast all-in-one JavaScript runtime.

package/dist/auth.js

@@ -0,0 +1,30 @@
+import * as fs from 'fs';
+import * as path from 'path';
+import * as os from 'os';
+const CONFIG_DIR = path.join(os.homedir(), '.hik');
+const CONFIG_FILE = path.join(CONFIG_DIR, 'config.json');
+export function getConfig() {
+    if (!fs.existsSync(CONFIG_FILE))
+        return {};
+    try {
+        return JSON.parse(fs.readFileSync(CONFIG_FILE, 'utf-8'));
+    }
+    catch {
+        return {};
+    }
+}
+export function saveConfig(config) {
+    if (!fs.existsSync(CONFIG_DIR)) {
+        fs.mkdirSync(CONFIG_DIR, { recursive: true });
+    }
+    const current = getConfig();
+    fs.writeFileSync(CONFIG_FILE, JSON.stringify({ ...current, ...config }, null, 2));
+}
+export function requireApiKey() {
+    const config = getConfig();
+    if (!config.apiKey) {
+        console.error('[Error] No API key found. Please run: hik login <your-api-key>');
+        process.exit(1);
+    }
+    return config.apiKey;
+}

package/dist/chat.js

@@ -0,0 +1,138 @@
+import fetch from "node-fetch";
+import { requireApiKey, getConfig } from "./auth.js";
+export async function streamChat(message, model) {
+    const apiKey = requireApiKey();
+    const config = getConfig();
+    const apiUrl = config.apiUrl || "http://localhost:3000";
+    // For MVP, we'll use a random UUID for session ID.
+    // In a real app, you might want to persist sessions in a local file.
+    const sessionId = crypto.randomUUID();
+    const response = await fetch(`${apiUrl}/api/v1/chat`, {
+        method: "POST",
+        headers: {
+            "Content-Type": "application/json",
+            "x-api-key": apiKey,
+        },
+        body: JSON.stringify({
+            sessionId,
+            messages: [{ role: "user", content: message }],
+            model: model || "qwen2.5-coder-7b-instruct",
+        }),
+    });
+    if (!response.ok) {
+        const err = await response.text();
+        throw new Error(`API Error: ${err}`);
+    }
+    const decoder = new TextDecoder();
+    if (!response.body)
+        throw new Error("No response body");
+    let buffer = "";
+    for await (const chunk of response.body) {
+        buffer +=
+            typeof chunk === "string"
+                ? chunk
+                : decoder.decode(chunk, { stream: true });
+        const lines = buffer.split("\n");
+        buffer = lines.pop() || "";
+        for (const line of lines) {
+            if (line.startsWith("data: ")) {
+                try {
+                    const data = JSON.parse(line.slice(6));
+                    if (data.type === "text") {
+                        process.stdout.write(data.content);
+                    }
+                }
+                catch (e) {
+                    // Ignore parse errors
+                }
+            }
+        }
+    }
+    buffer += decoder.decode();
+    console.log("\n"); // New line after stream ends
+}
+async function fetchCompletion(messages, model) {
+    const apiKey = requireApiKey();
+    const config = getConfig();
+    const apiUrl = config.apiUrl || "http://localhost:3000";
+    const sessionId = crypto.randomUUID();
+    const response = await fetch(`${apiUrl}/api/v1/chat`, {
+        method: "POST",
+        headers: {
+            "Content-Type": "application/json",
+            "x-api-key": apiKey,
+        },
+        body: JSON.stringify({
+            sessionId,
+            messages,
+            model,
+        }),
+    });
+    if (!response.ok)
+        throw new Error(await response.text());
+    const decoder = new TextDecoder();
+    let fullText = "";
+    let buffer = "";
+    if (response.body) {
+        for await (const chunk of response.body) {
+            buffer +=
+                typeof chunk === "string"
+                    ? chunk
+                    : decoder.decode(chunk, { stream: true });
+            const lines = buffer.split("\n");
+            buffer = lines.pop() || "";
+            for (const line of lines) {
+                if (line.startsWith("data: ")) {
+                    try {
+                        const data = JSON.parse(line.slice(6));
+                        if (data.type === "text")
+                            fullText += data.content;
+                    }
+                    catch { }
+                }
+            }
+        }
+    }
+    return fullText;
+}
+export async function generateCommitMessage(diff) {
+    const prompt = `Generate a conventional commit message for this diff. Only return the message, nothing else.\n\n${diff}`;
+    return fetchCompletion([{ role: "user", content: prompt }], "qwen2.5-coder-7b-instruct");
+}
+export async function explainCode(content, fileName) {
+    const prompt = `You are an expert developer. Please explain the following code from the file "${fileName}". 
+  Focus on:
+  1. What the code does at a high level.
+  2. Key functions or logic flows.
+  3. Any potential improvements or "gotchas".
+  
+  Keep the explanation concise and easy to understand.
+  
+  Code:
+  \`\`\`
+  ${content}
+  \`\`\``;
+    return fetchCompletion([{ role: "user", content: prompt }], "qwen2.5-coder-7b-instruct");
+}
+export async function fixIssue(input, contextType, fileName) {
+    let prompt = "";
+    if (contextType === "error") {
+        prompt = `You are an expert debugger. I am encountering the following error or issue. 
+    Please analyze it and provide:
+    1. A brief explanation of what is likely causing the error.
+    2. The corrected code or solution.
+    
+    Issue/Error:
+    ${input}`;
+    }
+    else {
+        prompt = `You are an expert code reviewer. I have the following code in "${fileName || "a file"}" that needs fixing or improvement.
+    Please identify any bugs, performance issues, or bad practices and provide the corrected version.
+    
+    Code:
+    \`\`\`
+    ${input}
+    \`\`\``;
+    }
+    return fetchCompletion([{ role: "user", content: prompt }], "qwen2.5-coder-7b-instruct");
+}

package/dist/fs.js

@@ -0,0 +1,17 @@
+import * as fs from "fs";
+import * as path from "path";
+export function readFileContent(filePath) {
+    const absolutePath = path.resolve(filePath);
+    if (!fs.existsSync(absolutePath)) {
+        throw new Error(`File not found: ${filePath}`);
+    }
+    const stats = fs.statSync(absolutePath);
+    if (stats.isDirectory()) {
+        throw new Error(`Path is a directory, not a file: ${filePath}`);
+    }
+    // Limit file size to prevent sending massive files to the LLM (e.g., 100KB limit)
+    if (stats.size > 100 * 1024) {
+        throw new Error("File is too large to explain (max 100KB).");
+    }
+    return fs.readFileSync(absolutePath, "utf-8");
+}

package/dist/git.js

@@ -0,0 +1,18 @@
+import { execSync } from "child_process";
+export function getStagedDiff() {
+    try {
+        // Get the diff of all staged files
+        return execSync("git diff --cached").toString();
+    }
+    catch (error) {
+        throw new Error("No staged changes found or not in a git repository.");
+    }
+}
+export function getCurrentBranch() {
+    try {
+        return execSync("git branch --show-current").toString().trim();
+    }
+    catch {
+        return "unknown";
+    }
+}

package/dist/index.js

@@ -0,0 +1,165 @@
+#!/usr/bin/env node
+import { Command } from 'commander';
+import { execSync } from "node:child_process";
+import chalk from "chalk";
+import { saveConfig } from "./auth.js";
+import { explainCode, fixIssue, generateCommitMessage, streamChat, } from "./chat.js";
+import pkg from "../package.json" with { type: "json" };
+import { getStagedDiff } from "./git.js";
+import { readFileContent } from "./fs.js";
+import * as path from "path";
+import { startInteractiveChat } from "./interactive.js";
+const program = new Command();
+program
+    .name("hik")
+    .description("Your unified AI workspace CLI")
+    .version(pkg.version);
+program
+    .command("login")
+    .argument("<api-key>", "Your Hik API key (hik_...)")
+    .description("Save your API key locally")
+    .action((apiKey) => {
+    if (!apiKey.startsWith("hik_")) {
+        console.error("[ERROR] Invalid API key format. It should start with hik_");
+        process.exit(1);
+    }
+    saveConfig({ apiKey });
+    console.log("[SUCCESS] API key saved successfully!");
+});
+program
+    .command("chat")
+    .argument("<message>", "The message to send to Hik")
+    .option("-m, --model <model>", "Specify the LLM model", "qwen2.5-coder-7b-instruct")
+    .description("Start a chat with Hik")
+    .action(async (message, options) => {
+    try {
+        console.log("[INFO] Hik: ");
+        await streamChat(message, options.model);
+    }
+    catch (error) {
+        console.error("[ERROR]:", error.message);
+        process.exit(1);
+    }
+});
+program
+    .command("config")
+    .option("--url <url>", "Set the backend API URL")
+    .description("Manage CLI configuration")
+    .action((options) => {
+    if (options.url) {
+        saveConfig({ apiUrl: options.url });
+        console.log(`[SUCCESS] Backend URL set to: ${options.url}`);
+    }
+    else {
+        console.error("[ERROR] No URL provided.");
+        console.log("Usage: hik config --url <http://localhost:3000>");
+    }
+});
+program
+    .command("commit")
+    .description("Generate a commit message from staged changes")
+    .option("-y, --yes", "Automatically commit with the generated message")
+    .action(async (options) => {
+    try {
+        console.log(chalk.blue("[INFO] Analyzing staged changes..."));
+        const diff = getStagedDiff();
+        if (!diff.trim()) {
+            console.log(chalk.yellow("[WARNING] No staged changes found."));
+            return;
+        }
+        console.log(chalk.blue("✨ Generating commit message..."));
+        const message = await generateCommitMessage(diff);
+        console.log(chalk.green("\nProposed Commit Message:"));
+        console.log(chalk.bold(`"${message}"\n`));
+        if (options.yes) {
+            execSync(`git commit -m "${message}"`, { stdio: "inherit" });
+            console.log(chalk.green("[SUCCESS] Committed successfully!"));
+        }
+        else {
+            console.log(chalk.gray("[INFO] To commit automatically next time, use: hik commit -y"));
+            console.log(chalk.gray(`[INFO] Or run: git commit -m "${message}"`));
+        }
+    }
+    catch (error) {
+        console.error(chalk.red("[ERROR] Error:"), error.message);
+        process.exit(1);
+    }
+});
+program
+    .command("explain")
+    .argument("<file>", "Path to the file you want to explain")
+    .description("Explain the contents of a code file")
+    .action(async (filePath) => {
+    try {
+        console.log(chalk.blue(`[INFO] Reading ${filePath}...`));
+        const content = readFileContent(filePath);
+        console.log(chalk.blue("✨ Analyzing code..."));
+        const explanation = await explainCode(content, path.basename(filePath));
+        console.log(chalk.green("\n💡 Explanation:"));
+        console.log(explanation);
+        console.log("\n");
+    }
+    catch (error) {
+        console.error(chalk.red("[ERROR] Error:"), error.message);
+        process.exit(1);
+    }
+});
+program
+    .command("fix")
+    .argument("[file]", "Path to the file containing the code or error log")
+    .description("Get a fix for an error message or buggy code. Can also read from stdin.")
+    .action(async (filePath) => {
+    try {
+        let input = "";
+        let contextType = "error";
+        let sourceName = "stdin";
+        // Check if data is being piped (e.g., cat error.log | hik fix)
+        if (process.stdin.isTTY) {
+            // If no file argument and not piped, ask for manual paste (MVP: just throw error for now)
+            if (!filePath) {
+                console.error(chalk.red("[ERROR] Please provide a file path or pipe input. Example:"));
+                console.error(chalk.gray("   hik fix error.log"));
+                console.error(chalk.gray("   cat error.log | hik fix"));
+                console.error(chalk.gray("   hik fix src/broken-code.ts"));
+                process.exit(1);
+            }
+            // It's a file
+            input = readFileContent(filePath);
+            sourceName = filePath;
+            // Simple heuristic: if it looks like code, treat as code
+            if (filePath.match(/\.(ts|js|py|go|rs|java|cpp|c)$/)) {
+                contextType = "code";
+            }
+        }
+        else {
+            // Reading from stdin
+            const chunks = [];
+            for await (const chunk of process.stdin) {
+                chunks.push(chunk);
+            }
+            input = Buffer.concat(chunks).toString();
+            contextType = "error"; // Default piped input to error/log analysis
+        }
+        if (!input.trim()) {
+            console.error(chalk.red("[ERROR] No input provided."));
+            process.exit(1);
+        }
+        console.log(chalk.blue(`🔍 Analyzing ${sourceName}...`));
+        const solution = await fixIssue(input, contextType, sourceName);
+        console.log(chalk.green("\n🛠️ Suggested Fix:"));
+        console.log(solution);
+        console.log("\n");
+    }
+    catch (error) {
+        console.error(chalk.red("[ERROR] Error:"), error.message);
+        process.exit(1);
+    }
+});
+program
+    .command("interactive")
+    .alias("i")
+    .description("Start an interactive chat session")
+    .action(() => {
+    startInteractiveChat();
+});
+program.parse();

package/dist/interactive.js

@@ -0,0 +1,92 @@
+import * as readline from 'readline';
+import { requireApiKey, getConfig } from './auth.js';
+import chalk from 'chalk';
+export async function startInteractiveChat() {
+    const apiKey = requireApiKey();
+    const config = getConfig();
+    const apiUrl = config.apiUrl || 'http://localhost:3000';
+    const rl = readline.createInterface({
+        input: process.stdin,
+        output: process.stdout,
+        prompt: chalk.green('hik> '),
+    });
+    const history = [];
+    const sessionId = crypto.randomUUID();
+    console.log(chalk.blue('\n🤖 Hik Interactive Mode'));
+    console.log(chalk.gray('Type your message and press Enter. Type /exit to quit.\n'));
+    rl.prompt();
+    rl.on('line', async (line) => {
+        const input = line.trim();
+        if (input.toLowerCase() === '/exit' || input.toLowerCase() === '/quit') {
+            console.log(chalk.yellow('Goodbye! 👋'));
+            rl.close();
+            return;
+        }
+        if (!input) {
+            rl.prompt();
+            return;
+        }
+        // Add user message to history
+        history.push({ role: 'user', content: input });
+        try {
+            // Show a small indicator that we are thinking
+            process.stdout.write(chalk.dim('Hik is typing...\r'));
+            const response = await fetch(`${apiUrl}/api/v1/chat`, {
+                method: 'POST',
+                headers: {
+                    'Content-Type': 'application/json',
+                    'x-api-key': apiKey,
+                },
+                body: JSON.stringify({
+                    sessionId,
+                    messages: history,
+                    model: 'qwen2.5-coder-7b-instruct',
+                }),
+            });
+            if (!response.ok)
+                throw new Error(await response.text());
+            // Clear the "typing" indicator
+            process.stdout.write(' '.repeat(20) + '\r');
+            // Stream the response
+            const reader = response.body?.getReader();
+            const decoder = new TextDecoder();
+            let assistantResponse = '';
+            if (reader) {
+                let buffer = '';
+                while (true) {
+                    const { done, value } = await reader.read();
+                    if (done)
+                        break;
+                    buffer += decoder.decode(value, { stream: true });
+                    const lines = buffer.split('\n');
+                    buffer = lines.pop() || '';
+                    for (const line of lines) {
+                        if (line.startsWith('data: ')) {
+                            try {
+                                const data = JSON.parse(line.slice(6));
+                                if (data.type === 'text') {
+                                    process.stdout.write(data.content);
+                                    assistantResponse += data.content;
+                                }
+                            }
+                            catch { }
+                        }
+                    }
+                }
+            }
+            console.log('\n'); // New line after response
+            // Add assistant response to history
+            history.push({ role: 'assistant', content: assistantResponse });
+        }
+        catch (error) {
+            console.error(chalk.red('\n[ERROR] Error:'), error.message);
+        }
+        finally {
+            rl.prompt();
+        }
+    });
+    rl.on('close', () => {
+        console.log('\n');
+        process.exit(0);
+    });
+}

package/package.json

@@ -0,0 +1,42 @@
+{
+  "name": "@udara-kavindu/hik-cli",
+  "version": "0.1.0",
+  "description": "Your unified AI workspace CLI",
+  "module": "index.ts",
+  "type": "module",
+  "main": "dist/index.js",
+  "scripts": {
+    "dev": "bun run src/index.ts",
+    "build": "tsc",
+    "prepublishOnly": "bun run build"
+  },
+  "bin": {
+    "hik": "./dist/index.js"
+  },
+  "keywords": [
+    "ai",
+    "cli",
+    "llm",
+    "obsidian",
+    "hik"
+  ],
+  "author": "Kavindu Udara <karunasinghesampath@gmail.com>",
+  "license": "MIT",
+  "files": [
+    "dist"
+  ],
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "devDependencies": {
+    "@types/bun": "latest"
+  },
+  "peerDependencies": {
+    "typescript": "^7"
+  },
+  "dependencies": {
+    "chalk": "^6.0.0",
+    "commander": "^15.0.0",
+    "node-fetch": "^3.3.2"
+  }
+}