novaprime 1.0.0

package/README.md

@@ -0,0 +1,47 @@
+# NovaPrime
+
+An AI coding assistant that lives in your terminal — read, write and edit files and run commands, powered by GLM through your NovaPrime server.
+
+## Install
+
+```bash
+npm install -g novaprime
+```
+
+## First run
+
+```bash
+novaprime login
+```
+
+Paste the **novaprime-key** your administrator gave you. It is saved locally to `~/.novaprime/config.json` and never shared with anyone but your NovaPrime server.
+
+## Use
+
+```bash
+novaprime                 # start an interactive session
+novaprime "fix the bug in app.js"   # run a single task
+```
+
+In a session:
+
+| Command | What it does |
+|---------|--------------|
+| `/help` | show help |
+| `/clear` | start a new conversation |
+| `/exit` | quit (Ctrl+C also works) |
+
+NovaPrime works in your **current folder**. Before it writes a file, edits a file, or runs a shell command, it shows you exactly what it will do and asks for permission.
+
+## Other commands
+
+```bash
+novaprime logout          # remove your saved key
+novaprime --version
+novaprime --help
+```
+
+## Privacy & safety
+
+- Your key only talks to your NovaPrime server; the underlying AI provider key never touches your machine.
+- File writes, edits and shell commands always require your confirmation.

package/bin/novaprime.js

@@ -0,0 +1,95 @@
+#!/usr/bin/env node
+'use strict';
+const prompts = require('prompts');
+const config = require('../src/config');
+const ui = require('../src/ui');
+const { c } = ui;
+const { runTurn } = require('../src/agent');
+
+const pkg = require('../package.json');
+
+async function doLogin() {
+  console.log(c.brand.bold('\nNovaPrime login'));
+  ui.info('Paste the novaprime-key your administrator gave you.');
+  const ans = await prompts([
+    { type: 'password', name: 'key', message: 'novaprime-key' },
+    { type: 'text', name: 'server', message: 'Server URL', initial: config.getServer() },
+  ]);
+  if (!ans.key) { ui.error('No key entered. Login cancelled.'); process.exit(1); }
+  const cfg = config.load();
+  cfg.key = ans.key.trim();
+  if (ans.server && ans.server.trim()) cfg.server = ans.server.trim();
+  config.save(cfg);
+  ui.ok('Saved to ' + config.FILE);
+}
+
+async function ensureKey() {
+  const cfg = config.load();
+  if (cfg.key) return cfg;
+  ui.warn('No novaprime-key found. Let\'s set it up.');
+  await doLogin();
+  return config.load();
+}
+
+function printHelp() {
+  console.log(`
+${c.brand.bold('novaprime')} ${c.muted('— AI coding assistant in your terminal')}
+
+${c.bold('Usage:')}
+  novaprime              start an interactive session
+  novaprime "task..."    run a single task and exit
+  novaprime login        save or change your novaprime-key
+  novaprime logout       remove your saved key
+  novaprime --version    show version
+  novaprime --help       show this help
+
+${c.bold('In a session:')}
+  /help    show help        /clear   start a new conversation
+  /exit    quit             (Ctrl+C also quits)
+`);
+}
+
+async function repl() {
+  const cfg = await ensureKey();
+  ui.banner();
+  let messages = [];
+  // graceful Ctrl+C
+  process.on('SIGINT', () => { console.log(c.muted('\nbye 👋')); process.exit(0); });
+
+  while (true) {
+    const ans = await prompts({ type: 'text', name: 'msg', message: ui.youLabel() });
+    const input = (ans.msg || '').trim();
+    if (ans.msg === undefined) { console.log(c.muted('bye 👋')); break; } // Ctrl+C / EOF
+    if (!input) continue;
+    if (input === '/exit' || input === '/quit') { console.log(c.muted('bye 👋')); break; }
+    if (input === '/help') { printHelp(); continue; }
+    if (input === '/clear') { messages = []; ui.ok('Started a new conversation.'); continue; }
+
+    messages.push({ role: 'user', content: input });
+    try {
+      await runTurn(cfg.server || config.getServer(), cfg.key, messages);
+    } catch (err) {
+      ui.error(err.message);
+    }
+  }
+}
+
+async function oneShot(task) {
+  const cfg = await ensureKey();
+  const messages = [{ role: 'user', content: task }];
+  await runTurn(cfg.server || config.getServer(), cfg.key, messages);
+}
+
+async function main() {
+  const args = process.argv.slice(2);
+  const cmd = args[0];
+
+  if (cmd === '--version' || cmd === '-v') return console.log(pkg.version);
+  if (cmd === '--help' || cmd === '-h' || cmd === 'help') return printHelp();
+  if (cmd === 'login') return doLogin();
+  if (cmd === 'logout') { config.clear(); return ui.ok('Logged out (key removed).'); }
+  if (cmd && !cmd.startsWith('-')) return oneShot(args.join(' '));
+  return repl();
+}
+
+main().catch((err) => { ui.error(err.message); process.exit(1); });

