@semalt-ai/code 1.4.4 → 1.6.0

package/lib/commands.js

@@ -0,0 +1,344 @@
+'use strict';
+
+const fs = require('fs');
+const readline = require('readline');
+
+const { CONFIG_PATH, DEFAULT_API_TIMEOUT_MS } = require('./constants');
+const { getSystemPrompt } = require('./prompts');
+
+function createCommands({
+  getConfig,
+  setConfig,
+  permissionManager,
+  ui,
+  apiClient,
+  runAgentLoop,
+  readFileContext,
+  agentExecShell,
+}) {
+  const {
+    BOLD,
+    FG_BLUE,
+    FG_CYAN,
+    FG_DARK,
+    FG_GRAY,
+    FG_GREEN,
+    FG_RED,
+    FG_TEAL,
+    FG_YELLOW,
+    RST,
+    getCols,
+    printBanner,
+    printHelpHints,
+    printStatusBar,
+    readInteractiveInput,
+  } = ui;
+  const {
+    chatStream,
+    chatSync,
+    chooseSavedModelProfile,
+    describeModelProfile,
+    estimateTokens,
+    setActiveModelProfile,
+  } = apiClient;
+
+  async function cmdChat(opts) {
+    printBanner();
+    const cwd = process.cwd();
+    let currentModel = opts.model || getConfig().default_model;
+    let isRunningAgent = false;
+
+    printStatusBar(currentModel, cwd);
+    printHelpHints();
+
+    let messages = [{ role: 'system', content: getSystemPrompt() }];
+    const promptHistory = [];
+    const cols = getCols();
+
+    while (true) {
+      const inputResult = await readInteractiveInput(`  ${FG_TEAL}${BOLD}>${RST} `, {
+        trim: false,
+        allowCursorNavigation: true,
+        history: promptHistory,
+      });
+
+      if (inputResult.type === 'eof') {
+        console.log(`\n  ${FG_GRAY}Goodbye!${RST}\n`);
+        return;
+      }
+
+      if (inputResult.type === 'sigint') {
+        if (!isRunningAgent) {
+          console.log(`\n  ${FG_YELLOW}Use Ctrl+D or type exit to quit.${RST}`);
+        }
+        continue;
+      }
+
+      const text = (inputResult.value || '').trim();
+      if (!text) continue;
+      promptHistory.push(text);
+
+      if (['exit', 'quit', '/exit', '/quit'].includes(text.toLowerCase())) {
+        console.log(`\n  ${FG_GRAY}Goodbye!${RST}\n`);
+        return;
+      }
+
+      if (text === '/help') {
+        console.log(`
+  ${FG_BLUE}${BOLD}Commands:${RST}
+  ${FG_CYAN}/file <path>${RST}     ${FG_GRAY}Load file or dir into context${RST}
+  ${FG_CYAN}/model${RST}           ${FG_GRAY}Choose saved model profile${RST}
+  ${FG_CYAN}/model <name>${RST}    ${FG_GRAY}Switch model manually${RST}
+  ${FG_CYAN}/models${RST}          ${FG_GRAY}Choose saved model profile${RST}
+  ${FG_CYAN}/clear${RST}           ${FG_GRAY}Clear conversation${RST}
+  ${FG_CYAN}/compact${RST}         ${FG_GRAY}Show token usage${RST}
+  ${FG_CYAN}/shell <cmd>${RST}     ${FG_GRAY}Run shell command directly${RST}
+  ${FG_CYAN}!<cmd>${RST}           ${FG_GRAY}Run shell command directly${RST}
+  ${FG_CYAN}/approve${RST}         ${FG_GRAY}Toggle auto-approve for all actions${RST}
+  ${FG_CYAN}/config${RST}          ${FG_GRAY}Show config${RST}
+  ${FG_CYAN}exit${RST}             ${FG_GRAY}Quit${RST}
+
+  ${FG_DARK}The AI can execute commands — you'll be asked to approve each one.${RST}
+`);
+        continue;
+      }
+
+      if (text.startsWith('/file ')) {
+        const fp = text.slice(6).trim();
+        const ctx = readFileContext([fp], ui);
+        if (ctx) messages.push({ role: 'user', content: `Here is the file context:\n${ctx}` });
+        continue;
+      }
+
+      if (text === '/model' || text === '/models') {
+        await new Promise((resolve) => {
+          const rl = readline.createInterface({
+            input: process.stdin,
+            output: process.stdout,
+            terminal: true,
+          });
+          chooseSavedModelProfile(rl, currentModel, cwd, (nextModel) => {
+            currentModel = nextModel;
+            rl.close();
+            resolve();
+          });
+        });
+        continue;
+      }
+
+      if (text.startsWith('/model ')) {
+        currentModel = text.slice(7).trim();
+        console.log(`  ${FG_GREEN}✓${RST} ${FG_GRAY}Model → ${currentModel}${RST}`);
+        printStatusBar(currentModel, cwd);
+        continue;
+      }
+
+      if (text === '/clear') {
+        messages = [{ role: 'system', content: getSystemPrompt() }];
+        permissionManager.clear();
+        console.log(`  ${FG_GREEN}✓${RST} ${FG_GRAY}Conversation and approvals cleared${RST}\n`);
+        continue;
+      }
+
+      if (text === '/compact' || text === '/cost') {
+        const total = messages.reduce((sum, message) => sum + estimateTokens(message.content), 0);
+        console.log(`  ${FG_GRAY}${messages.length - 1} messages · ~${total} tokens${RST}\n`);
+        continue;
+      }
+
+      if (text === '/config') {
+        console.log(`  ${FG_GRAY}${JSON.stringify(getConfig(), null, 2)}${RST}\n`);
+        continue;
+      }
+
+      if (text === '/approve') {
+        const enabled = permissionManager.toggleAll();
+        const state = enabled ? 'ON' : 'OFF';
+        const color = enabled ? FG_GREEN : FG_RED;
+        console.log(`  ${color}●${RST} ${FG_GRAY}Auto-approve: ${state}${RST}\n`);
+        continue;
+      }
+
+      if (text.startsWith('/shell ') || text.startsWith('!')) {
+        const cmd = text.startsWith('/shell ') ? text.slice(7).trim() : text.slice(1).trim();
+        await agentExecShell(cmd);
+        continue;
+      }
+
+      messages.push({ role: 'user', content: text });
+      console.log(`  ${FG_DARK}${'─'.repeat(Math.min(cols, 70) - 4)}${RST}`);
+
+      isRunningAgent = true;
+      messages = await runAgentLoop(messages, currentModel);
+      isRunningAgent = false;
+
+      console.log(`  ${FG_DARK}${'━'.repeat(Math.min(cols, 70) - 4)}${RST}`);
+      console.log();
+    }
+  }
+
+  async function cmdCode(opts, promptArgs) {
+    if (!promptArgs.length) {
+      console.log(`  ${FG_RED}Usage: semalt-code code <prompt>${RST}`);
+      return;
+    }
+
+    const userPrompt = promptArgs.join(' ');
+    const context = opts.file ? readFileContext(opts.file, ui) : '';
+    const fullPrompt = context ? `Context files:\n${context}\n\nTask: ${userPrompt}` : userPrompt;
+
+    let messages = [
+      { role: 'system', content: getSystemPrompt() },
+      { role: 'user', content: fullPrompt },
+    ];
+    messages = await runAgentLoop(messages, opts.model || getConfig().default_model);
+    console.log();
+  }
+
+  async function cmdEdit(opts, filePath, instructionArgs) {
+    if (!filePath) {
+      console.log(`  ${FG_RED}Usage: semalt-code edit <file> <instruction>${RST}`);
+      return;
+    }
+    if (!fs.existsSync(filePath)) {
+      console.log(`  ${FG_RED}✗ File not found: ${filePath}${RST}`);
+      return;
+    }
+
+    const content = fs.readFileSync(filePath, 'utf8');
+    const instruction = instructionArgs.join(' ');
+
+    const messages = [
+      { role: 'system', content: 'You are Semalt.AI. Output ONLY the modified file. No explanations, no fences.' },
+      { role: 'user', content: `File: ${filePath}\n\n\`\`\`\n${content}\n\`\`\`\n\nInstruction: ${instruction}` },
+    ];
+
+    console.log(`  ${FG_GRAY}Editing ${filePath}...${RST}`);
+    let result = await chatSync(messages, { model: opts.model });
+
+    if (result && !opts.dryRun) {
+      if (result.startsWith('```')) {
+        const lines = result.split('\n');
+        result = lines.at(-1).trim() === '```'
+          ? lines.slice(1, -1).join('\n')
+          : lines.slice(1).join('\n');
+      }
+      fs.writeFileSync(filePath, result);
+      console.log(`  ${FG_GREEN}✓ Saved: ${filePath}${RST}`);
+    } else if (opts.dryRun) {
+      console.log(`  ${FG_YELLOW}⚠ Dry run — not modified${RST}`);
+    }
+  }
+
+  async function cmdShell(opts, commandArgs) {
+    const command = commandArgs.join(' ');
+    if (!command) {
+      console.log(`  ${FG_RED}Usage: semalt-code shell <command>${RST}`);
+      return;
+    }
+
+    const result = await agentExecShell(command);
+
+    if (opts.analyze) {
+      const messages = [
+        { role: 'system', content: 'You are Semalt.AI. Analyze the command output concisely.' },
+        { role: 'user', content: `Command: ${command}\nExit: ${result.exit_code}\nStdout:\n${result.stdout}\nStderr:\n${result.stderr}` },
+      ];
+      console.log();
+      console.log(`  ${FG_TEAL}${BOLD}◆ Semalt.AI${RST}`);
+      console.log();
+      process.stdout.write('  ');
+      await chatStream(messages, { model: opts.model });
+      console.log();
+    }
+  }
+
+  async function cmdModels() {
+    const config = getConfig();
+    if (!config.models.length) {
+      console.log(`  ${FG_RED}✗${RST} ${FG_GRAY}No saved model profiles. Use semalt-code models add first.${RST}`);
+      return;
+    }
+
+    console.log();
+    console.log(`  ${FG_TEAL}${BOLD}◆ Saved Models${RST}`);
+    console.log(`  ${FG_DARK}${'─'.repeat(40)}${RST}`);
+    config.models.forEach((profile, index) => {
+      const active = profile.api_base === config.api_base &&
+        profile.api_key === config.api_key &&
+        profile.model === config.default_model;
+      const marker = active ? `${FG_GREEN}●${RST}` : `${FG_DARK}○${RST}`;
+      console.log(`  ${marker} ${FG_CYAN}${index + 1}.${RST} ${describeModelProfile(profile)}`);
+    });
+    console.log();
+  }
+
+  async function cmdModelsAdd() {
+    const rl = readline.createInterface({
+      input: process.stdin,
+      output: process.stdout,
+      terminal: true,
+    });
+
+    function ask(question) {
+      return new Promise((resolve) => {
+        rl.question(question, (answer) => resolve((answer || '').trim()));
+      });
+    }
+
+    console.log();
+    console.log(`  ${FG_TEAL}${BOLD}◆ Add Model Profile${RST}`);
+    console.log(`  ${FG_DARK}${'─'.repeat(40)}${RST}`);
+
+    const apiBase = await ask(`  ${FG_CYAN}API Base URL:${RST} `);
+    const apiKey = await ask(`  ${FG_CYAN}API Key:${RST} `);
+    const modelId = await ask(`  ${FG_CYAN}Model ID:${RST} `);
+    rl.close();
+
+    if (!apiBase || !modelId) {
+      console.log(`\n  ${FG_RED}✗${RST} ${FG_GRAY}API Base URL and Model ID are required.${RST}\n`);
+      return;
+    }
+
+    const config = getConfig();
+    const profile = {
+      api_base: apiBase,
+      api_key: apiKey || 'any',
+      model: modelId,
+    };
+
+    config.models.push(profile);
+    setActiveModelProfile(profile);
+    console.log(`\n  ${FG_GREEN}✓${RST} Saved model profile: ${describeModelProfile(profile)}\n`);
+  }
+
+  function cmdInit(opts) {
+    const current = getConfig();
+    const cfg = {
+      api_base: opts.apiBase || 'http://127.0.0.1:8800',
+      api_key: opts.apiKey || 'any',
+      default_model: opts.defaultModel || 'default',
+      temperature: 0.7,
+      request_timeout_ms: DEFAULT_API_TIMEOUT_MS,
+      stream: true,
+      models: current.models,
+    };
+    setConfig(cfg);
+    console.log(`\n  ${FG_GREEN}✓${RST} Config saved to ${CONFIG_PATH}`);
+    console.log(`  ${FG_GRAY}${JSON.stringify(cfg, null, 2)}${RST}\n`);
+  }
+
+  return {
+    cmdChat,
+    cmdCode,
+    cmdEdit,
+    cmdInit,
+    cmdModels,
+    cmdModelsAdd,
+    cmdShell,
+  };
+}
+
+module.exports = {
+  createCommands,
+};

