devfix-cli 1.0.0

package/bin/index.js

@@ -0,0 +1,41 @@
+#!/usr/bin/env node
+import { Command } from "commander";
+
+import { loginCommand } from "../src/commands/login.js";
+import { logoutCommand } from "../src/commands/logout.js";
+import { whoamiCommand } from "../src/commands/whoami.js";
+import { analyzeCommand } from "../src/commands/analyze.js";
+
+
+const program = new Command();
+
+program
+  .name("devfix")
+  .description("DevFix CLI - AI tool to solve errors and bugs")
+  .version("1.0.0");
+
+program.command("login").description("Login and save session for 7 days").action(loginCommand);
+
+program.command("logout").description("Logout and clear local session").action(logoutCommand);
+
+program.command("whoami").description("Show current login session").action(whoamiCommand);
+
+program
+  .command("analyze")
+  .description("Analyze an error/log with AI")
+  .option("-f, --file <path>", "Read logs from a file")
+  .option("-s, --stack <stack>", "Force stack (kubernetes/docker/nodejs/react/python/git)")
+  .option("-m, --model <model>", "OpenRouter model override")
+  .option("-c, --context", "Auto collect project/terminal context")
+  .argument("[text]", "Error/log text")
+  .action((text, options) => {
+    analyzeCommand({
+      text: text || "",
+      file: options.file,
+      stack: options.stack,
+      model: options.model,
+      useContext: options.context, 
+    });
+  });
+
+program.parse(process.argv);

package/package.json

@@ -0,0 +1,22 @@
+{
+  "name": "devfix-cli",
+  "type": "module",
+  "bin": {
+    "devfix": "bin/index.js"
+  },
+  "dependencies": {
+    "axios": "^1.13.5",
+    "boxen": "^8.0.1",
+    "chalk": "^5.6.2",
+    "cli-spinners": "^3.4.0",
+    "commander": "^14.0.3",
+    "dotenv": "^17.2.4",
+    "inquirer": "^13.2.2",
+    "keytar": "^7.9.0",
+    "log-update": "^7.1.0",
+    "marked": "^15.0.12",
+    "marked-terminal": "^7.3.0",
+    "ora": "^9.3.0"
+  },
+  "version": "1.0.0"
+}

package/src/commands/analyze.js

@@ -0,0 +1,101 @@
+
+import fs from "fs";
+import chalk from "chalk";
+import boxen from "boxen";
+import logUpdate from "log-update";
+
+import { marked } from "marked";
+import TerminalRenderer from "marked-terminal";
+
+import { readConfig } from "../utils/config.js";
+import { isSessionValid } from "../utils/session.js";
+import { decrypt } from "../utils/cryptoStore.js";
+
+import { collectContext } from "../utils/context.js";
+import { detectStack } from "../utils/detectStack.js";
+import { buildPrompt } from "../utils/prompt.js";
+import { askAI } from "../utils/ai.js";
+
+import { startDevFixLogo } from "../utils/animatedLogo.js";
+
+// Markdown → terminal renderer
+marked.setOptions({
+  renderer: new TerminalRenderer(),
+});
+
+export async function analyzeCommand({ text, file, stack, model, useContext }) {
+  const config = readConfig();
+
+  if (!isSessionValid(config)) {
+    console.log(chalk.red("\n❌ Not logged in or session expired.\nRun: devfix login\n"));
+    process.exit(1);
+  }
+
+  const apiKey = decrypt(config.apiKeyEncrypted);
+
+  if (!apiKey) {
+    console.log(chalk.red("\n❌ API key missing. Run: devfix login\n"));
+    process.exit(1);
+  }
+
+  let input = text;
+
+  if (file) {
+    input = fs.readFileSync(file, "utf-8");
+  }
+
+  if (!input || input.trim().length < 2) {
+    console.log(chalk.red("\n❌ Please provide error text or use --file\n"));
+    process.exit(1);
+  }
+
+  const detected = stack || detectStack(input);
+  const usedModel = model || "openai/gpt-4o-mini";
+  const context = useContext ? collectContext() : {};
+
+  // Start animation
+  const anim = startDevFixLogo();
+
+  const interval = setInterval(() => {
+    logUpdate(
+      `
+${chalk.cyan(`${anim.frame()} DevFix`)} ${chalk.gray("• AI Debugging Assistant")}
+
+${chalk.white("Stack:")}   ${chalk.yellow(detected)}
+${chalk.white("Model:")}   ${chalk.magenta(usedModel)}
+${chalk.white("Context:")} ${useContext ? chalk.green("ON") : chalk.red("OFF")}
+
+${chalk.cyan("Analyzing error with AI...")}
+`
+    );
+  }, 80);
+
+  try {
+    const prompt = buildPrompt({ stack: detected, input, context });
+    const answer = await askAI({ apiKey, model: usedModel, prompt });
+
+    // Stop animation
+    clearInterval(interval);
+    anim.stop();
+    logUpdate.clear();
+
+    // Print final output
+    console.log(
+      boxen(chalk.bold.green("✅ DevFix Suggested Fix"), {
+        padding: 1,
+        borderStyle: "round",
+      })
+    );
+
+    console.log(marked(answer));
+    console.log();
+  } catch (err) {
+    clearInterval(interval);
+    anim.stop();
+    logUpdate.clear();
+
+    console.log(chalk.red("\n❌ AI request failed\n"));
+    console.log(err?.response?.data || err.message);
+    console.log();
+  }
+}