package/package.json

@@ -0,0 +1,24 @@
+{
+  "name": "novaprime",
+  "version": "1.0.0",
+  "description": "NovaPrime — an AI coding assistant in your terminal, powered by GLM.",
+  "bin": {
+    "novaprime": "bin/novaprime.js"
+  },
+  "files": [
+    "bin/",
+    "src/",
+    "README.md"
+  ],
+  "engines": {
+    "node": ">=18"
+  },
+  "keywords": ["ai", "cli", "coding", "assistant", "glm", "novaprime"],
+  "license": "MIT",
+  "dependencies": {
+    "boxen": "^5.1.2",
+    "chalk": "^4.1.2",
+    "ora": "^5.4.1",
+    "prompts": "^2.4.2"
+  }
+}

package/src/agent.js

@@ -0,0 +1,113 @@
+'use strict';
+const os = require('os');
+const tools = require('./tools');
+const { c, aiLabel, error } = require('./ui');
+
+const SYSTEM_PROMPT =
+  `You are NovaPrime, an AI coding assistant running inside the user's terminal. ` +
+  `You help with coding, files, databases (e.g. MySQL/XAMPP) and shell tasks. ` +
+  `You can read, write and edit files and run shell commands using the provided tools, ` +
+  `all relative to the user's current working directory. ` +
+  `Always prefer making concrete changes with tools over only describing them. ` +
+  `Be concise and clear. Current OS: ${os.platform()}. Working directory: ${process.cwd()}.`;
+
+// Parse the SSE stream from the server, print text live, and reconstruct content blocks.
+async function streamMessage(server, key, messages) {
+  const res = await fetch(server.replace(/\/$/, '') + '/v1/messages', {
+    method: 'POST',
+    headers: { 'content-type': 'application/json', 'x-novaprime-key': key },
+    body: JSON.stringify({
+      max_tokens: 4096,
+      system: SYSTEM_PROMPT,
+      tools: tools.definitions,
+      messages,
+      stream: true,
+    }),
+  });
+
+  if (!res.ok) {
+    let msg = `Server error (HTTP ${res.status}).`;
+    try {
+      const j = await res.json();
+      if (j && j.error && j.error.message) msg = j.error.message;
+    } catch (_) {}
+    return { error: msg };
+  }
+
+  const blocks = [];
+  let stopReason = null;
+  let printedAi = false;
+  let buffer = '';
+  const decoder = new TextDecoder();
+  const reader = res.body.getReader();
+
+  while (true) {
+    const { done, value } = await reader.read();
+    if (done) break;
+    buffer += decoder.decode(value, { stream: true });
+    let idx;
+    while ((idx = buffer.indexOf('\n\n')) !== -1) {
+      const evt = buffer.slice(0, idx);
+      buffer = buffer.slice(idx + 2);
+      const dataLine = evt.split('\n').find((l) => l.startsWith('data:'));
+      if (!dataLine) continue;
+      let json;
+      try { json = JSON.parse(dataLine.slice(5).trim()); } catch (_) { continue; }
+
+      if (json.type === 'content_block_start') {
+        blocks[json.index] = json.content_block.type === 'tool_use'
+          ? { type: 'tool_use', id: json.content_block.id, name: json.content_block.name, _json: '' }
+          : { type: 'text', text: '' };
+      } else if (json.type === 'content_block_delta') {
+        const b = blocks[json.index];
+        if (!b) continue;
+        if (json.delta.type === 'text_delta') {
+          if (!printedAi) { aiLabel(); printedAi = true; }
+          process.stdout.write(json.delta.text);
+          b.text += json.delta.text;
+        } else if (json.delta.type === 'input_json_delta') {
+          b._json += json.delta.partial_json;
+        }
+      } else if (json.type === 'message_delta') {
+        if (json.delta && json.delta.stop_reason) stopReason = json.delta.stop_reason;
+      }
+    }
+  }
+  if (printedAi) process.stdout.write('\n');
+
+  // finalize tool_use inputs
+  const content = blocks.filter(Boolean).map((b) => {
+    if (b.type === 'tool_use') {
+      let input = {};
+      try { input = b._json ? JSON.parse(b._json) : {}; } catch (_) {}
+      return { type: 'tool_use', id: b.id, name: b.name, input };
+    }
+    return { type: 'text', text: b.text };
+  });
+
+  return { content, stopReason };
+}
+
+// One full turn: keep calling the model until it stops needing tools.
+async function runTurn(server, key, messages) {
+  while (true) {
+    const result = await streamMessage(server, key, messages);
+    if (result.error) { error(result.error); return; }
+
+    messages.push({ role: 'assistant', content: result.content });
+
+    const toolUses = result.content.filter((b) => b.type === 'tool_use');
+    if (result.stopReason === 'tool_use' && toolUses.length) {
+      const toolResults = [];
+      for (const tu of toolUses) {
+        const out = await tools.execute(tu.name, tu.input);
+        toolResults.push({ type: 'tool_result', tool_use_id: tu.id, content: out });
+      }
+      messages.push({ role: 'user', content: toolResults });
+      continue; // let the model react to the tool results
+    }
+    return; // done
+  }
+}
+
+module.exports = { runTurn, SYSTEM_PROMPT };

