arxo 0.0.1 → 0.1.0-beta.1

package/LICENSE

@@ -1,6 +1,6 @@
 MIT License
 
-Copyright (c) 2025 Arxo
+Copyright (c) 2026 Arxo
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
@@ -19,3 +19,11 @@ AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 SOFTWARE.
+
+---
+
+This license applies only to the JavaScript/Node components, documentation, and
+other source material in this repository. Native binaries (e.g. arxo-mcp)
+included in packages are proprietary software and are not licensed under the
+MIT License. Use of those binaries is permitted under the terms of each
+package distribution.

package/README.md

@@ -1,6 +1,18 @@
 # arxo
 
-Minimal CLI placeholder. Architecture tooling — coming soon.
+Architecture analysis for AI-native codebases.
+
+Arxo analyzes the dependency graph and call patterns of your project and surfaces structural risks — circular dependencies, unsafe agent boundaries, and governance gaps in AI configurations.
+
+## Public metrics
+
+| Metric | What it detects |
+|--------|-----------------|
+| `scc` | Circular dependency clusters (strongly connected components) |
+| `agent_architecture` | Unsafe patterns in LLM/agent code: tool call risks, memory isolation, MCP server shadow usage |
+| `openclaw_architecture` | Security and governance gaps in OpenClaw AI config files |
+
+Supports TypeScript and Python.
 
 ## Install
 
@@ -11,23 +23,20 @@ npm install -g arxo
 ## Usage
 
 ```bash
-arxo --help
-arxo --version
-```
-
-## Publish (from monorepo)
+# Analyze current directory (default) or a path
+arxo analyze [path]
 
-From repo root:
+# Generate an HTML report (report.html) and open it in your browser
+arxo analyze --html
 
-```bash
-cd arxo-npm
-npm login
-npm publish --access public
+# List available metrics
+arxo metrics list
 ```
 
-- `repository` in `package.json` points at this monorepo and `directory: "arxo-npm"` so npm/GitHub link to this folder.
-- Check name availability first: https://www.npmjs.com/package/arxo
+## MCP (AI assistant integration)
+
+Arxo ships an MCP server. Add it to Cursor or Claude Desktop and your AI assistant can query your architecture directly.
 
 ## License
 
-MIT
+The launcher and scripts in this package are MIT. The arxo native binary is proprietary; use is permitted under the terms of this distribution.

package/bin/arxo.js

@@ -1,29 +1,50 @@
 #!/usr/bin/env node
+/**
+ * Arxo CLI launcher. Runs the platform-specific native binary from bin/ when present
+ * (after prepare-from-dist). Supports multi-platform: arxo-<platform>-<arch> or arxo-win32-x64.exe.
+ * Falls back to legacy bin/arxo or bin/arxo.exe for single-binary installs.
+ */
+const path = require('path');
+const fs = require('fs');
+const { spawnSync } = require('child_process');
 
+const binDir = path.join(__dirname);
+const isWin = process.platform === 'win32';
+const arch = process.arch; // 'x64', 'arm64', 'ia32'
+
+// Multi-platform binary name (Node-style: darwin-x64, linux-arm64, win32-x64.exe)
+const platformName = isWin ? `win32-${arch}.exe` : `${process.platform}-${arch}`;
+const multiPlatformBin = path.join(binDir, `arxo-${platformName}`);
+
+// Legacy single-binary names
+const legacyBin = path.join(binDir, isWin ? 'arxo.exe' : 'arxo');
+
+const nativeBin = fs.existsSync(multiPlatformBin) ? multiPlatformBin : legacyBin;
 const args = process.argv.slice(2);
-const has = (s) => args.includes(s) || args.includes(s + "=");
 