package/lib/config.js

@@ -0,0 +1,46 @@
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+
+const { CONFIG_PATH, DEFAULT_CONFIG } = require('./constants');
+
+function normalizeConfig(cfg = {}) {
+  const merged = { ...DEFAULT_CONFIG, ...cfg };
+  merged.models = Array.isArray(cfg.models)
+    ? cfg.models
+        .filter((entry) => entry &&
+          typeof entry.api_base === 'string' &&
+          typeof entry.api_key === 'string' &&
+          typeof entry.model === 'string' &&
+          entry.api_base.trim() &&
+          entry.model.trim())
+        .map((entry) => ({
+          api_base: entry.api_base.trim(),
+          api_key: entry.api_key,
+          model: entry.model.trim(),
+        }))
+    : [];
+  return merged;
+}
+
+function loadConfig() {
+  if (fs.existsSync(CONFIG_PATH)) {
+    try {
+      const data = JSON.parse(fs.readFileSync(CONFIG_PATH, 'utf8'));
+      return normalizeConfig(data);
+    } catch {}
+  }
+  return normalizeConfig();
+}
+
+function saveConfig(cfg) {
+  fs.mkdirSync(path.dirname(CONFIG_PATH), { recursive: true });
+  fs.writeFileSync(CONFIG_PATH, JSON.stringify(normalizeConfig(cfg), null, 2));
+}
+
+module.exports = {
+  loadConfig,
+  normalizeConfig,
+  saveConfig,
+};