package/src/config.js

@@ -0,0 +1,31 @@
+'use strict';
+const os = require('os');
+const path = require('path');
+const fs = require('fs');
+
+const DEFAULT_SERVER = 'https://novaprime.fragzonebd.com';
+const DIR = path.join(os.homedir(), '.novaprime');
+const FILE = path.join(DIR, 'config.json');
+
+function load() {
+  try {
+    return JSON.parse(fs.readFileSync(FILE, 'utf8'));
+  } catch (_) {
+    return {};
+  }
+}
+
+function save(cfg) {
+  fs.mkdirSync(DIR, { recursive: true });
+  fs.writeFileSync(FILE, JSON.stringify(cfg, null, 2), { mode: 0o600 });
+}
+
+function clear() {
+  try { fs.unlinkSync(FILE); } catch (_) {}
+}
+
+function getServer() {
+  return load().server || DEFAULT_SERVER;
+}
+
+module.exports = { load, save, clear, getServer, FILE, DIR, DEFAULT_SERVER };

package/src/tools.js

@@ -0,0 +1,131 @@
+'use strict';
+const fs = require('fs');
+const path = require('path');
+const { spawnSync } = require('child_process');
+const prompts = require('prompts');
+const { c, tool, warn } = require('./ui');
+
+const MAX_OUTPUT = 20000; // cap tool output sent back to the model
+
+// ---- Tool definitions (Anthropic tool-use format) ----
+const definitions = [
+  {
+    name: 'read_file',
+    description: 'Read the contents of a text file in the current project.',
+    input_schema: {
+      type: 'object',
+      properties: { path: { type: 'string', description: 'Relative or absolute file path' } },
+      required: ['path'],
+    },
+  },
+  {
+    name: 'list_files',
+    description: 'List files and folders in a directory (default: current directory).',
+    input_schema: {
+      type: 'object',
+      properties: { path: { type: 'string', description: 'Directory path (default ".")' } },
+    },
+  },
+  {
+    name: 'write_file',
+    description: 'Create a new file or overwrite an existing file with the given content.',
+    input_schema: {
+      type: 'object',
+      properties: {
+        path: { type: 'string' },
+        content: { type: 'string' },
+      },
+      required: ['path', 'content'],
+    },
+  },
+  {
+    name: 'edit_file',
+    description: 'Replace an exact piece of text in a file with new text. old_string must match exactly once.',
+    input_schema: {
+      type: 'object',
+      properties: {
+        path: { type: 'string' },
+        old_string: { type: 'string' },
+        new_string: { type: 'string' },
+      },
+      required: ['path', 'old_string', 'new_string'],
+    },
+  },
+  {
+    name: 'run_command',
+    description: 'Run a shell command in the current directory (e.g. for git, npm, mysql). Always asks the user for permission first.',
+    input_schema: {
+      type: 'object',
+      properties: { command: { type: 'string' } },
+      required: ['command'],
+    },
+  },
+];
+
+function clip(s) {
+  if (s.length > MAX_OUTPUT) return s.slice(0, MAX_OUTPUT) + `\n...[truncated ${s.length - MAX_OUTPUT} chars]`;
+  return s;
+}
+
+async function confirm(message) {
+  const res = await prompts({
+    type: 'confirm',
+    name: 'ok',
+    message,
+    initial: false,
+  });
+  return res.ok === true;
+}
+
+// ---- Executors ----
+async function execute(name, input) {
+  try {
+    switch (name) {
+      case 'read_file': {
+        tool('read', input.path);
+        const data = fs.readFileSync(input.path, 'utf8');
+        return clip(data);
+      }
+      case 'list_files': {
+        const dir = input.path || '.';
+        tool('list', dir);
+        const items = fs.readdirSync(dir, { withFileTypes: true })
+          .map((d) => (d.isDirectory() ? d.name + '/' : d.name));
+        return items.join('\n') || '(empty)';
+      }
+      case 'write_file': {
+        console.log(c.warn('\n  ✎ write file: ') + c.bold(input.path) +
+          c.muted(`  (${(input.content || '').length} chars)`));
+        if (!(await confirm('Allow writing this file?'))) return 'DENIED: user did not allow writing the file.';
+        fs.mkdirSync(path.dirname(path.resolve(input.path)), { recursive: true });
+        fs.writeFileSync(input.path, input.content);
+        return 'OK: wrote ' + input.path;
+      }
+      case 'edit_file': {
+        const before = fs.readFileSync(input.path, 'utf8');
+        const count = before.split(input.old_string).length - 1;
+        if (count === 0) return 'ERROR: old_string not found in ' + input.path;
+        if (count > 1) return `ERROR: old_string matches ${count} times; make it more specific.`;
+        console.log(c.warn('\n  ✎ edit file: ') + c.bold(input.path));
+        console.log(c.danger('  - ' + input.old_string.split('\n').join('\n  - ')));
+        console.log(c.accent('  + ' + input.new_string.split('\n').join('\n  + ')));
+        if (!(await confirm('Allow this edit?'))) return 'DENIED: user did not allow the edit.';
+        fs.writeFileSync(input.path, before.replace(input.old_string, input.new_string));
+        return 'OK: edited ' + input.path;
+      }
+      case 'run_command': {
+        console.log(c.warn('\n  $ ') + c.bold(input.command));
+        if (!(await confirm('Run this command?'))) return 'DENIED: user did not allow running the command.';
+        const r = spawnSync(input.command, { shell: true, encoding: 'utf8', timeout: 1000 * 120 });
+        const out = (r.stdout || '') + (r.stderr || '');
+        return clip(`exit_code=${r.status}\n${out}`.trim());
+      }
+      default:
+        return 'ERROR: unknown tool ' + name;
+    }
+  } catch (err) {
+    return 'ERROR: ' + err.message;
+  }
+}
+
+module.exports = { definitions, execute };