-if (has("--version") || has("-v")) {
-  const pkg = require("../package.json");
-  console.log("arxo " + pkg.version);
-  process.exit(0);
+if (fs.existsSync(nativeBin)) {
+  const result = spawnSync(nativeBin, args, { stdio: 'inherit', windowsHide: true });
+  process.exitCode = result.status != null ? result.status : 1;
+  process.exit(process.exitCode);
 }
 
-if (has("--help") || has("-h")) {
+// No native binary (e.g. dev before prepare-from-dist)
+const has = (s) => args.includes(s) || args.includes(s + '=');
+if (has('--version') || has('-v')) {
+  const pkg = require(path.join(binDir, '..', 'package.json'));
+  console.log('arxo ' + pkg.version);
+  process.exit(0);
+}
+if (has('--help') || has('-h')) {
   console.log(`
-arxo — architecture tooling (placeholder)
+arxo — architecture analysis (scc, agent_architecture, openclaw_architecture)
 
 Usage:
-  arxo [options]
-
-Options:
-  -h, --help     Show this help
-  -v, --version  Show version
-
-Not implemented yet. Full CLI coming soon.
+  arxo analyze [path]
+  arxo metrics list
 `);
   process.exit(0);
 }
 
-console.log("arxo: Not implemented yet.");
-process.exit(0);
+console.error('arxo: Native binary not found for this platform. Reinstall with: npm install -g arxo');
+process.exit(1);

package/package.json

@@ -1,18 +1,33 @@
 {
   "name": "arxo",
-  "version": "0.0.1",
-  "description": "CLI placeholder — architecture tooling (coming soon)",
+  "version": "0.1.0-beta.1",
+  "description": "Architecture analysis CLI — scc, agent_architecture, openclaw_architecture for TypeScript and Python",
   "bin": {
     "arxo": "bin/arxo.js"
   },
-  "files": ["bin", "LICENSE", "README.md"],
+  "files": [
+    "bin",
+    "scripts",
+    "LICENSE",
+    "README.md"
+  ],
+  "scripts": {
+    "postinstall": "node scripts/postinstall.js",
+    "prepare-npm": "bash scripts/prepare-from-dist.sh"
+  },
   "repository": {
     "type": "git",
-    "url": "https://github.com/arxo-io/arxo-cli.git"
+    "url": "https://github.com/arxohq/arxo.git"
   },
   "license": "MIT",
-  "keywords": ["cli", "architecture"],
+  "keywords": [
+    "cli",
+    "architecture",
+    "agent",
+    "llm",
+    "mcp"
+  ],
   "engines": {
     "node": ">=14"
   }
-}
+}

package/scripts/platform.js

@@ -0,0 +1,23 @@
+#!/usr/bin/env node
+/**
+ * Detect platform triple for arxo-engine binary (must match arxo-loader platform.rs).
+ * Usage: node scripts/platform.js  →  e.g. "x86_64-unknown-linux-gnu"
+ */
+const os = require('os');
+const arch = os.arch();
+const platform = os.platform();
+
+const map = {
+  linux: { x64: 'x86_64-unknown-linux-gnu', arm64: 'aarch64-unknown-linux-gnu' },
+  darwin: { x64: 'x86_64-apple-darwin', arm64: 'aarch64-apple-darwin' },
+  win32: { x64: 'x86_64-pc-windows-msvc', arm64: 'x86_64-pc-windows-msvc' },
+};
+
+const a = arch === 'x64' || arch === 'x86_64' ? 'x64' : arch === 'arm64' || arch === 'aarch64' ? 'arm64' : null;
+const triple = map[platform] && map[platform][a] ? map[platform][a] : null;
+if (triple) {
+  console.log(triple);
+} else {
+  console.error('Unsupported platform: ' + platform + '/' + arch);
+  process.exit(1);
+}

package/scripts/postinstall.js

@@ -0,0 +1,56 @@
+#!/usr/bin/env node
+/**
+ * Postinstall: optionally download arxo-engine for current platform.
+ * Reads version from releases/version.json or env ARCH0_ENGINE_VERSION.
+ * Skips if ARCH0_SKIP_ENGINE_DOWNLOAD=1. Exits 0 on any error so npm install never fails.
+ */
+const fs = require('fs');
+const path = require('path');
+const { execSync } = require('child_process');
+
+if (process.env.ARCH0_SKIP_ENGINE_DOWNLOAD === '1') process.exit(0);
+
+const releasesRoot = path.resolve(__dirname, '../..');
+let version = process.env.ARCH0_ENGINE_VERSION;
+if (!version) {
+  try {
+    const v = JSON.parse(fs.readFileSync(path.join(releasesRoot, 'version.json'), 'utf8'));
+    version = v.engine_version || v.version || 'latest';
+  } catch (_) {
+    version = 'latest';
+  }
+}
+
+let triple;
+try {
+  triple = execSync('node "' + path.join(__dirname, 'platform.js') + '"', { encoding: 'utf8' }).trim();
+} catch (_) {
+  process.exit(0);
+}
+
+const isWin = triple.includes('windows');
+const ext = isWin ? 'dll' : triple.includes('darwin') ? 'dylib' : 'so';
+const prefix = isWin ? '' : 'lib';
+const libName = prefix + 'arxo_engine.' + ext;
+const CDN = process.env.ARXO_CDN_URL || 'https://releases.arxo.io';
+const url = CDN + '/v' + version + '/arxo-engine-' + triple + '/' + libName;
+const cacheDir = path.join(process.env.XDG_CACHE_HOME || path.join(process.env.HOME || process.env.USERPROFILE || '', '.cache'), 'arxo', 'engine', 'v' + version);
+const dest = path.join(cacheDir, libName);
+if (fs.existsSync(dest)) process.exit(0);
+
+try {
+  fs.mkdirSync(cacheDir, { recursive: true });
+} catch (_) {
+  process.exit(0);
+}
+
+const https = require('https');
+const http = require('http');
+const mod = url.startsWith('https') ? https : http;
+mod.get(url, (res) => {
+  if (res.statusCode !== 200) return;
+  const file = fs.createWriteStream(dest);
+  res.pipe(file);
+  file.on('finish', () => file.close());
+}).on('error', () => {});
+process.exit(0);

package/scripts/prepare-from-dist.sh

@@ -0,0 +1,36 @@
+#!/usr/bin/env bash
+# Copy public CLI binary(ies) from releases/dist/public into releases/npm/bin for npm publish.
+# Multi-platform: copies all arxo-<platform>-<arch> and arxo-win32-x64.exe.
+# Single-platform fallback: copies arxo or arxo.exe if no platform-named binaries exist.
+# Run from repo root after ./releases/scripts/release.sh (or after building CLI for each target).
+set -e
+
+REPO_ROOT="$(cd "$(dirname "$0")/../../.." && pwd)"
+DIST="$REPO_ROOT/releases/dist/public"
+NPM_BIN="$REPO_ROOT/releases/npm/bin"
+mkdir -p "$NPM_BIN"
+
+copied=0
+# CLI only: arxo-<platform>-<arch> or arxo-win32-x64.exe (exclude arxo-mcp*)
+for f in "$DIST"/arxo-darwin-* "$DIST"/arxo-linux-* "$DIST"/arxo-win32-*; do
+  [ -f "$f" ] || continue
+  name=$(basename "$f")
+  cp "$f" "$NPM_BIN/$name"
+  [ -x "$f" ] || chmod +x "$NPM_BIN/$name" 2>/dev/null || true
+  echo "Copied $DIST/$name -> $NPM_BIN/$name"
+  copied=$((copied + 1))
+done
+if [ "$copied" -eq 0 ]; then
+  # No platform-named binaries; try legacy single binary
+  if [ -f "$DIST/arxo" ]; then
+    cp "$DIST/arxo" "$NPM_BIN/arxo"
+    chmod +x "$NPM_BIN/arxo"
+    echo "Copied $DIST/arxo -> $NPM_BIN/arxo"
+  elif [ -f "$DIST/arxo.exe" ]; then
+    cp "$DIST/arxo.exe" "$NPM_BIN/arxo.exe"
+    echo "Copied $DIST/arxo.exe -> $NPM_BIN/arxo.exe"
+  else
+    echo "No public CLI binary at $DIST (arxo, arxo.exe, or arxo-<platform>-<arch>). Run ./releases/scripts/release.sh first." >&2
+    exit 1
+  fi
+fi