package/lib/constants.js

@@ -0,0 +1,27 @@
+'use strict';
+
+const os = require('os');
+const path = require('path');
+
+const PACKAGE_JSON = require('../package.json');
+
+const DEFAULT_API_TIMEOUT_MS = 15 * 60 * 1000;
+
+const DEFAULT_CONFIG = {
+  api_base: 'http://127.0.0.1:8800',
+  api_key: 'any',
+  default_model: 'default',
+  temperature: 0.7,
+  request_timeout_ms: DEFAULT_API_TIMEOUT_MS,
+  stream: true,
+  models: [],
+};
+
+const CONFIG_PATH = path.join(os.homedir(), '.semalt-ai', 'config.json');
+
+module.exports = {
+  CONFIG_PATH,
+  DEFAULT_API_TIMEOUT_MS,
+  DEFAULT_CONFIG,
+  PACKAGE_JSON,
+};

package/lib/context.js

@@ -0,0 +1,71 @@
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+
+function readFileContext(filePaths, ui) {
+  const { FG_GRAY, FG_GREEN, FG_RED, RST } = ui;
+  let context = '';
+
+  for (const fp of filePaths) {
+    if (!fs.existsSync(fp)) {
+      console.log(`  ${FG_RED}✗${RST} ${FG_GRAY}Not found: ${fp}${RST}`);
+      continue;
+    }
+
+    const stat = fs.statSync(fp);
+    if (stat.isFile()) {
+      try {
+        const content = fs.readFileSync(fp, 'utf8');
+        context += `\n--- File: ${fp} ---\n${content}\n`;
+        console.log(`  ${FG_GREEN}✓${RST} ${FG_GRAY}Loaded ${fp} (${content.length} chars)${RST}`);
+      } catch (error) {
+        console.log(`  ${FG_RED}✗${RST} ${FG_GRAY}${fp}: ${error.message}${RST}`);
+      }
+      continue;
+    }
+
+    if (stat.isDirectory()) {
+      let count = 0;
+      function walkDir(dir) {
+        if (count >= 50) return;
+        let entries;
+        try {
+          entries = fs.readdirSync(dir).sort();
+        } catch {
+          return;
+        }
+
+        for (const entry of entries) {
+          if (entry.startsWith('.')) continue;
+          const full = path.join(dir, entry);
+          let childStat;
+          try {
+            childStat = fs.statSync(full);
+          } catch {
+            continue;
+          }
+
+          if (childStat.isFile()) {
+            try {
+              const content = fs.readFileSync(full, 'utf8').slice(0, 10000);
+              context += `\n--- File: ${full} ---\n${content}\n`;
+              count++;
+            } catch {}
+          } else if (childStat.isDirectory()) {
+            walkDir(full);
+          }
+        }
+      }
+
+      walkDir(fp);
+      console.log(`  ${FG_GREEN}✓${RST} ${FG_GRAY}Loaded ${count} files from ${fp}${RST}`);
+    }
+  }
+
+  return context;
+}
+
+module.exports = {
+  readFileContext,
+};

