@rnbsolucoes/axion-code 0.1.3

package/README.md

@@ -0,0 +1,207 @@
+# Axion Code
+
+Axion Code is the Go-first CLI agent harness for the Axion ecosystem. It brings
+the Axion Agent runtime to the terminal with PREVC + A workflow state, Mythos
+execution discipline, provider/model management, persistent sessions, shared
+Axion Desktop configuration, native dotcontext support, and a Claude Code-style
+TUI focused on agentic coding workflows.
+
+This MVP follows the PREVC-P documentation package in `.context/`:
+
+- Go core;
+- PREVC + A / Mythos event rail;
+- JSONL protocol for `run --json`;
+- SQLite-first shared user session store;
+- Claude Code-style terminal TUI powered by Bubble Tea;
+- full-width chat layout with initial brand splash;
+- provider catalog/profile foundation with mock and OpenRouter adapters;
+- interactive slash palette and provider/model/permission menus;
+- Axion Desktop fallback provider presets, including OpenAI-compatible and Anthropic-compatible endpoints;
+- shared Axion Desktop/CLI provider, model and permission stores under `%USERPROFILE%\.axion`;
+- Pi Agent assets in inspect/import-only mode;
+- MCP probe/list/read-only posture.
+
+## MVP Commands
+
+```powershell
+axion-code
+axion-code ask "Explique este projeto"
+axion-code ask --provider openrouter --model google/gemini-2.5-flash-lite "Responda em uma linha"
+axion-code run --json
+axion-code doctor --json
+axion-code session list --json
+axion-code provider list --json
+axion-code provider profile init
+axion-code provider profile list --json
+axion-code provider profile add or-free --catalog openrouter --model openrouter/free --credential-ref env:OPENROUTER_API_KEY
+axion-code provider profile set or-free
+axion-code provider profile delete or-free
+axion-code provider profile active
+axion-code provider model list openrouter --json
+axion-code provider test openrouter google/gemini-2.5-flash-lite
+axion-code permission list --json
+axion-code permission set full_permission
+axion-code graphics doctor
+axion-code graphics logo
+axion-code graphics logo --mode sixel --width 180
+axion-code mcp list --json
+axion-code package inspect <path>
+```
+
+## Install
+
+Official install, after the package is published to the public npm registry:
+
+```powershell
+npm install -g @rnbsolucoes/axion-code
+axion
+```
+
+The GitHub source repository can remain private. The npm package is intentionally
+published as a small installer/runtime package: it contains the Node wrapper,
+platform binaries under `npm/releases`, and documentation, but it does not ship
+the Go source tree (`cmd/`, `internal/`, `go.mod`, `go.sum`).
+
+Private GitHub install is not the recommended distribution path. Commands like
+`npm install -g rnbsolucoes/Axion-CLI` use Git access and may require SSH keys or
+credentials on every machine. Use the scoped npm package instead.
+
+Development install from the current local clone:
+
+```powershell
+npm install -g .
+axion
+```
+
+If an older local `axion.ps1` shim already exists, replace it once:
+
+```powershell
+npm install -g . --force
+```
+
+The npm package exposes both `axion` and `axion-code`. It does not use a
+`postinstall` hook. On first run, the wrapper copies the packaged binary for the
+current platform into the local Axion Code bin directory and then executes it. In
+a source clone only, if no packaged binary exists, the wrapper can build from Go
+as a development fallback.
+
+Requirements:
+
+- Node.js 18+ for the npm wrapper.
+- End users do not need Go when installing from npm.
+- Development source builds need Go 1.26+ on `PATH`, `AXION_GO`, or the Codex
+  bundled Go toolchain at `%USERPROFILE%\.codex\toolchains\go1.26.4\go\bin\go.exe`.
+
+For this development machine, if an older PowerShell shim still points directly
+to `%LOCALAPPDATA%\AxionCode\bin\axion-code.exe`, rebuild the local binary:
+
+```powershell
+go build -o "$env:LOCALAPPDATA\AxionCode\bin\axion-code.exe" ./cmd/axion-code
+```
+
+## Publish
+
+Build the npm package binaries before publishing:
+
+```powershell
+npm run build:npm-binaries:release
+npm pack --dry-run
+npm publish --access public
+```
+
+The npm account or organization must own the `@rnbsolucoes` scope. Scoped public
+packages must be published with public access on the first publish.
+The current release build targets Windows x64 and Linux x64. Add more targets by
+running `node npm/build-package-binaries.mjs --targets=all` or a comma-separated
+target list when those platforms are ready.
+
+## Update
+
+Check for a newer version:
+
+```powershell
+axion update --check
+axion version --check
+```
+
+Update the installed CLI. This is the official update alias and must remain the
+single command users run whenever a new Axion Code binary/package is released:
+
+```powershell
+axion update
+```
+
+The npm wrapper checks the public npm registry first and falls back to the GitHub
+package metadata only when available. If a newer version exists, the initial
+Axion Code splash shows the update notice and hides it after the first
+interaction.
+
+Without npm:
+
+```powershell
+go build -o "$env:LOCALAPPDATA\AxionCode\bin\axion-code.exe" ./cmd/axion-code
+```
+
+Provider and model configuration is shared with Axion Desktop:
+
+```text
+%USERPROFILE%\.axion\harness\providers.json
+%USERPROFILE%\.axion\harness\active_profile
+%USERPROFILE%\.axion\axion-mode.json
+%USERPROFILE%\.axion\sessions\axion.db
+```
+
+OpenRouter uses `OPENROUTER_API_KEY` from the environment or a `secret:<NAME>` reference stored in `C:\Israel\Pesoal\secrets.env` (override for tests: `AXION_SECRETS_ENV`). Provider profile config stores only references, never the key value.
+
+For test/dev isolation, set `AXION_HOME` to a temporary folder. In normal use, leave it unset so Desktop and CLI remain two surfaces of the same Axion harness.
+
+The interactive TUI supports:
+
+```text
+/             inline slash palette
+/provider
+/provider set <profile-id>
+/model
+/permission
+```
+
+Slash palette behavior: `↑/↓` selects, `Tab` completes the selected command, `Enter` executes the selected command, `Esc` closes active menus/wizards.
+
+`/model` pulls the active provider's `/models` endpoint when credentials are configured. Reasoning and fast-mode steps appear only when the selected model metadata exposes those parameters.
+
+Provider menu actions:
+
+```text
+Register provider
+Edit provider
+Set provider
+Delete provider
+```
+
+For a profile-backed OpenRouter session:
+
+```powershell
+axion provider profile add or-free --catalog openrouter --model openrouter/free --credential-ref env:OPENROUTER_API_KEY
+axion provider profile set or-free
+axion
+```
+
+## Build
+
+```powershell
+go test -count=1 ./...
+go build ./cmd/axion-code
+```
+
+If Go is not on PATH, use a verified local Go toolchain and keep generated binaries out of git.
+
+## Current Limits
+
+This is a functional direction MVP, not the full harness:
+
+- no provider streaming yet; current provider profile foundation is non-streaming;
+- terminal logo uses Sixel when available and falls back to width-bounded ANSI/block rendering;
+- initial chat splash shows the Axion logo and system name until the first interaction;
+- no tool execution yet;
+- no executable Pi RPC bridge yet;
+- no MCP transport execution yet.

