stackai 0.1.0

package/dist/cli.js

@@ -0,0 +1,756 @@
+#!/usr/bin/env node
+
+// src/cli.tsx
+import { render } from "ink";
+
+// ../core/dist/llm-client.js
+import OpenAI from "openai";
+
+// ../core/dist/errors.js
+var StackAIError = class extends Error {
+  name = "StackAIError";
+  constructor(message) {
+    super(message);
+    Object.setPrototypeOf(this, new.target.prototype);
+  }
+};
+var PathEscapeError = class extends StackAIError {
+  attemptedPath;
+  name = "PathEscapeError";
+  constructor(attemptedPath) {
+    super(`Path "${attemptedPath}" escapes the working directory`);
+    this.attemptedPath = attemptedPath;
+  }
+};
+var EditError = class extends StackAIError {
+  name = "EditError";
+  constructor(message) {
+    super(message);
+  }
+};
+var LLMError = class extends StackAIError {
+  status;
+  name = "LLMError";
+  constructor(message, status) {
+    super(message);
+    this.status = status;
+  }
+};
+var MaxStepsExceededError = class extends StackAIError {
+  maxSteps;
+  name = "MaxStepsExceededError";
+  constructor(maxSteps) {
+    super(`Agent exceeded the maximum of ${maxSteps} steps without finishing`);
+    this.maxSteps = maxSteps;
+  }
+};
+
+// ../core/dist/llm-client.js
+var DEFAULT_BASE_URL = "https://token-plan-sgp.xiaomimimo.com/v1";
+var DEFAULT_MODEL = "mimo-v2.5-pro";
+var LLMClient = class {
+  client;
+  model;
+  constructor(options) {
+    if (!options.apiKey) {
+      throw new LLMError("LLMClient requires an apiKey (MIMO_API_KEY)");
+    }
+    this.model = options.model ?? DEFAULT_MODEL;
+    this.client = new OpenAI({
+      apiKey: options.apiKey,
+      baseURL: options.baseURL ?? DEFAULT_BASE_URL
+    });
+  }
+  /** Single non-streaming completion. Returns the raw message (may hold tool_calls). */
+  async chat(messages, options = {}) {
+    try {
+      const response = await this.client.chat.completions.create({
+        model: this.model,
+        messages,
+        temperature: options.temperature ?? 0.2,
+        ...options.tools ? { tools: options.tools } : {}
+      });
+      const choice = response.choices[0];
+      if (!choice) {
+        throw new LLMError("MiMo returned no choices");
+      }
+      return choice;
+    } catch (err) {
+      throw toLLMError(err);
+    }
+  }
+  /**
+   * Streaming tool-aware completion. Streams content tokens via `onToken`
+   * while reconstructing any tool_calls from their deltas. Resolves once the
+   * stream ends with the full content, the assembled tool calls, and the
+   * finish reason. Used by AgentRunner so the agent can stream its prose.
+   */
+  async streamChat(messages, options = {}) {
+    let content = "";
+    const acc = /* @__PURE__ */ new Map();
+    let finishReason = null;
+    try {
+      const stream = await this.client.chat.completions.create({
+        model: this.model,
+        messages,
+        temperature: options.temperature ?? 0,
+        stream: true,
+        ...options.tools ? { tools: options.tools } : {}
+      });
+      for await (const part of stream) {
+        const choice = part.choices[0];
+        if (!choice)
+          continue;
+        const delta = choice.delta;
+        if (delta?.content) {
+          content += delta.content;
+          options.onToken?.(delta.content);
+        }
+        for (const tc of delta?.tool_calls ?? []) {
+          const idx = tc.index;
+          let entry = acc.get(idx);
+          if (!entry) {
+            entry = { id: "", name: "", args: "" };
+            acc.set(idx, entry);
+          }
+          if (tc.id)
+            entry.id = tc.id;
+          if (tc.function?.name)
+            entry.name = tc.function.name;
+          if (tc.function?.arguments)
+            entry.args += tc.function.arguments;
+        }
+        if (choice.finish_reason)
+          finishReason = choice.finish_reason;
+      }
+    } catch (err) {
+      throw toLLMError(err);
+    }
+    const toolCalls = [...acc.entries()].sort(([a], [b]) => a - b).map(([, v]) => ({
+      id: v.id,
+      type: "function",
+      function: { name: v.name, arguments: v.args }
+    }));
+    return { content, toolCalls, finishReason };
+  }
+  /**
+   * Streaming completion. Invokes `onChunk` for every content delta and
+   * resolves with the fully concatenated text once the stream ends.
+   */
+  async stream(messages, onChunk, options = {}) {
+    let full = "";
+    try {
+      const stream = await this.client.chat.completions.create({
+        model: this.model,
+        messages,
+        temperature: options.temperature ?? 0.2,
+        stream: true,
+        ...options.tools ? { tools: options.tools } : {}
+      });
+      for await (const part of stream) {
+        const delta = part.choices[0]?.delta?.content;
+        if (delta) {
+          full += delta;
+          onChunk(delta);
+        }
+      }
+    } catch (err) {
+      throw toLLMError(err);
+    }
+    return full;
+  }
+};
+function toLLMError(err) {
+  if (err instanceof LLMError)
+    return err;
+  if (err instanceof OpenAI.APIError) {
+    return new LLMError(err.message, err.status);
+  }
+  const message = err instanceof Error ? err.message : String(err);
+  return new LLMError(message);
+}
+
+// ../core/dist/file-agent.js
+import { promises as fs } from "fs";
+import path from "path";
+var FileAgent = class {
+  root;
+  constructor(cwd) {
+    this.root = path.resolve(cwd);
+  }
+  /** Resolve a user/model-supplied path and guarantee it stays inside root. */
+  resolve(relPath) {
+    const abs = path.resolve(this.root, relPath);
+    const rel = path.relative(this.root, abs);
+    if (rel.startsWith("..") || path.isAbsolute(rel)) {
+      throw new PathEscapeError(relPath);
+    }
+    return abs;
+  }
+  async readFile(relPath) {
+    return fs.readFile(this.resolve(relPath), "utf8");
+  }
+  async writeFile(relPath, content) {
+    const abs = this.resolve(relPath);
+    await fs.mkdir(path.dirname(abs), { recursive: true });
+    await fs.writeFile(abs, content, "utf8");
+  }
+  /**
+   * Replace the first occurrence of `oldStr` with `newStr`. Throws if the
+   * string is missing or appears more than once (ambiguous edit).
+   */
+  async editFile(relPath, oldStr, newStr) {
+    const abs = this.resolve(relPath);
+    const current = await fs.readFile(abs, "utf8");
+    const first = current.indexOf(oldStr);
+    if (first === -1) {
+      throw new EditError(`oldStr not found in ${relPath}`);
+    }
+    if (current.indexOf(oldStr, first + oldStr.length) !== -1) {
+      throw new EditError(`oldStr is ambiguous in ${relPath} (appears multiple times)`);
+    }
+    await fs.writeFile(abs, current.replace(oldStr, newStr), "utf8");
+  }
+  /** List entries in a directory, marking sub-directories with a trailing slash. */
+  async listFiles(relDir = ".") {
+    const abs = this.resolve(relDir);
+    const entries = await fs.readdir(abs, { withFileTypes: true });
+    return entries.map((e) => e.isDirectory() ? `${e.name}/` : e.name).sort((a, b) => a.localeCompare(b));
+  }
+  async createDir(relPath) {
+    await fs.mkdir(this.resolve(relPath), { recursive: true });
+  }
+};
+
+// ../core/dist/system-prompt.js
+var SYSTEM_PROMPT = `You are StackAI, an autonomous coding agent operating inside a user's project directory.
+
+You can read, write, and edit files by calling the provided tools. Be DECISIVE and make the FEWEST tool calls possible \u2014 every call is a slow round-trip.
+
+How to work:
+1. To create a new file: call write_file once. Do NOT list_files or read_file first.
+2. To change an existing file: call read_file ONCE to see its contents, then make ONE edit_file (or one write_file) call to apply the change.
+3. When the task is done, stop calling tools and reply with ONE short sentence summarizing what you changed.
+
+Hard rules:
+- Make each distinct tool call AT MOST ONCE. Never repeat the same read or edit.
+- NEVER re-read a file to verify a write/edit. The tool result is authoritative \u2014 if it didn't error, it worked.
+- NEVER call list_files unless you truly don't know what files exist.
+- Only touch files relevant to the task; keep code consistent with the surrounding style.
+- Never invent contents of a file you have not read.`;
+
+// ../core/dist/agent-runner.js
+var MAX_TOOL_CALLS_PER_TURN = 6;
+var TOOLS = [
+  {
+    type: "function",
+    function: {
+      name: "read_file",
+      description: "Read a UTF-8 file relative to the project root.",
+      parameters: {
+        type: "object",
+        properties: { path: { type: "string" } },
+        required: ["path"]
+      }
+    }
+  },
+  {
+    type: "function",
+    function: {
+      name: "write_file",
+      description: "Create or overwrite a file with the given content.",
+      parameters: {
+        type: "object",
+        properties: {
+          path: { type: "string" },
+          content: { type: "string" }
+        },
+        required: ["path", "content"]
+      }
+    }
+  },
+  {
+    type: "function",
+    function: {
+      name: "edit_file",
+      description: "Replace the first (unique) occurrence of oldStr with newStr in a file.",
+      parameters: {
+        type: "object",
+        properties: {
+          path: { type: "string" },
+          oldStr: { type: "string" },
+          newStr: { type: "string" }
+        },
+        required: ["path", "oldStr", "newStr"]
+      }
+    }
+  },
+  {
+    type: "function",
+    function: {
+      name: "list_files",
+      description: "List files and directories at a path (default: project root).",
+      parameters: {
+        type: "object",
+        properties: { dir: { type: "string" } }
+      }
+    }
+  },
+  {
+    type: "function",
+    function: {
+      name: "create_dir",
+      description: "Create a directory (recursive).",
+      parameters: {
+        type: "object",
+        properties: { path: { type: "string" } },
+        required: ["path"]
+      }
+    }
+  }
+];
+var AgentRunner = class {
+  llm;
+  maxSteps;
+  constructor(options) {
+    this.llm = options.llm;
+    this.maxSteps = options.maxSteps ?? 25;
+  }
+  async run({ prompt, cwd, onStep }) {
+    const files = new FileAgent(cwd);
+    const messages = [
+      { role: "system", content: SYSTEM_PROMPT },
+      { role: "user", content: prompt }
+    ];
+    return this.runLoop(messages, files, onStep);
+  }
+  /** Start a stateful chat session that retains history across prompts. */
+  session(cwd) {
+    return new AgentSession(this, cwd);
+  }
+  /**
+   * Run the tool-call loop over an existing message history (mutated in place).
+   * Shared by one-shot run() and the interactive AgentSession.
+   * @internal
+   */
+  async runLoop(messages, files, onStep) {
+    for (let step = 1; step <= this.maxSteps; step++) {
+      const { content, toolCalls, finishReason } = await this.llm.streamChat(messages, {
+        tools: TOOLS,
+        temperature: 0,
+        onToken: (text) => onStep?.({ type: "token", text })
+      });
+      messages.push({
+        role: "assistant",
+        content,
+        ...toolCalls.length ? { tool_calls: toolCalls } : {}
+      });
+      if (finishReason === "stop" || toolCalls.length === 0) {
+        const summary = content.trim() || "Done.";
+        onStep?.({ type: "done", summary });
+        return { summary, steps: step };
+      }
+      const seen = /* @__PURE__ */ new Map();
+      let executed = 0;
+      for (const call of toolCalls) {
+        const sig = `${call.function.name}:${call.function.arguments}`;
+        let result = seen.get(sig);
+        if (result === void 0) {
+          if (executed >= MAX_TOOL_CALLS_PER_TURN) {
+            result = "Skipped: too many tool calls in one turn. Apply one change at a time.";
+          } else {
+            result = await this.execTool(files, call, onStep);
+            executed += 1;
+          }
+          seen.set(sig, result);
+        }
+        messages.push({
+          role: "tool",
+          tool_call_id: call.id,
+          content: result
+        });
+      }
+    }
+    throw new MaxStepsExceededError(this.maxSteps);
+  }
+  async execTool(files, call, onStep) {
+    const name = call.function.name;
+    let args;
+    try {
+      args = JSON.parse(call.function.arguments || "{}");
+    } catch {
+      return `Error: arguments for ${name} were not valid JSON`;
+    }
+    onStep?.({ type: "tool_call", name, args });
+    try {
+      const detail = await this.dispatch(files, name, args);
+      onStep?.({ type: "tool_result", name, ok: true, detail });
+      return detail;
+    } catch (err) {
+      const detail = err instanceof Error ? err.message : String(err);
+      onStep?.({ type: "tool_result", name, ok: false, detail });
+      return `Error: ${detail}`;
+    }
+  }
+  async dispatch(files, name, args) {
+    switch (name) {
+      case "read_file":
+        return files.readFile(str(args.path));
+      case "write_file":
+        await files.writeFile(str(args.path), str(args.content));
+        return `Wrote ${str(args.path)}`;
+      case "edit_file":
+        await files.editFile(str(args.path), str(args.oldStr), str(args.newStr));
+        return `Edited ${str(args.path)}`;
+      case "list_files": {
+        const entries = await files.listFiles(typeof args.dir === "string" ? args.dir : ".");
+        return entries.join("\n") || "(empty)";
+      }
+      case "create_dir":
+        await files.createDir(str(args.path));
+        return `Created ${str(args.path)}`;
+      default:
+        return `Error: unknown tool ${name}`;
+    }
+  }
+};
+function str(value) {
+  if (typeof value !== "string") {
+    throw new Error(`expected string argument, got ${typeof value}`);
+  }
+  return value;
+}
+var AgentSession = class {
+  runner;
+  messages = [
+    { role: "system", content: SYSTEM_PROMPT }
+  ];
+  files;
+  constructor(runner, cwd) {
+    this.runner = runner;
+    this.files = new FileAgent(cwd);
+  }
+  /** Send a user message; the agent acts with full prior context. */
+  async send(prompt, onStep) {
+    this.messages.push({ role: "user", content: prompt });
+    return this.runner.runLoop(this.messages, this.files, onStep);
+  }
+};
+
+// src/config.ts
+import { promises as fs2 } from "fs";
+import os from "os";
+import path2 from "path";
+var DEFAULT_API_URL = "https://stack-ai-web-one.vercel.app";
+var CONFIG_DIR = path2.join(os.homedir(), ".stackai");
+var CONFIG_PATH = path2.join(CONFIG_DIR, "config.json");
+async function readConfig() {
+  try {
+    const raw = await fs2.readFile(CONFIG_PATH, "utf8");
+    const parsed = JSON.parse(raw);
+    if (!parsed.apiKey) return null;
+    return {
+      apiKey: parsed.apiKey,
+      // STACKAI_API_URL env always wins — handy for pointing at a local API.
+      apiUrl: process.env.STACKAI_API_URL ?? parsed.apiUrl ?? DEFAULT_API_URL
+    };
+  } catch {
+    return null;
+  }
+}
+async function writeConfig(config) {
+  await fs2.mkdir(CONFIG_DIR, { recursive: true });
+  await fs2.writeFile(CONFIG_PATH, JSON.stringify(config, null, 2), "utf8");
+}
+
+// src/api.ts
+var ApiClient = class {
+  constructor(config) {
+    this.config = config;
+  }
+  config;
+  headers() {
+    return {
+      Authorization: `Bearer ${this.config.apiKey}`,
+      "Content-Type": "application/json"
+    };
+  }
+  async verify() {
+    const res = await fetch(`${this.config.apiUrl}/api/verify`, {
+      method: "POST",
+      headers: this.headers()
+    });
+    if (!res.ok) throw new Error(`Auth failed (${res.status})`);
+    return await res.json();
+  }
+  async usage() {
+    const res = await fetch(`${this.config.apiUrl}/api/usage`, {
+      headers: this.headers()
+    });
+    if (!res.ok) throw new Error(`Usage request failed (${res.status})`);
+    return await res.json();
+  }
+};
+
+// src/ui/run-view.tsx
+import { useEffect, useState } from "react";
+import { Box as Box2, Text as Text2, useApp } from "ink";
+import Spinner from "ink-spinner";
+
+// src/ui/format.ts
+function describe(step) {
+  const p = step.args.path ?? step.args.dir ?? "";
+  switch (step.name) {
+    case "read_file":
+      return `Reading ${p}`;
+    case "write_file":
+      return `Writing ${p}`;
+    case "edit_file":
+      return `Editing ${p}`;
+    case "list_files":
+      return `Listing ${p || "."}`;
+    case "create_dir":
+      return `Creating ${p}/`;
+    default:
+      return step.name;
+  }
+}
+function applyStep(entries, step) {
+  if (step.type === "token") {
+    const last = entries[entries.length - 1];
+    if (last && last.kind === "text") {
+      return [...entries.slice(0, -1), { kind: "text", text: last.text + step.text }];
+    }
+    return [...entries, { kind: "text", text: step.text }];
+  }
+  if (step.type === "tool_call") {
+    return [...entries, { kind: "tool", color: "gray", text: describe(step) }];
+  }
+  if (step.type === "tool_result" && !step.ok) {
+    return [...entries, { kind: "tool", color: "red", text: step.detail }];
+  }
+  return entries;
+}
+
+// src/ui/entry-lines.tsx
+import { Box, Text } from "ink";
+import { Fragment, jsx, jsxs } from "react/jsx-runtime";
+function EntryLines({ entries }) {
+  return /* @__PURE__ */ jsx(Fragment, { children: entries.map(
+    (e, i) => e.kind === "tool" ? /* @__PURE__ */ jsx(Box, { marginLeft: 2, children: /* @__PURE__ */ jsxs(Text, { color: e.color, children: [
+      "\u2192 ",
+      e.text
+    ] }) }, i) : /* @__PURE__ */ jsx(Box, { marginTop: 1, marginLeft: 2, children: /* @__PURE__ */ jsx(Text, { children: e.text }) }, i)
+  ) });
+}
+
+// src/ui/run-view.tsx
+import { jsx as jsx2, jsxs as jsxs2 } from "react/jsx-runtime";
+function RunView({ runner, prompt, cwd }) {
+  const { exit } = useApp();
+  const [entries, setEntries] = useState([]);
+  const [error, setError] = useState(null);
+  const [running, setRunning] = useState(true);
+  useEffect(() => {
+    let cancelled = false;
+    const onStep = (step) => {
+      if (!cancelled) setEntries((prev) => applyStep(prev, step));
+    };
+    runner.run({ prompt, cwd, onStep }).catch((err) => {
+      if (!cancelled)
+        setError(err instanceof Error ? err.message : String(err));
+    }).finally(() => {
+      if (!cancelled) {
+        setRunning(false);
+        setTimeout(() => exit(), 50);
+      }
+    });
+    return () => {
+      cancelled = true;
+    };
+  }, [runner, prompt, cwd, exit]);
+  return /* @__PURE__ */ jsxs2(Box2, { flexDirection: "column", paddingY: 1, children: [
+    /* @__PURE__ */ jsxs2(Box2, { children: [
+      /* @__PURE__ */ jsxs2(Text2, { color: "#e8ff47", bold: true, children: [
+        "StackAI",
+        " "
+      ] }),
+      running ? /* @__PURE__ */ jsxs2(Text2, { color: "gray", children: [
+        /* @__PURE__ */ jsx2(Spinner, { type: "dots" }),
+        " working\u2026"
+      ] }) : /* @__PURE__ */ jsx2(Text2, { color: "gray", children: "done" })
+    ] }),
+    /* @__PURE__ */ jsx2(EntryLines, { entries }),
+    error && /* @__PURE__ */ jsx2(Box2, { marginTop: 1, marginLeft: 2, children: /* @__PURE__ */ jsxs2(Text2, { color: "red", children: [
+      "Error: ",
+      error
+    ] }) })
+  ] });
+}
+
+// src/ui/interactive.tsx
+import { useState as useState2 } from "react";
+import { Box as Box3, Text as Text3, useApp as useApp2 } from "ink";
+import Spinner2 from "ink-spinner";
+import TextInput from "ink-text-input";
+import { Fragment as Fragment2, jsx as jsx3, jsxs as jsxs3 } from "react/jsx-runtime";
+function Interactive({ session, cwd }) {
+  const { exit } = useApp2();
+  const [history, setHistory] = useState2([]);
+  const [input, setInput] = useState2("");
+  const [busy, setBusy] = useState2(false);
+  const [error, setError] = useState2(null);
+  async function onSubmit(value) {
+    const text = value.trim();
+    if (!text || busy) return;
+    if (text === "/exit" || text === "/quit") {
+      exit();
+      return;
+    }
+    setInput("");
+    setError(null);
+    setBusy(true);
+    setHistory((prev) => [
+      ...prev,
+      { kind: "user", text },
+      { kind: "agent", entries: [] }
+    ]);
+    const onStep = (step) => {
+      setHistory((prev) => {
+        const last = prev[prev.length - 1];
+        if (!last || last.kind !== "agent") return prev;
+        const updated = {
+          kind: "agent",
+          entries: applyStep(last.entries, step)
+        };
+        return [...prev.slice(0, -1), updated];
+      });
+    };
+    try {
+      await session.send(text, onStep);
+    } catch (err) {
+      setError(err instanceof Error ? err.message : String(err));
+    } finally {
+      setBusy(false);
+    }
+  }
+  return /* @__PURE__ */ jsxs3(Box3, { flexDirection: "column", paddingY: 1, children: [
+    /* @__PURE__ */ jsxs3(Box3, { marginBottom: 1, children: [
+      /* @__PURE__ */ jsxs3(Text3, { color: "#e8ff47", bold: true, children: [
+        "StackAI",
+        " "
+      ] }),
+      /* @__PURE__ */ jsxs3(Text3, { color: "gray", children: [
+        "\u2014 ",
+        cwd
+      ] })
+    ] }),
+    history.map(
+      (block, i) => block.kind === "user" ? /* @__PURE__ */ jsxs3(Box3, { marginTop: 1, children: [
+        /* @__PURE__ */ jsx3(Text3, { color: "#e8ff47", children: "\u203A " }),
+        /* @__PURE__ */ jsx3(Text3, { children: block.text })
+      ] }, i) : /* @__PURE__ */ jsx3(EntryLines, { entries: block.entries }, i)
+    ),
+    error && /* @__PURE__ */ jsx3(Box3, { marginTop: 1, marginLeft: 2, children: /* @__PURE__ */ jsxs3(Text3, { color: "red", children: [
+      "Error: ",
+      error
+    ] }) }),
+    /* @__PURE__ */ jsx3(Box3, { marginTop: 1, children: busy ? /* @__PURE__ */ jsxs3(Text3, { color: "gray", children: [
+      /* @__PURE__ */ jsx3(Spinner2, { type: "dots" }),
+      " working\u2026"
+    ] }) : /* @__PURE__ */ jsxs3(Fragment2, { children: [
+      /* @__PURE__ */ jsx3(Text3, { color: "#e8ff47", children: "\u203A " }),
+      /* @__PURE__ */ jsx3(
+        TextInput,
+        {
+          value: input,
+          onChange: setInput,
+          onSubmit,
+          placeholder: "type a message, /exit to quit"
+        }
+      )
+    ] }) })
+  ] });
+}
+
+// src/cli.tsx
+import { jsx as jsx4 } from "react/jsx-runtime";
+var VERSION = "0.1.0";
+var HELP = `
+  StackAI \u2014 AI coding agent in your terminal
+
+  Usage
+    $ stackai                      Start an interactive chat session
+    $ stackai <prompt>             Run the agent once, then exit
+    $ stackai auth <api_key>       Save your API key
+    $ stackai auth <key> <url>     ...with a custom API URL
+    $ stackai whoami               Show current user + usage
+    $ stackai --help
+    $ stackai --version
+`;
+async function main() {
+  const args = process.argv.slice(2);
+  const first = args[0];
+  if (first === "--help" || first === "-h") {
+    console.log(HELP);
+    return;
+  }
+  if (first === "--version" || first === "-v") {
+    console.log(VERSION);
+    return;
+  }
+  if (first === "auth") {
+    const key = args[1];
+    if (!key) {
+      console.error("Usage: stackai auth <api_key> [api_url]");
+      process.exitCode = 1;
+      return;
+    }
+    const apiUrl = args[2] ?? DEFAULT_API_URL;
+    await writeConfig({ apiKey: key, apiUrl });
+    console.log(`\u2713 API key saved to ~/.stackai/config.json (${apiUrl})`);
+    return;
+  }
+  const config = await readConfig();
+  if (!config) {
+    console.error("Not authenticated. Run: stackai auth <api_key>");
+    process.exitCode = 1;
+    return;
+  }
+  if (first === "whoami") {
+    const api = new ApiClient(config);
+    try {
+      const [verify, usage] = await Promise.all([api.verify(), api.usage()]);
+      const limit = usage.limit === null ? "\u221E" : usage.limit;
+      console.log(`  @${verify.user.username} \xB7 ${usage.tier} tier`);
+      console.log(`  Usage today: ${usage.used} / ${limit}`);
+    } catch (err) {
+      console.error(err instanceof Error ? err.message : String(err));
+      process.exitCode = 1;
+    }
+    return;
+  }
+  const llm = new LLMClient({
+    apiKey: config.apiKey,
+    baseURL: `${config.apiUrl}/api/v1`
+  });
+  const runner = new AgentRunner({ llm });
+  const cwd = process.cwd();
+  if (!first) {
+    if (!process.stdin.isTTY) {
+      console.error(
+        'Interactive mode needs a real terminal. Run a one-shot instead:\n  stackai "your prompt here"'
+      );
+      process.exitCode = 1;
+      return;
+    }
+    render(/* @__PURE__ */ jsx4(Interactive, { session: runner.session(cwd), cwd }));
+    return;
+  }
+  const prompt = args.join(" ");
+  render(/* @__PURE__ */ jsx4(RunView, { runner, prompt, cwd }));
+}
+main().catch((err) => {
+  console.error(err instanceof Error ? err.message : String(err));
+  process.exitCode = 1;
+});