package/lib/permissions.js

@@ -0,0 +1,93 @@
+'use strict';
+
+function createPermissionManager(ui) {
+  const { BOLD, FG_CYAN, FG_DARK, FG_GRAY, FG_GREEN, FG_RED, FG_YELLOW, RST, readInteractiveInput } = ui;
+  const state = {
+    autoApproveShell: false,
+    autoApproveFile: false,
+  };
+
+  function askPermissionLine(actionType) {
+    return actionType === 'shell'
+      ? '  1. Yes  2. Yes, always for shell  3. No'
+      : '  1. Yes  2. Yes, always for files  3. No';
+  }
+
+  function readPermissionChoice() {
+    return readInteractiveInput(`  ${FG_YELLOW}?${RST} `, {
+      allowed: ['1', '2', '3'],
+      immediate: true,
+      trim: true,
+    });
+  }
+
+  function askPermission(actionType, description) {
+    return new Promise((resolve) => {
+      if (actionType === 'shell' && state.autoApproveShell) {
+        console.log(`  ${FG_GREEN}✓${RST} ${FG_DARK}Auto-approved: ${description}${RST}`);
+        resolve(true);
+        return;
+      }
+
+      if (actionType === 'file' && state.autoApproveFile) {
+        console.log(`  ${FG_GREEN}✓${RST} ${FG_DARK}Auto-approved: ${description}${RST}`);
+        resolve(true);
+        return;
+      }
+
+      console.log();
+      console.log(`  ${FG_YELLOW}${BOLD}⚠ Permission required${RST}`);
+      console.log(`  ${FG_GRAY}${actionType}: ${description}${RST}`);
+      console.log();
+      console.log(`  ${FG_CYAN}${askPermissionLine(actionType)}${RST}`);
+      console.log();
+
+      readPermissionChoice().then((result) => {
+        if (result.type === 'sigint' || result.type === 'eof') {
+          console.log(`  ${FG_RED}✗${RST} ${FG_DARK}Denied${RST}`);
+          resolve(false);
+          return;
+        }
+
+        const choice = (result.value || '').trim().toLowerCase();
+        if (choice === '1' || choice === 'y' || choice === 'yes') {
+          resolve(true);
+          return;
+        }
+
+        if (choice === '2' || choice === 'a' || choice === 'always') {
+          if (actionType === 'shell') state.autoApproveShell = true;
+          else state.autoApproveFile = true;
+          console.log(`  ${FG_GREEN}✓${RST} ${FG_DARK}Auto-approve enabled for ${actionType} operations${RST}`);
+          resolve(true);
+          return;
+        }
+
+        console.log(`  ${FG_RED}✗${RST} ${FG_DARK}Denied${RST}`);
+        resolve(false);
+      });
+    });
+  }
+
+  function clear() {
+    state.autoApproveShell = false;
+    state.autoApproveFile = false;
+  }
+
+  function toggleAll() {
+    state.autoApproveShell = !state.autoApproveShell;
+    state.autoApproveFile = !state.autoApproveFile;
+    return state.autoApproveShell;
+  }
+
+  return {
+    askPermission,
+    clear,
+    state,
+    toggleAll,
+  };
+}
+
+module.exports = {
+  createPermissionManager,
+};

package/lib/prompts.js

@@ -0,0 +1,29 @@
+'use strict';
+
+function getSystemPrompt() {
+  return `You are Semalt.AI, an expert AI coding assistant running in the user's terminal. You have the ability to execute shell commands and file operations.
+
+IMPORTANT: You CAN execute commands on the user's system. When you need to run a command, use this exact format:
+
+To run a shell command:
+<exec>command here</exec>
+
+To read a file:
+<read_file>/path/to/file</read_file>
+
+To write a file:
+<write_file path="/path/to/file">file content here</write_file>
+
+Rules:
+- When the user asks you to do something on their system (create files, install packages, check status, etc.), USE the tools above — do NOT just print instructions.
+- Each command will be shown to the user for approval before execution.
+- After execution, you will receive the output and can continue working.
+- You can chain multiple operations in one response.
+- Be concise. Provide working solutions.
+- Use markdown for code blocks in explanations.
+- Current working directory: ${process.cwd()}`;
+}
+
+module.exports = {
+  getSystemPrompt,
+};