package/src/commands/login.js

@@ -0,0 +1,28 @@
+import inquirer from "inquirer";
+import chalk from "chalk";
+
+import { writeConfig } from "../utils/config.js";
+import { createSession } from "../utils/session.js";
+import { encrypt } from "../utils/cryptoStore.js";
+
+export async function loginCommand() {
+  const answers = await inquirer.prompt([
+    { name: "username", message: "Enter username:", type: "input" },
+    { name: "email", message: "Enter email:", type: "input" },
+    { name: "apiKey", message: "Enter OpenRouter API key:", type: "password", mask: "*" },
+  ]);
+
+  const session = createSession({
+    username: answers.username.trim(),
+    email: answers.email.trim(),
+  });
+
+  const apiKeyEncrypted = encrypt(answers.apiKey.trim());
+
+  writeConfig({
+    ...session,
+    apiKeyEncrypted,
+  });
+
+  console.log(chalk.green("\n✅ Login saved for 7 days.\n"));
+}

package/src/commands/logout.js

@@ -0,0 +1,7 @@
+import chalk from "chalk";
+import { deleteConfig } from "../utils/config.js";
+
+export async function logoutCommand() {
+  deleteConfig();
+  console.log(chalk.yellow("\n👋 Logged out. Session cleared.\n"));
+}

package/src/commands/whoami.js

@@ -0,0 +1,23 @@
+import chalk from "chalk";
+import { readConfig, getConfigPath } from "../utils/config.js";
+import { isSessionValid } from "../utils/session.js";
+
+export async function whoamiCommand() {
+  const config = readConfig();
+
+  if (!config) {
+    console.log(chalk.red("\n❌ Not logged in.\n"));
+    return;
+  }
+
+  console.log(chalk.cyan("\n👤 DevFix User\n"));
+  console.log("Username:", config.username);
+  console.log("Email:", config.email);
+  console.log("Config:", getConfigPath());
+
+  if (isSessionValid(config)) {
+    console.log(chalk.green("\n✅ Session valid until:"), config.expiresAt, "\n");
+  } else {
+    console.log(chalk.red("\n⏳ Session expired. Please run devfix login\n"));
+  }
+}

package/src/utils/ai.js

