@novaqore/atom 0.0.1

package/src/screens/chat.js

@@ -0,0 +1,371 @@
+import React, { useState, useEffect, useRef } from "react";
+import { Box, Text, useInput } from "ink";
+import NovaQoreAI from "@novaqore/ai";
+import { SERVICE_FILE } from "../utils/paths.js";
+import { tools, executeTool } from "../tools/index.js";
+import { buildSystemPrompt } from "../utils/system-prompt.js";
+import { ChatInput } from "../components/Chat/ChatInput.js";
+import { ConfirmDangerousCommand } from "../components/Chat/ConfirmDangerousCommand.js";
+import { Header } from "../components/Header.js";
+import { renderMarkdown } from "../utils/markdown.js";
+
+export function ChatScreen({ version, unhinged }) {
+  const [nq] = useState(() => new NovaQoreAI(SERVICE_FILE));
+  const [messages, setMessages] = useState([]);
+  const [input, setInput] = useState("");
+  const [streaming, setStreaming] = useState("");
+  const [streamingTools, setStreamingTools] = useState([]);
+  const [sending, setSending] = useState(false);
+  const [error, setError] = useState(null);
+  const [confirm, setConfirm] = useState(null);
+  const [usage, setUsage] = useState({ prompt: 0, completion: 0, total: 0 });
+  const [cwd, setCwd] = useState(process.cwd());
+  const [running, setRunning] = useState(null);
+  const [durations, setDurations] = useState({});
+  const stopRef = useRef(null);
+
+  const toApiMessage = (m) => {
+    if (m.role === "tool") {
+      return {
+        role: "tool",
+        tool_call_id: m.tool_call_id,
+        content: m.content,
+      };
+    }
+    return m;
+  };
+
+  useEffect(() => {
+    if (!running) return;
+    const id = setInterval(() => {
+      setRunning((r) => (r ? { ...r, elapsed: Date.now() - r.start } : null));
+    }, 100);
+    return () => clearInterval(id);
+  }, [running?.id]);
+
+  useInput((_input, key) => {
+    if (key.escape && sending && stopRef.current) {
+      const stop = stopRef.current;
+      stopRef.current = null;
+      stop();
+    }
+  });
+
+  const askConfirm = (command) =>
+    new Promise((resolve) => setConfirm({ command, resolve }));
+
+  const handleSubmit = async (text) => {
+    if (!text.trim() || sending) return;
+
+    let convo = [...messages, { role: "user", content: text }];
+    setMessages(convo);
+    setInput("");
+    setSending(true);
+    setError(null);
+
+    let acc = "";
+    let toolCalls = [];
+
+    try {
+      while (true) {
+        setStreaming("");
+        setStreamingTools([]);
+
+        const { stream, stop } = await nq.chat(
+          [
+            { role: "system", content: buildSystemPrompt() },
+            ...convo.map(toApiMessage),
+          ],
+          { stream: true, tools }
+        );
+        stopRef.current = stop;
+
+        acc = "";
+        toolCalls = [];
+        for await (const chunk of stream) {
+          if (chunk.timings) {
+            const t = chunk.timings;
+            const promptTokens = (t.cache_n || 0) + (t.prompt_n || 0);
+            const completionTokens = t.predicted_n || 0;
+            setUsage((prev) => ({
+              prompt: prev.prompt + promptTokens,
+              completion: prev.completion + completionTokens,
+              total: prev.total + promptTokens + completionTokens,
+            }));
+          }
+          const delta = chunk.choices[0]?.delta;
+          if (delta?.content) {
+            acc += delta.content;
+            setStreaming(acc);
+          }
+          if (delta?.tool_calls) {
+            for (const tc of delta.tool_calls) {
+              const i = tc.index ?? 0;
+              if (!toolCalls[i]) {
+                toolCalls[i] = {
+                  id: tc.id || "",
+                  type: "function",
+                  function: {
+                    name: tc.function?.name || "",
+                    arguments: tc.function?.arguments || "",
+                  },
+                };
+              } else {
+                if (tc.id) toolCalls[i].id = tc.id;
+                if (tc.function?.name)
+                  toolCalls[i].function.name += tc.function.name;
+                if (tc.function?.arguments)
+                  toolCalls[i].function.arguments += tc.function.arguments;
+              }
+            }
+            setStreamingTools([...toolCalls]);
+          }
+        }
+
+        const assistantMsg = { role: "assistant", content: acc };
+        if (toolCalls.length > 0) assistantMsg.tool_calls = toolCalls;
+        convo = [...convo, assistantMsg];
+        setMessages(convo);
+        setStreaming("");
+        setStreamingTools([]);
+
+        if (toolCalls.length === 0) break;
+
+        for (const tc of toolCalls) {
+          const start = Date.now();
+          setRunning({ id: tc.id, start, elapsed: 0 });
+          const result = await executeTool(
+            tc.function.name,
+            tc.function.arguments,
+            { askConfirm, unhinged, cwd, setCwd }
+          );
+          const duration = Date.now() - start;
+          setRunning(null);
+          setDurations((prev) => ({ ...prev, [tc.id]: duration }));
+          convo = [
+            ...convo,
+            {
+              role: "tool",
+              tool_call_id: tc.id,
+              content: result,
+            },
+          ];
+          setMessages(convo);
+        }
+      }
+      setSending(false);
+    } catch (err) {
+      const aborted =
+        err.name === "AbortError" ||
+        err.code === "ABORT_ERR" ||
+        /aborted/i.test(err.message || "");
+      if (aborted) {
+        if (acc.trim() || toolCalls.length > 0) {
+          const partial = { role: "assistant", content: acc };
+          if (toolCalls.length > 0) partial.tool_calls = toolCalls;
+          setMessages((prev) => [...prev, partial]);
+        }
+        setStreaming("");
+        setStreamingTools([]);
+      } else {
+        setError(
+          `${err.message} | ${err.cause?.code || ""} ${err.cause?.message || ""}`
+        );
+      }
+      setSending(false);
+    } finally {
+      stopRef.current = null;
+    }
+  };
+
+  const formatToolName = (name) =>
+    name.charAt(0).toUpperCase() + name.slice(1);
+
+  const formatToolArgs = (rawArgs) => {
+    try {
+      const parsed = JSON.parse(rawArgs || "{}");
+      const keys = Object.keys(parsed);
+      if (keys.length === 1) return String(parsed[keys[0]]);
+      return keys.map((k) => `${k}=${JSON.stringify(parsed[k])}`).join(", ");
+    } catch {
+      return rawArgs || "";
+    }
+  };
+
+  const renderToolCall = (tc, key) =>
+    React.createElement(
+      Box,
+      { key },
+      React.createElement(
+        Text,
+        { bold: true, color: "yellow" },
+        formatToolName(tc.function.name)
+      ),
+      React.createElement(Text, { dimColor: true }, "("),
+      React.createElement(Text, null, formatToolArgs(tc.function.arguments)),
+      React.createElement(Text, { dimColor: true }, ")")
+    );
+
+  const MAX_OUTPUT_LINES = 2;
+
+  const formatMs = (ms) =>
+    ms < 1000 ? `${ms}ms` : `${(ms / 1000).toFixed(1)}s`;
+
+  const renderToolResult = (msg, key) => {
+    const content = (msg.content || "").trimEnd();
+    const ms = durations[msg.tool_call_id];
+    const dur = ms ? ` · ${formatMs(ms)}` : "";
+    if (!content) {
+      return React.createElement(
+        Box,
+        { key, paddingLeft: 2, marginBottom: 1 },
+        React.createElement(
+          Text,
+          { dimColor: true },
+          `⎿  (No output)${dur}`
+        )
+      );
+    }
+    const lines = content.split("\n");
+    const visible = lines.slice(0, MAX_OUTPUT_LINES);
+    const overflow = lines.length - MAX_OUTPUT_LINES;
+
+    const children = visible.map((line, idx) => {
+      const isLastShown = idx === visible.length - 1 && overflow === 0;
+      const suffix = isLastShown ? dur : "";
+      return React.createElement(
+        Text,
+        { key: `line-${idx}`, dimColor: true },
+        idx === 0 ? `⎿  ${line}${suffix}` : `   ${line}${suffix}`
+      );
+    });
+    if (overflow > 0) {
+      children.push(
+        React.createElement(
+          Text,
+          { key: "overflow", dimColor: true },
+          `   … +${overflow} lines${dur}`
+        )
+      );
+    }
+
+    return React.createElement(
+      Box,
+      { key, flexDirection: "column", paddingLeft: 2, marginBottom: 1 },
+      children
+    );
+  };
+
+  return React.createElement(
+    Box,
+    { flexDirection: "column" },
+    React.createElement(Header, { key: "header", version, unhinged }),
+    ...messages.flatMap((msg, i) => {
+      if (msg.role === "user") {
+        return [
+          React.createElement(
+            Box,
+            { key: `m-${i}`, marginBottom: 1 },
+            React.createElement(Text, { bold: true, color: "white" }, "You: "),
+            React.createElement(Text, { dimColor: true }, msg.content)
+          ),
+        ];
+      }
+      if (msg.role === "assistant") {
+        const nodes = [];
+        if (msg.content) {
+          const rendered = renderMarkdown(msg.content);
+          const nlIdx = rendered.indexOf("\n");
+          const firstLine = nlIdx === -1 ? rendered : rendered.slice(0, nlIdx);
+          const rest = nlIdx === -1 ? "" : rendered.slice(nlIdx + 1);
+          nodes.push(
+            React.createElement(
+              Box,
+              {
+                key: `m-${i}`,
+                marginBottom: 1,
+                flexDirection: "column",
+              },
+              React.createElement(
+                Box,
+                null,
+                React.createElement(
+                  Text,
+                  { bold: true, color: "cyan" },
+                  "Atom: "
+                ),
+                React.createElement(Text, null, firstLine)
+              ),
+              rest ? React.createElement(Text, null, rest) : null
+            )
+          );
+        }
+        if (msg.tool_calls) {
+          for (let j = 0; j < msg.tool_calls.length; j++) {
+            nodes.push(renderToolCall(msg.tool_calls[j], `m-${i}-tc-${j}`));
+          }
+        }
+        return nodes;
+      }
+      if (msg.role === "tool") {
+        return [renderToolResult(msg, `m-${i}`)];
+      }
+      return [];
+    }),
+    streaming &&
+      (() => {
+        const rendered = renderMarkdown(streaming, { streaming: true });
+        const nlIdx = rendered.indexOf("\n");
+        const firstLine = nlIdx === -1 ? rendered : rendered.slice(0, nlIdx);
+        const rest = nlIdx === -1 ? "" : rendered.slice(nlIdx + 1);
+        return React.createElement(
+          Box,
+          { key: "streaming", flexDirection: "column" },
+          React.createElement(
+            Box,
+            null,
+            React.createElement(
+              Text,
+              { color: "cyan", bold: true },
+              "Atom: "
+            ),
+            React.createElement(Text, null, firstLine)
+          ),
+          rest ? React.createElement(Text, null, rest) : null
+        );
+      })(),
+    ...streamingTools.map((tc, j) => renderToolCall(tc, `streaming-tc-${j}`)),
+    running &&
+      React.createElement(
+        Box,
+        { key: "running", paddingLeft: 2, marginBottom: 1 },
+        React.createElement(
+          Text,
+          { dimColor: true },
+          `⎿  running ${formatMs(running.elapsed)}`
+        )
+      ),
+    error &&
+      React.createElement(Text, { key: "error", color: "red" }, `Error: ${error}`),
+    confirm
+      ? React.createElement(ConfirmDangerousCommand, {
+          key: "confirm",
+          command: confirm.command,
+          onAnswer: (value) => {
+            const { resolve } = confirm;
+            setConfirm(null);
+            resolve(value);
+          },
+        })
+      : React.createElement(ChatInput, {
+          key: "input",
+          value: input,
+          onChange: setInput,
+          onSubmit: handleSubmit,
+          cwd,
+          totalTokens: usage.total,
+          loading: sending && !streaming && streamingTools.length === 0,
+          disabled: sending,
+        })
+  );
+}