package/npm/bin/axion.mjs

@@ -0,0 +1,297 @@
+#!/usr/bin/env node
+import { spawnSync } from "node:child_process";
+import { chmodSync, copyFileSync, existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import https from "node:https";
+import { dirname, join, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+
+const here = dirname(fileURLToPath(import.meta.url));
+const root = resolve(here, "..", "..");
+const isWindows = process.platform === "win32";
+const exeName = isWindows ? "axion-code.exe" : "axion-code";
+const platformKey = `${process.platform}-${process.arch}`;
+const packagedExePath = join(root, "npm", "releases", platformKey, exeName);
+const binDir = isWindows
+  ? join(process.env.LOCALAPPDATA || join(process.env.USERPROFILE || root, "AppData", "Local"), "AxionCode", "bin")
+  : join(process.env.HOME || root, ".local", "share", "axion-code", "bin");
+const exePath = join(binDir, exeName);
+const markerPath = join(binDir, ".axion-code-package-version");
+const updateCachePath = join(binDir, ".axion-code-update.json");
+const packageJSON = JSON.parse(readFileSync(join(root, "package.json"), "utf8"));
+const updateSource = packageJSON.name;
+const githubSource = "github:rnbsolucoes/Axion-CLI";
+const updatePackageURL = "https://raw.githubusercontent.com/rnbsolucoes/Axion-CLI/main/package.json";
+const npmRegistryURL = "https://registry.npmjs.org/@rnbsolucoes%2Faxion-code/latest";
+const updateCommand = "axion update";
+const updateCacheTTL = 12 * 60 * 60 * 1000;
+
+function findGo() {
+  if (process.env.AXION_GO) {
+    return process.env.AXION_GO;
+  }
+  if (isWindows && process.env.USERPROFILE) {
+    const bundled = join(process.env.USERPROFILE, ".codex", "toolchains", "go1.26.4", "go", "bin", "go.exe");
+    if (existsSync(bundled)) {
+      return bundled;
+    }
+  }
+  return "go";
+}
+
+function sourceAvailable() {
+  return existsSync(join(root, "go.mod")) && existsSync(join(root, "cmd", "axion-code"));
+}
+
+function installPackagedBinary() {
+  if (!existsSync(packagedExePath)) {
+    return false;
+  }
+  copyFileSync(packagedExePath, exePath);
+  if (!isWindows) {
+    chmodSync(exePath, 0o755);
+  }
+  writeFileSync(markerPath, `${packageJSON.version}\n`, "utf8");
+  return true;
+}
+
+function buildFromSource() {
+  const go = findGo();
+  const result = spawnSync(go, ["build", "-o", exePath, "./cmd/axion-code"], {
+    cwd: root,
+    stdio: "inherit",
+    shell: false
+  });
+  if (result.status !== 0) {
+    return false;
+  }
+  writeFileSync(markerPath, `${packageJSON.version}\n`, "utf8");
+  return true;
+}
+
+function ensureBinary() {
+  const marker = existsSync(markerPath) ? readFileSync(markerPath, "utf8").trim() : "";
+  if (existsSync(exePath) && marker === packageJSON.version) {
+    return;
+  }
+  mkdirSync(binDir, { recursive: true });
+  if (installPackagedBinary()) {
+    return;
+  }
+  if (sourceAvailable() && buildFromSource()) {
+    return;
+  }
+  console.error("");
+  console.error(`Axion Code binary for ${platformKey} was not found in this package.`);
+  console.error("If you are using a source clone, install Go 1.26+ on PATH or set AXION_GO and run:");
+  console.error("  npm run install:local");
+  console.error("If you installed from npm, update to a package that includes your platform binary.");
+  process.exit(1);
+}
+
+function semverParts(value) {
+  return String(value || "")
+    .trim()
+    .split(/[+-]/)[0]
+    .split(".")
+    .slice(0, 3)
+    .map((part) => Number.parseInt(part, 10) || 0);
+}
+
+function compareVersions(a, b) {
+  const aa = semverParts(a);
+  const bb = semverParts(b);
+  for (let i = 0; i < 3; i += 1) {
+    if ((aa[i] || 0) > (bb[i] || 0)) return 1;
+    if ((aa[i] || 0) < (bb[i] || 0)) return -1;
+  }
+  return String(a || "").localeCompare(String(b || ""));
+}
+
+function readJSON(path) {
+  try {
+    return JSON.parse(readFileSync(path, "utf8"));
+  } catch {
+    return null;
+  }
+}
+
+function writeJSON(path, value) {
+  try {
+    mkdirSync(dirname(path), { recursive: true });
+    writeFileSync(path, `${JSON.stringify(value, null, 2)}\n`, "utf8");
+  } catch {
+    // Update metadata is advisory; failing to cache must not block startup.
+  }
+}
+
+function fetchJSON(url, timeoutMs = 1800) {
+  return new Promise((resolvePromise, rejectPromise) => {
+    const headers = { "User-Agent": `Axion-Code/${packageJSON.version}` };
+    if (url.includes("githubusercontent.com")) {
+      const token = process.env.GH_TOKEN || process.env.GITHUB_TOKEN || "";
+      if (token) {
+        headers.Authorization = `Bearer ${token}`;
+      }
+    }
+    const req = https.get(url, { headers }, (res) => {
+      if (res.statusCode !== 200) {
+        res.resume();
+        rejectPromise(new Error(`status ${res.statusCode}`));
+        return;
+      }
+      let body = "";
+      res.setEncoding("utf8");
+      res.on("data", (chunk) => {
+        body += chunk;
+        if (body.length > 128 * 1024) {
+          req.destroy(new Error("version payload too large"));
+        }
+      });
+      res.on("end", () => {
+        try {
+          resolvePromise(JSON.parse(body));
+        } catch (error) {
+          rejectPromise(error);
+        }
+      });
+    });
+    req.setTimeout(timeoutMs, () => req.destroy(new Error("version check timeout")));
+    req.on("error", rejectPromise);
+  });
+}
+
+async function fetchLatestPackage() {
+  const errors = [];
+  for (const candidate of [
+    { url: npmRegistryURL, source: packageJSON.name },
+    { url: updatePackageURL, source: githubSource }
+  ]) {
+    try {
+      const remote = await fetchJSON(candidate.url);
+      const latestVersion = String(remote.version || "").trim();
+      if (latestVersion) {
+        return { latestVersion, source: candidate.source };
+      }
+      errors.push(`${candidate.url}: missing version`);
+    } catch (error) {
+      errors.push(`${candidate.url}: ${error.message}`);
+    }
+  }
+  throw new Error(errors.join("; "));
+}
+
+async function readUpdateInfo({ force = false } = {}) {
+  const cached = readJSON(updateCachePath);
+  const now = Date.now();
+  if (!force && cached?.latestVersion && now - Number(cached.checkedAt || 0) < updateCacheTTL) {
+    return {
+      currentVersion: packageJSON.version,
+      latestVersion: cached.latestVersion,
+      updateAvailable: compareVersions(cached.latestVersion, packageJSON.version) > 0,
+      source: updateSource,
+      checkedAt: cached.checkedAt,
+      fromCache: true
+    };
+  }
+  try {
+    const remote = await fetchLatestPackage();
+    const latestVersion = remote.latestVersion;
+    const info = {
+      currentVersion: packageJSON.version,
+      latestVersion,
+      updateAvailable: latestVersion ? compareVersions(latestVersion, packageJSON.version) > 0 : false,
+      source: remote.source || updateSource,
+      checkedAt: now,
+      fromCache: false
+    };
+    if (latestVersion) {
+      writeJSON(updateCachePath, { latestVersion, checkedAt: now, source: info.source });
+    }
+    return info;
+  } catch (error) {
+    return {
+      currentVersion: packageJSON.version,
+      latestVersion: cached?.latestVersion || "",
+      updateAvailable: cached?.latestVersion ? compareVersions(cached.latestVersion, packageJSON.version) > 0 : false,
+      source: cached?.source || updateSource,
+      checkedAt: cached?.checkedAt || 0,
+      fromCache: Boolean(cached?.latestVersion),
+      error: error.message
+    };
+  }
+}
+
+async function updateCommandHandler(args) {
+  const checkOnly = args.includes("--check");
+  const asJSON = args.includes("--json");
+  const info = await readUpdateInfo({ force: true });
+  if (checkOnly) {
+    if (asJSON) {
+      console.log(JSON.stringify({
+        current: info.currentVersion,
+        latest: info.latestVersion || undefined,
+        update_available: info.updateAvailable,
+        source: info.source,
+        command: updateCommand,
+        checked: Boolean(info.latestVersion),
+        error: info.error || undefined
+      }));
+      return;
+    }
+    if (info.updateAvailable) {
+      console.log(`Update available: ${info.currentVersion} -> ${info.latestVersion}`);
+      console.log(`Run: ${updateCommand}`);
+      return;
+    }
+    if (info.latestVersion) {
+      console.log(`Axion Code ${info.currentVersion} is up to date.`);
+      return;
+    }
+    console.log(`Axion Code ${info.currentVersion}. Could not check latest version.`);
+    if (info.error) {
+      console.error(`Version check warning: ${info.error}`);
+    }
+    return;
+  }
+  const source = info.source === packageJSON.name ? packageJSON.name : updateSource;
+  console.log(`Updating Axion Code from ${source}...`);
+  const result = spawnSync("npm", ["install", "-g", source], {
+    stdio: "inherit",
+    shell: false
+  });
+  if (result.error) {
+    console.error(result.error.message);
+    process.exit(1);
+  }
+  if (result.status !== 0) {
+    process.exit(result.status || 1);
+  }
+  console.log("Axion Code update completed. Run axion again.");
+}
+
+const args = process.argv.slice(2);
+if (args[0] === "update") {
+  await updateCommandHandler(args.slice(1));
+  process.exit(0);
+}
+
+const updateInfo = await readUpdateInfo();
+ensureBinary();
+const run = spawnSync(exePath, process.argv.slice(2), {
+  stdio: "inherit",
+  shell: false,
+  env: {
+    ...process.env,
+    AXION_CODE_VERSION: packageJSON.version,
+    AXION_CODE_LATEST_VERSION: updateInfo.latestVersion || "",
+    AXION_CODE_UPDATE_AVAILABLE: updateInfo.updateAvailable ? "1" : "0",
+    AXION_CODE_UPDATE_COMMAND: updateCommand,
+    AXION_CODE_UPDATE_SOURCE: updateSource
+  }
+});
+
+if (run.error) {
+  console.error(run.error.message);
+  process.exit(1);
+}
+process.exit(run.status ?? 0);

package/package.json

@@ -0,0 +1,44 @@
+{
+  "name": "@rnbsolucoes/axion-code",
+  "version": "0.1.3",
+  "description": "Axion Code CLI harness for the Axion ecosystem.",
+  "type": "module",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/rnbsolucoes/Axion-CLI.git"
+  },
+  "homepage": "https://github.com/rnbsolucoes/Axion-CLI#readme",
+  "bugs": {
+    "url": "https://github.com/rnbsolucoes/Axion-CLI/issues"
+  },
+  "publishConfig": {
+    "access": "public",
+    "registry": "https://registry.npmjs.org/"
+  },
+  "bin": {
+    "axion": "npm/bin/axion.mjs",
+    "axion-code": "npm/bin/axion.mjs"
+  },
+  "scripts": {
+    "build": "go build -o dist/axion-code ./cmd/axion-code",
+    "build:npm-binaries": "node npm/build-package-binaries.mjs",
+    "build:npm-binaries:release": "node npm/build-package-binaries.mjs --targets=win32-x64,linux-x64",
+    "install:local": "node npm/install-local.mjs",
+    "test": "go test -count=1 ./..."
+  },
+  "engines": {
+    "node": ">=18"
+  },
+  "files": [
+    "npm/bin",
+    "npm/releases",
+    "README.md"
+  ],
+  "keywords": [
+    "axion",
+    "cli",
+    "agent",
+    "prevc",
+    "harness"
+  ]
+}