@@ -0,0 +1,23 @@
+import axios from "axios";
+
+export async function askAI({ apiKey, model, prompt }) {
+
+const res = await axios.post(
+  "https://openrouter.ai/api/v1/chat/completions",
+  {
+    model: "openai/gpt-4o-mini",
+    messages: [{ role: "user", content: prompt}],
+    max_tokens: 800
+  },
+  {
+    headers: {
+      Authorization: `Bearer ${apiKey}`,
+      "Content-Type": "application/json",
+    },
+    timeout: 30000
+  }
+);
+
+
+  return res.data.choices?.[0]?.message?.content || "No response from AI.";
+}

package/src/utils/animatedLogo.js

@@ -0,0 +1,16 @@
+import spinners from "cli-spinners";
+
+const frames = spinners.dots.frames;
+
+export function startDevFixLogo() {
+  let i = 0;
+
+  const timer = setInterval(() => {
+    i = (i + 1) % frames.length;
+  }, 80);
+
+  return {
+    frame: () => frames[i],
+    stop: () => clearInterval(timer),
+  };
+}

package/src/utils/config.js

@@ -0,0 +1,33 @@
+import fs from "fs";
+import os from "os";
+import path from "path";
+
+const DIR = path.join(os.homedir(), ".devfix");
+const FILE = path.join(DIR, "config.json");
+
+export function ensureConfigDir() {
+  if (!fs.existsSync(DIR)) fs.mkdirSync(DIR, { recursive: true });
+}
+
+export function readConfig() {
+  try {
+    if (!fs.existsSync(FILE)) return null;
+    const raw = fs.readFileSync(FILE, "utf-8");
+    return JSON.parse(raw);
+  } catch {
+    return null;
+  }
+}
+
+export function writeConfig(data) {
+  ensureConfigDir();
+  fs.writeFileSync(FILE, JSON.stringify(data, null, 2), "utf-8");
+}
+
+export function deleteConfig() {
+  if (fs.existsSync(FILE)) fs.unlinkSync(FILE);
+}
+
+export function getConfigPath() {
+  return FILE;
+}

package/src/utils/context.js

@@ -0,0 +1,63 @@
+import fs from "fs";
+import os from "os";
+import path from "path";
+import { execSync } from "child_process";
+
+function safeExec(cmd) {
+  try {
+    return execSync(cmd, { encoding: "utf-8", stdio: ["ignore", "pipe", "ignore"] }).trim();
+  } catch {
+    return null;
+  }
+}
+
+function safeReadJson(filePath) {
+  try {
+    if (!fs.existsSync(filePath)) return null;
+    return JSON.parse(fs.readFileSync(filePath, "utf-8"));
+  } catch {
+    return null;
+  }
+}
+
+export function collectContext() {
+  const cwd = process.cwd();
+
+  // Basic system info
+  const context = {
+    cwd,
+    os: `${os.type()} ${os.release()}`,
+    platform: os.platform(),
+    arch: os.arch(),
+    node: safeExec("node -v"),
+    npm: safeExec("npm -v"),
+    gitBranch: safeExec("git branch --show-current"),
+  };
+
+  // Node project detection
+  const pkgPath = path.join(cwd, "package.json");
+  const pkg = safeReadJson(pkgPath);
+
+  if (pkg) {
+    context.projectType = "node";
+    context.projectName = pkg.name || null;
+    context.dependencies = Object.keys(pkg.dependencies || {}).slice(0, 30);
+    context.devDependencies = Object.keys(pkg.devDependencies || {}).slice(0, 30);
+    context.scripts = pkg.scripts || {};
+  }
+
+  // Kubernetes tools detection
+  const kubectl = safeExec("kubectl version --client=true --output=yaml");
+  if (kubectl) {
+    context.kubectlInstalled = true;
+    context.kubectlVersion = kubectl.slice(0, 500);
+  }
+
+  const minikube = safeExec("minikube version");
+  if (minikube) {
+    context.minikubeInstalled = true;
+    context.minikubeVersion = minikube;
+  }
+
+  return context;
+}

package/src/utils/cryptoStore.js