package/src/screens/main-menu.js

@@ -0,0 +1,107 @@
+import React from "react";
+import { Box, Text, useApp } from "ink";
+import SelectInput from "ink-select-input";
+import { Header } from "../components/Header.js";
+import { HOSTNAME, USERNAME, IS_ROOT } from "../utils/system.js";
+
+function YellowIndicator({ isSelected }) {
+  return React.createElement(
+    Box,
+    { marginRight: 1 },
+    isSelected
+      ? React.createElement(Text, { color: "yellow" }, "❯")
+      : React.createElement(Text, null, " ")
+  );
+}
+
+function YellowItem({ isSelected, label }) {
+  const text = React.createElement(
+    Text,
+    isSelected ? { color: "yellow" } : null,
+    label
+  );
+  if (label === "Exit") {
+    return React.createElement(
+      Box,
+      { flexDirection: "column" },
+      React.createElement(Text, { dimColor: true }, "──────"),
+      text
+    );
+  }
+  return text;
+}
+
+export function MainMenuScreen({
+  version,
+  unhinged,
+  onboarded,
+  onChat,
+  onGetStarted,
+  onSystem,
+  onReset,
+}) {
+  const { exit } = useApp();
+
+  const items = onboarded
+    ? [
+        { label: "Chat", value: "chat" },
+        { label: "System", value: "system" },
+        { label: "Reset", value: "reset" },
+        { label: "Exit", value: "exit" },
+      ]
+    : [
+        { label: "Get Started", value: "start" },
+        { label: "System", value: "system" },
+        { label: "Exit", value: "exit" },
+      ];
+
+  const handleSelect = (item) => {
+    if (item.value === "chat") onChat();
+    if (item.value === "start") onGetStarted();
+    if (item.value === "system") onSystem();
+    if (item.value === "reset") onReset();
+    if (item.value === "exit") exit();
+  };
+
+  return React.createElement(
+    Box,
+    { flexDirection: "column", paddingBottom: 1 },
+    React.createElement(Header, { version, unhinged }),
+    React.createElement(
+      Box,
+      { paddingX: 1, marginTop: 1, flexDirection: "column" },
+      React.createElement(
+        Text,
+        null,
+        "Welcome. Atom will run as ",
+        React.createElement(
+          Text,
+          { color: IS_ROOT ? "red" : "cyan", bold: true },
+          USERNAME
+        ),
+        " on the ",
+        React.createElement(
+          Text,
+          { color: "cyan", bold: true },
+          HOSTNAME
+        ),
+        " system, with full access to read, write, and execute anything here."
+      ),
+      React.createElement(
+        Text,
+        null,
+        "This is experimental, so use it at your own risk and have fun."
+      )
+    ),
+    React.createElement(
+      Box,
+      { marginTop: 1, paddingX: 1 },
+      React.createElement(SelectInput, {
+        items,
+        onSelect: handleSelect,
+        indicatorComponent: YellowIndicator,
+        itemComponent: YellowItem,
+      })
+    )
+  );
+}

