@krishivpb60/aether-ai-cli 1.1.6 → 1.1.8

package/src/cli.js

@@ -202,6 +202,14 @@ export function createCLI(argv) {
       await handleSetup();
     });
 
+  // ── Commit Command ──────────────────────────────────────
+  program
+    .command("commit")
+    .description("Generate conventional commit message from git diff and commit changes")
+    .action(async () => {
+      await handleCommit();
+    });
+
   // ── Default: Show help ──────────────────────────────────
   program.action(() => {
     showMiniBanner();
@@ -569,6 +577,86 @@ async function handleStatus() {
   console.log("");
 }
 
+async function handleCommit() {
+  const { getGitDiff, runGitCommit } = await import("./git.js");
+  const { createInterface } = await import("node:readline/promises");
+
+  try {
+    const { diff, isStaged } = await getGitDiff();
+    if (!diff) {
+      console.log("\n" + label.system + " " + colors.warning("No staged or unstaged changes detected. Stage your files using 'git add' first.\n"));
+      return;
+    }
+
+    if (!isStaged) {
+      const rlInit = createInterface({
+        input: process.stdin,
+        output: process.stdout,
+      });
+      const stageAnswer = await rlInit.question("\n" + label.system + " " + colors.warning("No staged changes found. Do you want to stage all changes automatically? [y/N]: "));
+      rlInit.close();
+
+      if (stageAnswer.toLowerCase().trim() === "y" || stageAnswer.toLowerCase().trim() === "yes") {
+        const { exec } = await import("node:child_process");
+        const { promisify } = await import("node:util");
+        const execAsync = promisify(exec);
+        await execAsync("git add .");
+        console.log(label.system + " " + colors.success("Staged all changes successfully."));
+      } else {
+        console.log("\n" + label.system + " " + colors.muted("Aborted. Please stage files using 'git add' first.\n"));
+        return;
+      }
+    }
+
+    const aiConfig = await getAIConfig();
+    const mode = MODES[DEFAULT_MODE];
+
+    console.log("");
+    console.log(label.system + " " + colors.brand("Reading git diff and generating conventional commit message..."));
+    console.log("");
+
+    const systemPrompt = "You are an expert developer assistant. Generate a concise, clear, and professional conventional commit message (e.g., 'feat: add login page', 'fix: resolve buffer overflow') based on the provided git diff. Output ONLY the commit message itself on a single line, with absolutely no backticks, markdown, explanations, prefix, or introductory text.";
+    const userPrompt = `Here is the git diff:\n\n${diff}`;
+
+    let firstToken = true;
+    let commitMessage = "";
+    const onToken = (token) => {
+      if (firstToken) {
+        firstToken = false;
+        process.stdout.write(label.aether + " Suggested Commit Message: " + colors.success(token));
+      } else {
+        process.stdout.write(colors.success(token));
+      }
+      commitMessage += token;
+    };
+
+    const result = await routePrompt(userPrompt, mode.systemPrompt, aiConfig, onToken);
+    console.log("\n");
+
+    const cleanMessage = result.text.trim().replace(/^`+|`+$/g, ""); // strip quotes/backticks
+
+    const rl = createInterface({
+      input: process.stdin,
+      output: process.stdout,
+    });
+
+    const answer = await rl.question(colors.muted("Commit with this message? [Y/n]: "));
+    rl.close();
+
+    if (answer.toLowerCase().trim() === "n" || answer.toLowerCase().trim() === "no") {
+      console.log("\n" + label.system + " " + colors.muted("Commit aborted.\n"));
+      return;
+    }
+
+    console.log("\n" + label.system + " " + colors.brand("Executing git commit..."));
+    const output = await runGitCommit(cleanMessage);
+    console.log("\n" + colors.success(output) + "\n");
+
+  } catch (err) {
+    console.log("\n" + label.error + " " + colors.danger(err.message) + "\n");
+  }
+}
+
 async function handleSetup() {
   const { createInterface } = await import("node:readline");
 

package/src/config.js

@@ -5,6 +5,15 @@
 // ═══════════════════════════════════════════════════════════
 
 import { readFile, writeFile, mkdir, unlink, access } from "node:fs/promises";
+import {
+  existsSync,
+  readdirSync,
+  statSync,
+  mkdirSync,
+  readFileSync,
+  writeFileSync,
+  unlinkSync
+} from "node:fs";
 import { join } from "node:path";
 import { homedir } from "node:os";
 import { getAllConfigKeys } from "./ai/providers.js";
@@ -164,7 +173,7 @@ export async function configExists() {
 export function isValidConfigKey(key) {
   const upper = key.toUpperCase();
   // Accept any API key or model override
-  if (upper.endsWith("_API_KEY") || upper.endsWith("_API_KEYS") || upper.endsWith("_MODEL") || upper === "THEME" || upper === "CUSTOM_COMMANDS") {
+  if (upper.endsWith("_API_KEY") || upper.endsWith("_API_KEYS") || upper.endsWith("_MODEL") || upper === "THEME" || upper === "CUSTOM_COMMANDS" || upper === "AUTOPILOT") {
     return true;
   }
   // Accept known config keys
@@ -172,7 +181,143 @@ export function isValidConfigKey(key) {
   return knownKeys.includes(upper);
 }
 
-const HISTORY_FILE = join(CONFIG_DIR, "history.json");
+const HISTORY_DIR = join(CONFIG_DIR, "history");
+const LEGACY_HISTORY_FILE = join(CONFIG_DIR, "history.json");
+
+let currentSessionFile = null;
+
+/**
+ * Gets the current active session file path, initializing it if necessary.
+ * @returns {string}
+ */
+export function getSessionFile() {
+  if (currentSessionFile) {
+    return currentSessionFile;
+  }
+
+  try {
+    if (!existsSync(HISTORY_DIR)) {
+      mkdirSync(HISTORY_DIR, { recursive: true });
+    }
+
+    const files = readdirSync(HISTORY_DIR).filter(
+      (f) => f.startsWith("session_") && f.endsWith(".json")
+    );
+
+    if (files.length > 0) {
+      // Sort files descending by modification time
+      files.sort((a, b) => {
+        return statSync(join(HISTORY_DIR, b)).mtimeMs - statSync(join(HISTORY_DIR, a)).mtimeMs;
+      });
+      currentSessionFile = join(HISTORY_DIR, files[0]);
+    } else {
+      // If legacy history file exists, migrate it
+      if (existsSync(LEGACY_HISTORY_FILE)) {
+        const timestamp = statSync(LEGACY_HISTORY_FILE).mtimeMs || Date.now();
+        currentSessionFile = join(HISTORY_DIR, `session_${timestamp}.json`);
+        try {
+          const raw = readFileSync(LEGACY_HISTORY_FILE, "utf-8");
+          const legacyData = JSON.parse(raw);
+          const sessionData = {
+            mode: "titan",
+            timestamp,
+            messages: Array.isArray(legacyData) ? legacyData : (legacyData.messages || []),
+          };
+          writeFileSync(currentSessionFile, JSON.stringify(sessionData, null, 2), "utf-8");
+          try {
+            unlinkSync(LEGACY_HISTORY_FILE);
+          } catch {
+            // ignore unlink error
+          }
+        } catch {
+          // ignore parsing error, start new
+          startNewSession();
+        }
+      } else {
+        startNewSession();
+      }
+    }
+  } catch {
+    startNewSession();
+  }
+
+  return currentSessionFile;
+}
+
+/**
+ * Starts a new chat session.
+ * @returns {string} Path to the new session file
+ */
+export function startNewSession() {
+  const timestamp = Date.now();
+  currentSessionFile = join(HISTORY_DIR, `session_${timestamp}.json`);
+  try {
+    if (!existsSync(HISTORY_DIR)) {
+      mkdirSync(HISTORY_DIR, { recursive: true });
+    }
+    const sessionData = {
+      mode: "titan",
+      timestamp,
+      messages: [],
+    };
+    writeFileSync(currentSessionFile, JSON.stringify(sessionData, null, 2), "utf-8");
+  } catch {
+    // Fail silently
+  }
+  return currentSessionFile;
+}
+
+/**
+ * Lists all session logs.
+ * @returns {Array} List of sessions with metadata
+ */
+export function listSessions() {
+  try {
+    if (!existsSync(HISTORY_DIR)) {
+      mkdirSync(HISTORY_DIR, { recursive: true });
+    }
+    const files = readdirSync(HISTORY_DIR).filter(
+      (f) => f.startsWith("session_") && f.endsWith(".json")
+    );
+    const sessions = [];
+
+    for (const file of files) {
+      const fullPath = join(HISTORY_DIR, file);
+      try {
+        const raw = readFileSync(fullPath, "utf-8");
+        const data = JSON.parse(raw);
+        const messages = Array.isArray(data) ? data : (data.messages || []);
+        const mode = Array.isArray(data) ? "titan" : (data.mode || "titan");
+        const timestamp = Array.isArray(data)
+          ? (statSync(fullPath).mtimeMs || Date.now())
+          : (data.timestamp || statSync(fullPath).mtimeMs || Date.now());
+
+        sessions.push({
+          file: fullPath,
+          filename: file,
+          timestamp,
+          mode,
+          messages,
+        });
+      } catch {
+        // ignore corrupt files
+      }
+    }
+
+    sessions.sort((a, b) => b.timestamp - a.timestamp);
+    return sessions;
+  } catch {
+    return [];
+  }
+}
+
+/**
+ * Switches the active session file.
+ * @param {string} sessionFile
+ */
+export function switchSession(sessionFile) {
+  currentSessionFile = sessionFile;
+}
 
 /**
  * Loads chat history from disk.
@@ -180,8 +325,10 @@ const HISTORY_FILE = join(CONFIG_DIR, "history.json");
  */
 export async function loadHistory() {
   try {
-    const raw = await readFile(HISTORY_FILE, "utf-8");
-    return JSON.parse(raw);
+    const file = getSessionFile();
+    const raw = readFileSync(file, "utf-8");
+    const data = JSON.parse(raw);
+    return Array.isArray(data) ? data : (data.messages || []);
   } catch {
     return [];
   }
@@ -190,24 +337,54 @@ export async function loadHistory() {
 /**
  * Saves chat history to disk.
  * @param {Array} history - List of chat exchanges to save
+ * @param {string} [mode] - Current mode name
  */
-export async function saveHistory(history) {
+export async function saveHistory(history, mode) {
   try {
-    await mkdir(CONFIG_DIR, { recursive: true });
-    // Limit saved history to last 50 entries to keep it light
+    const file = getSessionFile();
+    let timestamp = Date.now();
+    const match = file.match(/session_(\d+)\.json$/);
+    if (match) {
+      timestamp = parseInt(match[1], 10);
+    }
     const trimmed = history.slice(-50);
-    await writeFile(HISTORY_FILE, JSON.stringify(trimmed, null, 2), "utf-8");
+    
+    let finalMode = mode;
+    if (!finalMode) {
+      try {
+        const raw = readFileSync(file, "utf-8");
+        const data = JSON.parse(raw);
+        if (!Array.isArray(data)) {
+          finalMode = data.mode;
+        }
+      } catch {
+        // file might not exist yet
+      }
+    }
+    if (!finalMode) {
+      finalMode = "titan";
+    }
+
+    const sessionData = {
+      mode: finalMode,
+      timestamp,
+      messages: trimmed,
+    };
+
+    writeFileSync(file, JSON.stringify(sessionData, null, 2), "utf-8");
   } catch {
     // Fail silently to not block chat
   }
 }
 
 /**
- * Deletes the chat history file.
+ * Deletes the current chat history file.
  */
 export async function clearHistory() {
   try {
-    await unlink(HISTORY_FILE);
+    const file = getSessionFile();
+    unlinkSync(file);
+    currentSessionFile = null;
   } catch {
     // File may not exist
   }

package/src/file-parser.js

@@ -3,7 +3,8 @@
 // ═══════════════════════════════════════════════════════════
 
 import { readFile, stat } from "node:fs/promises";
-import { resolve, extname, basename } from "node:path";
+import { readdirSync, statSync } from "node:fs";
+import { resolve, extname, basename, join, relative } from "node:path";
 
 const MAX_CONTENT_LENGTH = 30000;
 
@@ -92,3 +93,49 @@ function formatBytes(bytes) {
   if (bytes < 1024 * 1024) return `${(bytes / 1024).toFixed(1)}KB`;
   return `${(bytes / (1024 * 1024)).toFixed(1)}MB`;
 }
+
+const EXCLUDE_DIRS = new Set([
+  "node_modules", ".git", ".agents", "build", "dist", ".github",
+  "aether_pip", "aether_ai_agent_cli.egg-info", "aether_ai_cli.egg-info"
+]);
+
+/**
+ * Recursively scans baseDir and returns a list of supported files.
+ * @param {string} baseDir - Directory to scan
+ * @returns {string[]} List of relative file paths
+ */
+export function scanWorkspaceFiles(baseDir) {
+  const files = [];
+
+  function recurse(dir) {
+    let entries;
+    try {
+      entries = readdirSync(dir);
+    } catch {
+      return;
+    }
+
+    for (const entry of entries) {
+      if (EXCLUDE_DIRS.has(entry)) continue;
+      const fullPath = join(dir, entry);
+      let stats;
+      try {
+        stats = statSync(fullPath);
+      } catch {
+        continue;
+      }
+
+      if (stats.isDirectory()) {
+        recurse(fullPath);
+      } else if (stats.isFile()) {
+        const ext = extname(entry).toLowerCase();
+        if (SUPPORTED_EXTENSIONS.has(ext)) {
+          files.push(relative(baseDir, fullPath));
+        }
+      }
+    }
+  }
+
+  recurse(baseDir);
+  return files.sort();
+}

package/src/git.js

@@ -0,0 +1,41 @@
+import { exec } from "node:child_process";
+import { promisify } from "node:util";
+
+const execAsync = promisify(exec);
+
+/**
+ * Checks if inside a git repository and returns the staged or unstaged diff.
+ * @returns {Promise<{ diff: string, isStaged: boolean }>}
+ */
+export async function getGitDiff() {
+  try {
+    await execAsync("git rev-parse --is-inside-work-tree");
+  } catch {
+    throw new Error("Not a git repository (or git is not installed).");
+  }
+
+  // Try staged changes first
+  const { stdout: staged } = await execAsync("git diff --cached");
+  if (staged.trim()) {
+    return { diff: staged.trim(), isStaged: true };
+  }
+
+  // Fallback to unstaged changes
+  const { stdout: unstaged } = await execAsync("git diff");
+  if (unstaged.trim()) {
+    return { diff: unstaged.trim(), isStaged: false };
+  }
+
+  return { diff: "", isStaged: false };
+}
+
+/**
+ * Executes a git commit with the specified message.
+ * @param {string} message - The commit message
+ * @returns {Promise<string>} stdout output of the git commit command
+ */
+export async function runGitCommit(message) {
+  const escaped = message.replace(/"/g, '\\"');
+  const { stdout } = await execAsync(`git commit -m "${escaped}"`);
+  return stdout.trim();
+}

package/src/ui/theme.js

@@ -269,11 +269,6 @@ export function getThemesList() {
   return Object.keys(THEMES);
 }
 
-/**
- * Strips markdown code block fences (```lang ... ```) from a string if present.
- * @param {string} content - Raw content extracted from file write blocks
- * @returns {string} Cleaned content
- */
 export function stripCodeFences(content) {
   let cleaned = content.trim();
   if (cleaned.startsWith("```")) {
@@ -289,3 +284,205 @@ export function stripCodeFences(content) {
   }
   return cleaned.trim();
 }
+
+/**
+ * Interactive checkbox selector inside terminal using raw stdin. Renders scrollable pagination.
+ * Arrow Up/Down to navigate, Space to toggle, Enter to confirm, Esc/q to abort.
+ */
+export async function interactiveCheckbox(headerText, items, preselected = []) {
+  if (items.length === 0) return [];
+
+  const stdin = process.stdin;
+  const stdout = process.stdout;
+  
+  const wasRaw = stdin.isRaw;
+  stdin.setRawMode(true);
+  stdin.resume();
+  stdin.setEncoding("utf8");
+
+  stdout.write("\x1b[?25l"); // Hide cursor
+
+  let activeIndex = 0;
+  const selected = new Set(preselected.map(item => items.indexOf(item)).filter(i => i !== -1));
+  
+  const PAGE_SIZE = 10;
+  let startRow = 0;
+  let renderedLines = 0;
+
+  function render() {
+    if (renderedLines > 0) {
+      stdout.write(`\x1b[${renderedLines}A\x1b[J`);
+    }
+
+    let lines = [];
+    lines.push(colors.brand(headerText));
+
+    if (activeIndex < startRow) {
+      startRow = activeIndex;
+    } else if (activeIndex >= startRow + PAGE_SIZE) {
+      startRow = activeIndex - PAGE_SIZE + 1;
+    }
+
+    const visibleEnd = Math.min(items.length, startRow + PAGE_SIZE);
+    for (let i = startRow; i < visibleEnd; i++) {
+      const isActive = i === activeIndex;
+      const isSelected = selected.has(i);
+
+      const pointer = isActive ? colors.accent("❯ ") : "  ";
+      const checkbox = isSelected 
+        ? colors.success("[⬢] ") 
+        : colors.muted("[⬡] ");
+      
+      const itemText = isActive 
+        ? colors.brand(items[i]) 
+        : colors.text(items[i]);
+
+      lines.push(pointer + checkbox + itemText);
+    }
+
+    if (items.length > PAGE_SIZE) {
+      lines.push(colors.dim(`  (Arrow Keys, Page ${Math.floor(startRow/PAGE_SIZE) + 1}/${Math.ceil(items.length/PAGE_SIZE)})`));
+    }
+
+    const outputStr = lines.join("\n") + "\n";
+    stdout.write(outputStr);
+    renderedLines = lines.length;
+  }
+
+  render();
+
+  return new Promise((resolve) => {
+    function handleKey(key) {
+      if (key === "\u0003" || key === "\u001b" || key === "q") { // Ctrl+C, Esc, q
+        cleanup();
+        resolve(null);
+        return;
+      }
+
+      if (key === "\r" || key === "\n") { // Enter
+        cleanup();
+        resolve([...selected].map(i => items[i]));
+        return;
+      }
+
+      if (key === " ") { // Spacebar
+        if (selected.has(activeIndex)) {
+          selected.delete(activeIndex);
+        } else {
+          selected.add(activeIndex);
+        }
+        render();
+        return;
+      }
+
+      if (key === "\u001b[A") { // Up Arrow
+        activeIndex = (activeIndex - 1 + items.length) % items.length;
+        render();
+      } else if (key === "\u001b[B") { // Down Arrow
+        activeIndex = (activeIndex + 1) % items.length;
+        render();
+      }
+    }
+
+    function cleanup() {
+      stdin.removeListener("data", handleKey);
+      stdin.setRawMode(wasRaw);
+      stdin.pause();
+      stdout.write("\x1b[?25h"); // Show cursor
+    }
+
+    stdin.on("data", handleKey);
+  });
+}
+
+/**
+ * Interactive single-select menu selector inside terminal. Renders scrollable pagination.
+ * Arrow Up/Down to navigate, Enter to select, Esc/q to abort.
+ */
+export async function interactiveMenu(headerText, items) {
+  if (items.length === 0) return null;
+
+  const stdin = process.stdin;
+  const stdout = process.stdout;
+  
+  const wasRaw = stdin.isRaw;
+  stdin.setRawMode(true);
+  stdin.resume();
+  stdin.setEncoding("utf8");
+
+  stdout.write("\x1b[?25l"); // Hide cursor
+
+  let activeIndex = 0;
+  const PAGE_SIZE = 10;
+  let startRow = 0;
+  let renderedLines = 0;
+
+  function render() {
+    if (renderedLines > 0) {
+      stdout.write(`\x1b[${renderedLines}A\x1b[J`);
+    }
+
+    let lines = [];
+    lines.push(colors.brand(headerText));
+
+    if (activeIndex < startRow) {
+      startRow = activeIndex;
+    } else if (activeIndex >= startRow + PAGE_SIZE) {
+      startRow = activeIndex - PAGE_SIZE + 1;
+    }
+
+    const visibleEnd = Math.min(items.length, startRow + PAGE_SIZE);
+    for (let i = startRow; i < visibleEnd; i++) {
+      const isActive = i === activeIndex;
+      const pointer = isActive ? colors.accent("❯ ") : "  ";
+      const itemText = isActive 
+        ? colors.success(items[i]) 
+        : colors.text(items[i]);
+
+      lines.push(pointer + itemText);
+    }
+
+    if (items.length > PAGE_SIZE) {
+      lines.push(colors.dim(`  (Page ${Math.floor(startRow/PAGE_SIZE) + 1}/${Math.ceil(items.length/PAGE_SIZE)})`));
+    }
+
+    const outputStr = lines.join("\n") + "\n";
+    stdout.write(outputStr);
+    renderedLines = lines.length;
+  }
+
+  render();
+
+  return new Promise((resolve) => {
+    function handleKey(key) {
+      if (key === "\u0003" || key === "\u001b" || key === "q") { // Ctrl+C, Esc, q
+        cleanup();
+        resolve(null);
+        return;
+      }
+
+      if (key === "\r" || key === "\n") { // Enter
+        cleanup();
+        resolve(activeIndex);
+        return;
+      }
+
+      if (key === "\u001b[A") { // Up Arrow
+        activeIndex = (activeIndex - 1 + items.length) % items.length;
+        render();
+      } else if (key === "\u001b[B") { // Down Arrow
+        activeIndex = (activeIndex + 1) % items.length;
+        render();
+      }
+    }
+
+    function cleanup() {
+      stdin.removeListener("data", handleKey);
+      stdin.setRawMode(wasRaw);
+      stdin.pause();
+      stdout.write("\x1b[?25h"); // Show cursor
+    }
+
+    stdin.on("data", handleKey);
+  });
+}