@@ -0,0 +1,35 @@
+import crypto from "crypto";
+
+// Creates a machine-local key (same user on same machine)
+function getSecretKey() {
+  const user = process.env.USER || process.env.USERNAME || "devfix";
+  const machine = process.env.HOSTNAME || "localmachine";
+
+  // 32 bytes key for AES-256
+  return crypto.createHash("sha256").update(user + machine).digest();
+}
+
+export function encrypt(text) {
+  const iv = crypto.randomBytes(16);
+  const key = getSecretKey();
+
+  const cipher = crypto.createCipheriv("aes-256-cbc", key, iv);
+  let encrypted = cipher.update(text, "utf8", "base64");
+  encrypted += cipher.final("base64");
+
+  return iv.toString("base64") + ":" + encrypted;
+}
+
+export function decrypt(encryptedText) {
+  const [ivBase64, encrypted] = encryptedText.split(":");
+  if (!ivBase64 || !encrypted) return null;
+
+  const iv = Buffer.from(ivBase64, "base64");
+  const key = getSecretKey();
+
+  const decipher = crypto.createDecipheriv("aes-256-cbc", key, iv);
+  let decrypted = decipher.update(encrypted, "base64", "utf8");
+  decrypted += decipher.final("utf8");
+
+  return decrypted;
+}

package/src/utils/detectStack.js

@@ -0,0 +1,12 @@
+export function detectStack(text) {
+  const t = text.toLowerCase();
+
+  if (t.includes("kubectl") || t.includes("minikube") || t.includes("kubernetes")) return "kubernetes";
+  if (t.includes("docker") || t.includes("container")) return "docker";
+  if (t.includes("npm") || t.includes("node") || t.includes("express")) return "nodejs";
+  if (t.includes("react") || t.includes("vite")) return "react";
+  if (t.includes("python") || t.includes("pip")) return "python";
+  if (t.includes("git") || t.includes("commit")) return "git";
+
+  return "general";
+}

package/src/utils/prompt.js

@@ -0,0 +1,29 @@
+export function buildPrompt({ stack, input, context = {} }) {
+  return `
+You are DevFix, a CLI debugging assistant.
+
+Hard rules:
+- Be concise.
+- Max 5 fix steps.
+- Max 6 commands.
+- No long paragraphs.
+- If log indicates success (no error), say so and ask for the real error.
+- If ambiguous, ask ONLY 1 question.
+
+Output format (Markdown):
+### Summary
+### Root Cause
+### Fix (steps)
+### Commands
+### Verify
+### Question (only if needed)
+
+Stack: ${stack}
+
+Context (optional):
+${Object.keys(context).length ? JSON.stringify(context, null, 2) : "None"}
+
+Error/Log:
+${input}
+`;
+}

package/src/utils/secureStore.js

@@ -0,0 +1,16 @@
+import keytar from "keytar";
+
+const SERVICE = "devfix-cli";
+const ACCOUNT = "openrouter-api-key";
+
+export async function saveApiKey(apiKey) {
+  await keytar.setPassword(SERVICE, ACCOUNT, apiKey);
+}
+
+export async function getApiKey() {
+  return await keytar.getPassword(SERVICE, ACCOUNT);
+}
+
+export async function deleteApiKey() {
+  await keytar.deletePassword(SERVICE, ACCOUNT);
+}

package/src/utils/session.js

@@ -0,0 +1,21 @@
+export function isSessionValid(config) {
+  if (!config) return false;
+  if (!config.expiresAt) return false;
+
+  const expiresAt = new Date(config.expiresAt).getTime();
+  const now = Date.now();
+
+  return now < expiresAt;
+}
+
+export function createSession({ username, email }) {
+  const now = new Date();
+  const expires = new Date(now.getTime() + 7 * 24 * 60 * 60 * 1000); // 7 days
+
+  return {
+    username,
+    email,
+    loggedInAt: now.toISOString(),
+    expiresAt: expires.toISOString(),
+  };
+}