package/src/screens/onboarding.js

@@ -0,0 +1,166 @@
+import React, { useState, useEffect, useRef } from "react";
+import { Box, Text, useApp, useStdin } from "ink";
+import { writeFile, mkdir } from "node:fs/promises";
+import { ATOM_DIR, SERVICE_FILE } from "../utils/paths.js";
+import { Header } from "../components/Header.js";
+
+const STEPS = [
+  { key: "uid", name: "UID", label: "Enter your UID" },
+  { key: "keyId", name: "Key ID", label: "Enter your Key ID" },
+  { key: "quantumKey", name: "Quantum Key", label: "Enter your Quantum Key" },
+];
+
+function PasteInput({ onSubmit, onCancel, onExit }) {
+  const { stdin, setRawMode } = useStdin();
+  const [value, setValue] = useState("");
+  const valueRef = useRef("");
+
+  useEffect(() => {
+    setRawMode(true);
+    const handler = (data) => {
+      const str = data.toString();
+
+      if (str === "\x03") {
+        onExit();
+        return;
+      }
+      if (str === "\x1b") {
+        onCancel();
+        return;
+      }
+
+      const newlineIdx = str.search(/\r|\n/);
+      if (newlineIdx >= 0) {
+        const before = str.slice(0, newlineIdx).replace(/[\x00-\x1f\x7f]/g, "");
+        valueRef.current += before;
+        onSubmit(valueRef.current);
+        return;
+      }
+      if (str === "\x7f" || str === "\b") {
+        valueRef.current = valueRef.current.slice(0, -1);
+        setValue(valueRef.current);
+        return;
+      }
+      const cleaned = str.replace(/[\x00-\x1f\x7f]/g, "");
+      if (cleaned) {
+        valueRef.current += cleaned;
+        setValue(valueRef.current);
+      }
+    };
+    stdin.on("data", handler);
+    return () => {
+      stdin.off("data", handler);
+      setRawMode(false);
+    };
+  }, [onSubmit, onCancel, onExit, stdin, setRawMode]);
+
+  return React.createElement(Text, null, "•".repeat(value.length));
+}
+
+export function OnboardingScreen({ version, unhinged, onComplete, onBack }) {
+  const { exit } = useApp();
+  const [step, setStep] = useState(0);
+  const [values, setValues] = useState({});
+  const [saved, setSaved] = useState(false);
+
+  useEffect(() => {
+    if (step < STEPS.length || saved) return;
+    setSaved(true);
+    mkdir(ATOM_DIR, { recursive: true, mode: 0o700 })
+      .then(() =>
+        writeFile(SERVICE_FILE, JSON.stringify(values, null, 2), { mode: 0o600 })
+      )
+      .then(() => onComplete());
+  }, [step, saved, values, onComplete]);
+
+  const isComplete = step >= STEPS.length;
+
+  return React.createElement(
+    Box,
+    { flexDirection: "column", paddingBottom: 1 },
+    React.createElement(Header, { version, unhinged }),
+    React.createElement(
+      Box,
+      { marginTop: 1, paddingX: 1, flexDirection: "column" },
+      React.createElement(
+        Box,
+        null,
+        React.createElement(Text, null, "Sign up at "),
+        React.createElement(Text, { color: "cyan" }, "https://novaqore.ai"),
+        React.createElement(Text, null, " and generate your keys at "),
+        React.createElement(
+          Text,
+          { color: "cyan" },
+          "https://chat.novaqore.ai/keys"
+        ),
+        React.createElement(Text, null, ", then paste each value below.")
+      ),
+      React.createElement(
+        Text,
+        { dimColor: true },
+        "Keys are stored locally in ~/.atom/."
+      ),
+      React.createElement(
+        Box,
+        { marginTop: 1, flexDirection: "column" },
+        STEPS.map((s) => {
+          const filled = values[s.key] !== undefined;
+          return React.createElement(
+            Box,
+            { key: s.key },
+            filled
+              ? React.createElement(
+                  Text,
+                  { color: "green", bold: true },
+                  "  ✓  "
+                )
+              : React.createElement(Text, { dimColor: true }, "  ·  "),
+            React.createElement(
+              Text,
+              filled ? null : { dimColor: true },
+              s.name
+            )
+          );
+        })
+      ),
+      isComplete
+        ? React.createElement(
+            Box,
+            { marginTop: 1 },
+            React.createElement(Text, { color: "green" }, "Saving...")
+          )
+        : React.createElement(
+            Box,
+            {
+              marginTop: 1,
+              borderStyle: "single",
+              borderTop: true,
+              borderBottom: true,
+              borderLeft: false,
+              borderRight: false,
+              borderColor: "gray",
+            },
+            React.createElement(
+              Text,
+              { color: "white" },
+              `${STEPS[step].label}: `
+            ),
+            React.createElement(PasteInput, {
+              key: step,
+              onSubmit: (val) => {
+                setValues({ ...values, [STEPS[step].key]: val });
+                setStep(step + 1);
+              },
+              onCancel: onBack,
+              onExit: exit,
+            })
+          ),
+      React.createElement(
+        Box,
+        { marginTop: 1 },
+        React.createElement(Text, { color: "yellow", bold: true }, "[Esc]"),
+        React.createElement(Text, { dimColor: true }, " Back")
+      )
+    )
+  );
+}