@novaqore/atom 0.0.1

package/src/screens/system.js

@@ -0,0 +1,175 @@
+import React from "react";
+import { release, arch, cpus, totalmem } from "node:os";
+import { Box, Text } from "ink";
+import SelectInput from "ink-select-input";
+import { Header } from "../components/Header.js";
+import { RUNTIMES } from "../utils/runtimes.js";
+import {
+  HOSTNAME,
+  USERNAME,
+  IS_ROOT,
+  DISK,
+  getGPUs,
+  getPackageManagers,
+} from "../utils/system.js";
+
+function Row({ label, value, color, dim }) {
+  const valueProps = dim
+    ? { dimColor: true }
+    : color
+      ? { color }
+      : null;
+  return React.createElement(
+    Box,
+    null,
+    React.createElement(
+      Box,
+      { width: 14 },
+      React.createElement(Text, { dimColor: true }, label)
+    ),
+    React.createElement(Text, valueProps, value)
+  );
+}
+
+function Section({ title, rows }) {
+  return React.createElement(
+    Box,
+    { flexDirection: "column", marginTop: 1 },
+    React.createElement(Text, { color: "cyan", bold: true }, title),
+    React.createElement(
+      Box,
+      { flexDirection: "column", paddingLeft: 2 },
+      rows
+    )
+  );
+}
+
+export function SystemScreen({ version, unhinged, onBack }) {
+  const platformStr = `${process.platform}/${arch()} (${release()})`;
+  const shell = (process.env.SHELL || "").split("/").pop() || "shell";
+  const cwd = process.cwd();
+
+  const gpus = getGPUs();
+  const pms = getPackageManagers();
+
+  const cpuList = cpus();
+  const cpuModel = cpuList?.[0]?.model?.trim() || "unknown";
+  const cpuCount = cpuList?.length || 0;
+  const cpuSpeed = cpuList?.[0]?.speed || 0;
+  const cpuStr = cpuSpeed
+    ? `${cpuCount} cores @ ${(cpuSpeed / 1000).toFixed(2)} GHz (${cpuModel})`
+    : `${cpuCount} cores (${cpuModel})`;
+  const ramStr = `${(totalmem() / 1024 ** 3).toFixed(1)} GB`;
+  const diskStr = DISK
+    ? `${(DISK.used / 1024 ** 3).toFixed(1)} GB used / ${(DISK.total / 1024 ** 3).toFixed(1)} GB total`
+    : "unknown";
+
+  const systemRows = [
+    React.createElement(Row, {
+      key: "host",
+      label: "Hostname:",
+      value: HOSTNAME,
+    }),
+    React.createElement(Row, {
+      key: "user",
+      label: "User:",
+      value: USERNAME + (IS_ROOT ? " (root)" : ""),
+      color: IS_ROOT ? "red" : undefined,
+    }),
+    React.createElement(Row, {
+      key: "platform",
+      label: "Platform:",
+      value: platformStr,
+    }),
+    React.createElement(Row, { key: "shell", label: "Shell:", value: shell }),
+    React.createElement(Row, {
+      key: "cwd",
+      label: "Working dir:",
+      value: cwd,
+    }),
+  ];
+
+  const pmRows = [];
+  if (pms.system.length > 0) {
+    pmRows.push(
+      React.createElement(Row, {
+        key: "pm-system",
+        label: "System:",
+        value: pms.system.join(", "),
+      })
+    );
+  }
+  if (pms.language.length > 0) {
+    pmRows.push(
+      React.createElement(Row, {
+        key: "pm-language",
+        label: "Language:",
+        value: pms.language.join(", "),
+      })
+    );
+  }
+  if (pms.container.length > 0) {
+    pmRows.push(
+      React.createElement(Row, {
+        key: "pm-container",
+        label: "Container:",
+        value: pms.container.join(", "),
+      })
+    );
+  }
+
+  const hardwareRows = [
+    React.createElement(Row, { key: "cpu", label: "CPU:", value: cpuStr }),
+    React.createElement(Row, { key: "mem", label: "Memory:", value: ramStr }),
+  ];
+  if (gpus.length > 0) {
+    hardwareRows.push(
+      React.createElement(Row, {
+        key: "gpu",
+        label: "GPU:",
+        value: gpus.join(", "),
+      })
+    );
+  }
+  if (DISK) {
+    hardwareRows.push(
+      React.createElement(Row, { key: "disk", label: "Disk:", value: diskStr })
+    );
+  }
+
+  const runtimeRows = Object.entries(RUNTIMES)
+    .filter(([, value]) => value !== "not installed")
+    .map(([key, value]) =>
+      React.createElement(Row, {
+        key,
+        label: `${key}:`,
+        value,
+        color: "green",
+      })
+    );
+
+  return React.createElement(
+    Box,
+    { flexDirection: "column", paddingBottom: 1 },
+    React.createElement(Header, { version, unhinged }),
+    React.createElement(
+      Box,
+      { flexDirection: "column", paddingX: 1 },
+      React.createElement(Section, { title: "System", rows: systemRows }),
+      React.createElement(Section, { title: "Hardware", rows: hardwareRows }),
+      React.createElement(Section, { title: "Runtimes", rows: runtimeRows }),
+      React.createElement(Section, {
+        title: "Package Managers",
+        rows: pmRows,
+      }),
+      React.createElement(
+        Box,
+        { marginTop: 1 },
+        React.createElement(SelectInput, {
+          items: [{ label: "Back", value: "back" }],
+          onSelect: onBack,
+        })
+      )
+    )
+  );
+}