package/src/ui.js

@@ -0,0 +1,34 @@
+'use strict';
+const chalk = require('chalk');
+const boxen = require('boxen');
+
+const c = {
+  brand: chalk.hex('#6d8bff'),
+  accent: chalk.hex('#46d39a'),
+  warn: chalk.hex('#ffb454'),
+  danger: chalk.hex('#ff6b6b'),
+  muted: chalk.gray,
+  bold: chalk.bold,
+};
+
+function banner() {
+  const title = c.brand.bold('NovaPrime') + c.muted('  · AI coding assistant');
+  console.log(
+    boxen(title + '\n' + c.muted('Type your task. /help for commands, /exit to quit.'), {
+      padding: { top: 0, bottom: 0, left: 1, right: 1 },
+      margin: { top: 1, bottom: 1, left: 0, right: 0 },
+      borderStyle: 'round',
+      borderColor: '#6d8bff',
+    })
+  );
+}
+
+function aiLabel() { process.stdout.write(c.accent('\n● novaprime  ')); }
+function youLabel() { return c.brand('❯ '); }
+function info(msg) { console.log(c.muted(msg)); }
+function warn(msg) { console.log(c.warn('⚠ ' + msg)); }
+function error(msg) { console.log(c.danger('✖ ' + msg)); }
+function ok(msg) { console.log(c.accent('✔ ' + msg)); }
+function tool(name, detail) { console.log(c.muted('  ⚙ ' + name + (detail ? '  ' + detail : ''))); }
+
+module.exports = { chalk, boxen, c, banner, aiLabel, youLabel, info, warn, error, ok, tool };