package/package.json

@@ -0,0 +1,54 @@
+{
+  "name": "stackai",
+  "version": "0.1.0",
+  "description": "StackAI — AI coding agent in your terminal. Read, write, and edit code with AI.",
+  "type": "module",
+  "bin": {
+    "stackai": "./dist/cli.js"
+  },
+  "files": [
+    "dist"
+  ],
+  "keywords": [
+    "ai",
+    "cli",
+    "coding-agent",
+    "agent",
+    "mimo",
+    "code-generation",
+    "developer-tools"
+  ],
+  "homepage": "https://stack-ai-web-one.vercel.app",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/Stackaiagent/StackAI.git",
+    "directory": "packages/cli"
+  },
+  "bugs": {
+    "url": "https://github.com/Stackaiagent/StackAI/issues"
+  },
+  "license": "MIT",
+  "engines": {
+    "node": ">=20"
+  },
+  "dependencies": {
+    "ink": "^5.1.0",
+    "ink-spinner": "^5.0.0",
+    "ink-text-input": "^6.0.0",
+    "openai": "^4.77.0",
+    "react": "^18.3.1"
+  },
+  "devDependencies": {
+    "@types/react": "^18.3.18",
+    "rimraf": "^6.0.1",
+    "tsup": "^8.3.5",
+    "typescript": "^5.7.2",
+    "@stackai/core": "0.1.0"
+  },
+  "scripts": {
+    "build": "tsup",
+    "dev": "tsup --watch",
+    "typecheck": "tsc -p tsconfig.json --noEmit",
+    "clean": "rimraf dist"
+  }
+}