package/src/screens/unhinged-warning.js

@@ -0,0 +1,45 @@
+import React from "react";
+import { Box, Text, useApp } from "ink";
+import SelectInput from "ink-select-input";
+
+const items = [
+  { label: "I understand, continue", value: true },
+  { label: "Cancel", value: false },
+];
+
+export function UnhingedWarningScreen({ onConfirm }) {
+  const { exit } = useApp();
+
+  return React.createElement(
+    Box,
+    { flexDirection: "column", paddingX: 1, paddingBottom: 1 },
+    React.createElement(Text, { color: "red", bold: true }, "UNHINGED MODE"),
+    React.createElement(
+      Box,
+      { marginTop: 1, flexDirection: "column", gap: 1 },
+      React.createElement(
+        Text,
+        null,
+        "Atom will run shell commands on this machine without asking for confirmation, including destructive ones like rm and sudo."
+      ),
+      React.createElement(
+        Text,
+        null,
+        "Best used on isolated environments such as AWS instances, DigitalOcean droplets, or disposable containers."
+      ),
+      React.createElement(
+        Text,
+        { dimColor: true },
+        "Do not run on a personal machine with important files, production systems, or anywhere with credentials you care about."
+      )
+    ),
+    React.createElement(
+      Box,
+      { marginTop: 1 },
+      React.createElement(SelectInput, {
+        items,
+        onSelect: (item) => (item.value ? onConfirm() : exit()),
+      })
+    )
+  );
+}

package/src/setup.js

@@ -0,0 +1,3 @@
+if (!process.env.FORCE_COLOR) {
+  process.env.FORCE_COLOR = "3";
+}

package/src/tools/bash/tool.js

@@ -0,0 +1,74 @@
+import { exec } from "node:child_process";
+import { promisify } from "node:util";
+
+const execAsync = promisify(exec);
+const PWD_MARKER = "__ATOM_PWD_MARKER__";
+
+const DANGEROUS = ["rm"];
+
+function isDangerous(command) {
+  return DANGEROUS.some((word) => new RegExp(`\\b${word}\\b`).test(command));
+}
+
+function parsePwd(text) {
+  const idx = text.lastIndexOf(PWD_MARKER);
+  if (idx === -1) return { output: text, newCwd: null };
+  const newCwd = text.slice(idx + PWD_MARKER.length).trim();
+  const output = text.slice(0, idx);
+  return { output, newCwd };
+}
+
+export default {
+  definition: {
+    type: "function",
+    function: {
+      name: "bash",
+      description:
+        "Execute a bash command on the user's machine to fulfill a request that requires running code, inspecting files, or interacting with the system. Only use this when the user is asking you to do something that genuinely needs a shell command. Never use it to greet, chat, echo a message, or produce conversational output. Talk to the user directly with a normal text response instead.",
+      parameters: {
+        type: "object",
+        properties: {
+          command: {
+            type: "string",
+            description: "The bash command to execute",
+          },
+        },
+        required: ["command"],
+      },
+    },
+  },
+  execute: async ({ command }, { askConfirm, unhinged, cwd, setCwd } = {}) => {
+    if (!unhinged && isDangerous(command) && askConfirm) {
+      const ok = await askConfirm(command);
+      if (!ok)
+        return "The user rejected this command and does not want it to run. Do not retry it or try a workaround. Acknowledge the rejection and ask the user what they would like to do instead.";
+    }
+
+    const startDir = cwd || process.cwd();
+    const wrapped = `${command}\nprintf '%s%s' '${PWD_MARKER}' "$(pwd)"`;
+
+    try {
+      const { stdout = "", stderr = "" } = await execAsync(wrapped, {
+        cwd: startDir,
+      });
+      const { output: cleanStdout, newCwd } = parsePwd(stdout);
+      if (newCwd && setCwd) setCwd(newCwd);
+      return [cleanStdout.trimEnd(), stderr.trimEnd()]
+        .filter(Boolean)
+        .join("\n")
+        .replace(/\s+$/, "");
+    } catch (err) {
+      const stdout = err.stdout || "";
+      const stderr = err.stderr || "";
+      const { output: cleanStdout, newCwd } = parsePwd(stdout);
+      if (newCwd && setCwd) setCwd(newCwd);
+      const body = [cleanStdout.trimEnd(), stderr.trimEnd()]
+        .filter(Boolean)
+        .join("\n");
+      return `Error (exit ${err.code ?? "?"}): ${err.message}\n${body}`.replace(
+        /\s+$/,
+        ""
+      );
+    }
+  },
+};

package/src/tools/index.js

@@ -0,0 +1,30 @@
+import { readdirSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { fileURLToPath, pathToFileURL } from "node:url";
+
+const here = dirname(fileURLToPath(import.meta.url));
+
+const folders = readdirSync(here, { withFileTypes: true })
+  .filter((d) => d.isDirectory())
+  .map((d) => d.name);
+
+const registry = {};
+for (const folder of folders) {
+  const mod = await import(pathToFileURL(join(here, folder, "tool.js")).href);
+  const tool = mod.default;
+  registry[tool.definition.function.name] = tool;
+}
+
+export const tools = Object.values(registry).map((t) => t.definition);
+
+export async function executeTool(name, rawArgs, context = {}) {
+  const tool = registry[name];
+  if (!tool) return `Error: unknown tool "${name}"`;
+  let args;
+  try {
+    args = typeof rawArgs === "string" ? JSON.parse(rawArgs || "{}") : rawArgs || {};
+  } catch (err) {
+    return `Error: invalid arguments JSON: ${err.message}`;
+  }
+  return tool.execute(args, context);
+}

package/src/utils/exec.js

@@ -0,0 +1,13 @@
+import { execSync } from "node:child_process";
+
+export function tryRun(cmd, timeout = 1500) {
+  try {
+    return execSync(cmd, {
+      encoding: "utf8",
+      stdio: ["ignore", "pipe", "pipe"],
+      timeout,
+    }).trim();
+  } catch {
+    return null;
+  }
+}

package/src/utils/markdown.js

@@ -0,0 +1,47 @@
+import { marked } from "marked";
+import { markedTerminal } from "marked-terminal";
+import chalk from "chalk";
+
+const ext = markedTerminal({
+  codespan: chalk.bold.white,
+  text: chalk.white,
+});
+
+// Patch: marked-terminal v7's text renderer ignores nested inline tokens
+// (codespan, strong, em, link, etc.) when they appear inside list items.
+// Force it to parse them inline so styling works in lists too.
+const origText = ext.renderer.text;
+ext.renderer.text = function (token) {
+  if (
+    typeof token === "object" &&
+    Array.isArray(token.tokens) &&
+    token.tokens.length > 0
+  ) {
+    return this.parser.parseInline(token.tokens);
+  }
+  return origText.call(this, token);
+};
+
+marked.use(ext);
+
+function balanceForStreaming(buffer) {
+  let out = buffer;
+
+  const fences = (out.match(/```/g) || []).length;
+  if (fences % 2 === 1) out += "\n```";
+
+  const bolds = (out.match(/\*\*/g) || []).length;
+  if (bolds % 2 === 1) out += "**";
+
+  const stripped = out.replace(/```[\s\S]*?```/g, "");
+  const ticks = (stripped.match(/`/g) || []).length;
+  if (ticks % 2 === 1) out += "`";
+
+  return out;
+}
+
+export function renderMarkdown(text, { streaming = false } = {}) {
+  if (!text) return "";
+  const input = streaming ? balanceForStreaming(text) : text;
+  return marked.parse(input).trim();
+}

package/src/utils/paths.js

@@ -0,0 +1,5 @@
+import { homedir } from "node:os";
+import { join } from "node:path";
+
+export const ATOM_DIR = join(homedir(), ".atom");
+export const SERVICE_FILE = join(ATOM_DIR, "novaqore-ai-service.json");

package/src/utils/runtimes.js

@@ -0,0 +1,70 @@
+import { tryRun } from "./exec.js";
+
+function detectVersion(cmd, regex) {
+  const out = tryRun(cmd);
+  if (!out) return "not installed";
+  const match = out.match(regex);
+  return match ? match[1] : "not installed";
+}
+
+function detectPython() {
+  const v = detectVersion("python3 --version 2>&1", /Python\s+(\S+)/i);
+  if (v !== "not installed") return v;
+  return detectVersion("python --version 2>&1", /Python\s+(\S+)/i);
+}
+
+const lazySpecs = {
+  ruby: ["ruby --version 2>&1", /ruby\s+(\S+)/i],
+  go: ["go version 2>&1", /go(\d[\d.]+)/i],
+  rust: ["rustc --version 2>&1", /rustc\s+(\S+)/i],
+  java: ["java -version 2>&1", /version\s+"([^"]+)"/i],
+  php: ["php --version 2>&1", /PHP\s+(\S+)/i],
+  deno: ["deno --version 2>&1", /deno\s+(\S+)/i],
+  bun: ["bun --version 2>&1", /(\S+)/],
+};
+
+const cache = {
+  node: process.version,
+  python: detectPython(),
+};
+
+function readKey(key) {
+  if (key in cache) return cache[key];
+  if (key in lazySpecs) {
+    const [cmd, regex] = lazySpecs[key];
+    cache[key] = detectVersion(cmd, regex);
+    return cache[key];
+  }
+  return undefined;
+}
+
+const allKeys = ["node", "python", ...Object.keys(lazySpecs)];
+
+export function peekRuntimes() {
+  return { ...cache };
+}
+
+export const RUNTIMES = new Proxy(
+  {},
+  {
+    get(_t, prop) {
+      return readKey(prop);
+    },
+    has(_t, prop) {
+      return allKeys.includes(prop);
+    },
+    ownKeys() {
+      return allKeys;
+    },
+    getOwnPropertyDescriptor(_t, prop) {
+      if (allKeys.includes(prop)) {
+        return {
+          enumerable: true,
+          configurable: true,
+          value: readKey(prop),
+        };
+      }
+      return undefined;
+    },
+  }
+);

package/src/utils/system-prompt.js

@@ -0,0 +1,89 @@
+import { release, arch, cpus, totalmem } from "node:os";
+import { peekRuntimes } from "./runtimes.js";
+import {
+  HOSTNAME,
+  USERNAME,
+  IS_ROOT,
+  DISK,
+  peekGPUs,
+  peekPackageManagers,
+} from "./system.js";
+
+function cpuLine() {
+  const list = cpus();
+  if (!list || list.length === 0) return "CPU: unknown";
+  const model = list[0].model.trim();
+  const speed = list[0].speed;
+  if (!speed) return `CPU: ${list.length} cores (${model})`;
+  return `CPU: ${list.length} cores @ ${(speed / 1000).toFixed(2)} GHz (${model})`;
+}
+
+function memoryLine() {
+  const gb = totalmem() / 1024 ** 3;
+  return `Memory: ${gb.toFixed(1)} GB`;
+}
+
+function diskLine() {
+  if (!DISK) return null;
+  const totalGB = (DISK.total / 1024 ** 3).toFixed(1);
+  const usedGB = (DISK.used / 1024 ** 3).toFixed(1);
+  return `Disk: ${usedGB} GB used / ${totalGB} GB total`;
+}
+
+function gpuLine() {
+  const gpus = peekGPUs();
+  if (gpus === null) return null;
+  if (gpus.length === 0) return null;
+  return `GPU: ${gpus.join(", ")}`;
+}
+
+function runtimesLine() {
+  const cached = peekRuntimes();
+  const installed = Object.entries(cached)
+    .filter(([, v]) => v && v !== "not installed")
+    .map(([k, v]) => `${k} ${v}`);
+  if (installed.length === 0) return null;
+  return `Runtimes: ${installed.join(", ")}`;
+}
+
+function packageManagerLines() {
+  const pms = peekPackageManagers();
+  if (pms === null) return [];
+  const out = [];
+  if (pms.system.length > 0)
+    out.push(`Package managers (system): ${pms.system.join(", ")}`);
+  if (pms.language.length > 0)
+    out.push(`Package managers (language): ${pms.language.join(", ")}`);
+  if (pms.container.length > 0)
+    out.push(`Package managers (container): ${pms.container.join(", ")}`);
+  return out;
+}
+
+export function buildSystemPrompt() {
+  const env = [
+    `Hostname: ${HOSTNAME}`,
+    `User: ${USERNAME}${IS_ROOT ? " (root)" : ""}`,
+    `Platform: ${process.platform} (${release()}, ${arch()})`,
+    `Shell: ${process.env.SHELL || "unknown"}`,
+    `Working directory: ${process.cwd()}`,
+    cpuLine(),
+    memoryLine(),
+    diskLine(),
+    gpuLine(),
+    runtimesLine(),
+    ...packageManagerLines(),
+  ]
+    .filter(Boolean)
+    .join("\n");
+
+  return `You are Atom, a full-system code agent. You run on the server you are operating (typically an isolated server or VM), with shell access at the system level. You can read, write, and execute anywhere your process has permission, including system paths and service configuration.
+
+You help with software engineering tasks across the whole machine: writing and debugging code, refactoring, explaining unfamiliar code, reviewing changes, configuring services, and operating on system files when the user asks. You favor clear, idiomatic solutions over clever ones, and you keep your responses concise.
+
+You have access to tools when they help you complete a task. Use them when running a command or inspecting the environment is the most direct way to answer.
+
+Always use structured sentences. Do not use em dashes or dashes in your writing.
+
+Environment:
+${env}`;
+}

package/src/utils/system.js

@@ -0,0 +1,106 @@
+import { hostname, userInfo } from "node:os";
+import { tryRun } from "./exec.js";
+
+export const HOSTNAME = hostname();
+export const USERNAME = userInfo().username;
+export const IS_ROOT =
+  typeof process.getuid === "function" && process.getuid() === 0;
+
+function detectGPUs() {
+  if (process.platform === "darwin") {
+    const out = tryRun("system_profiler SPDisplaysDataType 2>/dev/null", 4000);
+    if (!out) return [];
+    return [...out.matchAll(/^\s*Chipset Model:\s+(.+)$/gm)].map((m) =>
+      m[1].trim()
+    );
+  }
+  if (process.platform === "linux") {
+    const nvidia = tryRun(
+      "nvidia-smi --query-gpu=name --format=csv,noheader 2>/dev/null",
+      2000
+    );
+    if (nvidia) {
+      return nvidia
+        .split("\n")
+        .map((s) => s.trim())
+        .filter(Boolean);
+    }
+    const lspci = tryRun("lspci 2>/dev/null", 1500);
+    if (!lspci) return [];
+    return lspci
+      .split("\n")
+      .filter((l) => /VGA|3D controller|Display controller/i.test(l))
+      .map((l) => {
+        const m = l.match(
+          /(?:VGA compatible controller|3D controller|Display controller):\s+(.+)/i
+        );
+        return m ? m[1].trim() : l;
+      });
+  }
+  return [];
+}
+
+let _gpus = null;
+export function getGPUs() {
+  if (_gpus === null) _gpus = detectGPUs();
+  return _gpus;
+}
+export function peekGPUs() {
+  return _gpus;
+}
+
+const PM_GROUPS = {
+  system: ["apt", "apt-get", "dnf", "yum", "pacman", "apk", "brew", "zypper"],
+  language: [
+    "npm",
+    "pnpm",
+    "yarn",
+    "pip3",
+    "pip",
+    "pipx",
+    "poetry",
+    "gem",
+    "bundler",
+    "cargo",
+    "composer",
+    "maven",
+    "gradle",
+  ],
+  container: ["docker", "podman"],
+};
+
+function detectInGroup(group) {
+  return group.filter((pm) => tryRun(`command -v ${pm}`));
+}
+
+let _pms = null;
+export function getPackageManagers() {
+  if (_pms === null) {
+    _pms = {
+      system: detectInGroup(PM_GROUPS.system),
+      language: detectInGroup(PM_GROUPS.language),
+      container: detectInGroup(PM_GROUPS.container),
+    };
+  }
+  return _pms;
+}
+export function peekPackageManagers() {
+  return _pms;
+}
+
+function detectDisk() {
+  const out = tryRun("df -kP .");
+  if (!out) return null;
+  const lines = out.split("\n");
+  if (lines.length < 2) return null;
+  const fields = lines[lines.length - 1].split(/\s+/);
+  const totalKB = parseInt(fields[1], 10);
+  const usedKB = parseInt(fields[2], 10);
+  if (isNaN(totalKB) || isNaN(usedKB)) return null;
+  return {
+    total: totalKB * 1024,
+    used: usedKB * 1024,
+  };
+}
+
+export const DISK = detectDisk();