agnostic-ai 0.62.0

package/README.md

@@ -0,0 +1,22 @@
+# agnostic-ai
+
+One spec, every AI CLI. Write your agents, skills, rules, hooks, and MCP servers once, then emit them to Claude Code, Codex, Gemini, Cursor, Copilot, and 20 more in each tool's native format.
+
+```bash
+npx agnostic-ai init --demo   # scaffold specs, one example per kind
+npx agnostic-ai sync          # emit native config for every target
+```
+
+Or install it globally:
+
+```bash
+npm install -g agnostic-ai
+```
+
+This package is a thin wrapper: it downloads the prebuilt Go binary for your platform from [GitHub Releases](https://github.com/Chemaclass/agnostic-ai/releases) and runs it. Supported platforms are macOS, Linux, and Windows on x64 and arm64.
+
+The download normally happens on install. Under npm's install-script gating (`--ignore-scripts`, or npm 11's default prompt), it happens on first run instead. Pin a different binary version with `AGNOSTIC_AI_VERSION=v0.45.0`.
+
+Full docs, targets, and configuration: [github.com/Chemaclass/agnostic-ai](https://github.com/Chemaclass/agnostic-ai).
+
+MIT licensed.

package/bin/agnostic-ai.js

@@ -0,0 +1,27 @@
+#!/usr/bin/env node
+'use strict'
+
+const { spawnSync } = require('node:child_process')
+const { ensureBinary } = require('../lib/download')
+
+async function main() {
+  let binary
+  try {
+    // Normally already on disk from postinstall; this covers an install that
+    // ran with --ignore-scripts or without network.
+    binary = await ensureBinary({ log: (m) => console.error(`agnostic-ai: ${m}`) })
+  } catch (err) {
+    console.error(`agnostic-ai: ${err.message}`)
+    process.exit(1)
+  }
+
+  const result = spawnSync(binary, process.argv.slice(2), { stdio: 'inherit' })
+  if (result.error) {
+    console.error(`agnostic-ai: ${result.error.message}`)
+    process.exit(1)
+  }
+  // A signalled child reports null status; 128+signal is the shell convention.
+  process.exit(result.status === null ? 128 : result.status)
+}
+
+main()

package/lib/download.js

@@ -0,0 +1,122 @@
+'use strict'
+
+// Fetches the agnostic-ai release binary for the current platform. Shared by
+// the postinstall hook and the bin shim, so a failed install still recovers on
+// first run instead of leaving a broken command.
+
+const { execFileSync } = require('node:child_process')
+const crypto = require('node:crypto')
+const fs = require('node:fs')
+const https = require('node:https')
+const os = require('node:os')
+const path = require('node:path')
+
+const REPO = 'Chemaclass/agnostic-ai'
+const BINARY = process.platform === 'win32' ? 'agnostic-ai.exe' : 'agnostic-ai'
+
+const PLATFORMS = { darwin: 'darwin', linux: 'linux', win32: 'windows' }
+const ARCHS = { x64: 'amd64', arm64: 'arm64' }
+
+function target() {
+  const goos = PLATFORMS[process.platform]
+  const goarch = ARCHS[process.arch]
+  if (!goos || !goarch) {
+    throw new Error(
+      `agnostic-ai has no prebuilt binary for ${process.platform}/${process.arch}. ` +
+        'Build from source: go install github.com/chemaclass/agnostic-ai/cmd/agnostic-ai@latest'
+    )
+  }
+  return { goos, goarch, ext: goos === 'windows' ? 'zip' : 'tar.gz' }
+}
+
+function assetName() {
+  const { goos, goarch, ext } = target()
+  return `agnostic-ai_${goos}_${goarch}.${ext}`
+}
+
+function binaryPath() {
+  return path.join(__dirname, '..', 'bin', BINARY)
+}
+
+function get(url) {
+  return new Promise((resolve, reject) => {
+    https
+      .get(url, { headers: { 'user-agent': 'agnostic-ai-npm' } }, (res) => {
+        // GitHub redirects release assets to a signed object-store URL.
+        if (res.statusCode >= 300 && res.statusCode < 400 && res.headers.location) {
+          res.resume()
+          resolve(get(res.headers.location))
+          return
+        }
+        if (res.statusCode !== 200) {
+          res.resume()
+          reject(new Error(`GET ${url} failed with HTTP ${res.statusCode}`))
+          return
+        }
+        const chunks = []
+        res.on('data', (c) => chunks.push(c))
+        res.on('end', () => resolve(Buffer.concat(chunks)))
+        res.on('error', reject)
+      })
+      .on('error', reject)
+  })
+}
+
+// The published package carries the release version; a checkout carries the
+// 0.0.0-dev placeholder, which has no matching release, so fall back to latest.
+async function resolveVersion() {
+  if (process.env.AGNOSTIC_AI_VERSION) return process.env.AGNOSTIC_AI_VERSION
+
+  const { version } = require('../package.json')
+  if (version && !version.startsWith('0.0.0')) return `v${version}`
+
+  const body = await get(`https://api.github.com/repos/${REPO}/releases/latest`)
+  const tag = JSON.parse(body.toString('utf8')).tag_name
+  if (!tag) throw new Error('could not resolve the latest agnostic-ai release')
+  return tag
+}
+
+function downloadUrl(version, asset) {
+  return `https://github.com/${REPO}/releases/download/${version}/${asset}`
+}
+
+async function verifyChecksum(archive, asset, version) {
+  const sums = (await get(downloadUrl(version, 'checksums.txt'))).toString('utf8')
+  const line = sums.split('\n').find((l) => l.trim().endsWith(asset))
+  if (!line) throw new Error(`${asset} missing from checksums.txt`)
+
+  const expected = line.trim().split(/\s+/)[0]
+  const actual = crypto.createHash('sha256').update(fs.readFileSync(archive)).digest('hex')
+  if (actual !== expected) throw new Error(`checksum mismatch for ${asset}`)
+}
+
+async function ensureBinary({ log = () => {} } = {}) {
+  const dest = binaryPath()
+  if (fs.existsSync(dest)) return dest
+
+  const version = await resolveVersion()
+  const asset = assetName()
+  log(`downloading agnostic-ai ${version} (${asset})`)
+
+  const work = fs.mkdtempSync(path.join(os.tmpdir(), 'agnostic-ai-'))
+  try {
+    const archive = path.join(work, asset)
+    fs.writeFileSync(archive, await get(downloadUrl(version, asset)))
+    await verifyChecksum(archive, asset, version)
+
+    // bsdtar reads both tar.gz and zip, and ships with macOS and Windows 10
+    // 1803+; Linux only ever gets the tar.gz here, so GNU tar is fine too.
+    execFileSync('tar', ['-xf', archive, '-C', work, BINARY], { stdio: 'ignore' })
+
+    fs.mkdirSync(path.dirname(dest), { recursive: true })
+    fs.copyFileSync(path.join(work, BINARY), dest)
+    fs.chmodSync(dest, 0o755)
+  } finally {
+    fs.rmSync(work, { recursive: true, force: true })
+  }
+
+  log(`installed ${dest}`)
+  return dest
+}
+
+module.exports = { assetName, binaryPath, downloadUrl, ensureBinary, resolveVersion, target }

package/lib/download_test.js

@@ -0,0 +1,62 @@
+'use strict'
+
+// Run: node npm/lib/download_test.js  (or npm test inside npm/)
+//
+// Covers the pure mapping logic. The download path itself is exercised
+// end to end by .github/workflows/install.yml against a real release.
+
+const assert = require('node:assert')
+const path = require('node:path')
+const { assetName, binaryPath, downloadUrl, resolveVersion, target } = require('./download')
+
+const tests = {
+  'asset name matches the release archive for this platform'() {
+    const { goos, goarch } = target()
+    const expected = goos === 'windows'
+      ? `agnostic-ai_${goos}_${goarch}.zip`
+      : `agnostic-ai_${goos}_${goarch}.tar.gz`
+    assert.strictEqual(assetName(), expected)
+  },
+
+  'windows gets a zip, every other platform a tar.gz'() {
+    assert.strictEqual(target().ext, process.platform === 'win32' ? 'zip' : 'tar.gz')
+  },
+
+  'download url points at the tagged release asset'() {
+    assert.strictEqual(
+      downloadUrl('v0.45.0', 'agnostic-ai_linux_amd64.tar.gz'),
+      'https://github.com/Chemaclass/agnostic-ai/releases/download/v0.45.0/agnostic-ai_linux_amd64.tar.gz'
+    )
+  },
+
+  'binary path lands in the package bin dir'() {
+    assert.strictEqual(path.dirname(binaryPath()), path.join(__dirname, '..', 'bin'))
+    assert.match(path.basename(binaryPath()), /^agnostic-ai(\.exe)?$/)
+  },
+
+  async 'env override wins over the package version'() {
+    process.env.AGNOSTIC_AI_VERSION = 'v1.2.3'
+    try {
+      assert.strictEqual(await resolveVersion(), 'v1.2.3')
+    } finally {
+      delete process.env.AGNOSTIC_AI_VERSION
+    }
+  },
+}
+
+async function run() {
+  let failed = 0
+  for (const [name, fn] of Object.entries(tests)) {
+    try {
+      await fn()
+      console.log(`ok   ${name}`)
+    } catch (err) {
+      failed++
+      console.error(`FAIL ${name}\n     ${err.message}`)
+    }
+  }
+  console.log(`\n${Object.keys(tests).length - failed} passed, ${failed} failed`)
+  process.exit(failed === 0 ? 0 : 1)
+}
+
+run()

package/package.json

@@ -0,0 +1,52 @@
+{
+  "name": "agnostic-ai",
+  "version": "0.62.0",
+  "description": "One spec, every AI CLI. Sync agents, skills, rules, hooks, and MCP servers to Claude Code, Codex, Gemini, Cursor, Copilot, and 20 more.",
+  "keywords": [
+    "ai",
+    "cli",
+    "claude",
+    "codex",
+    "cursor",
+    "copilot",
+    "agents",
+    "skills",
+    "mcp"
+  ],
+  "homepage": "https://github.com/Chemaclass/agnostic-ai#readme",
+  "bugs": {
+    "url": "https://github.com/Chemaclass/agnostic-ai/issues"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/Chemaclass/agnostic-ai.git",
+    "directory": "npm"
+  },
+  "license": "MIT",
+  "author": "Chemaclass",
+  "bin": {
+    "agnostic-ai": "bin/agnostic-ai.js"
+  },
+  "files": [
+    "bin/",
+    "lib/",
+    "scripts/",
+    "README.md"
+  ],
+  "scripts": {
+    "postinstall": "node scripts/postinstall.js",
+    "test": "node lib/download_test.js"
+  },
+  "engines": {
+    "node": ">=18"
+  },
+  "os": [
+    "darwin",
+    "linux",
+    "win32"
+  ],
+  "cpu": [
+    "x64",
+    "arm64"
+  ]
+}

package/scripts/postinstall.js

@@ -0,0 +1,12 @@
+'use strict'
+
+// Downloads the binary at install time. A failure here is a warning, never an
+// install error: the bin shim retries on first run, so an offline install or a
+// blocked proxy does not break `npm install` for the whole project.
+
+const { ensureBinary } = require('../lib/download')
+
+ensureBinary({ log: (m) => console.log(`agnostic-ai: ${m}`) }).catch((err) => {
+  console.warn(`agnostic-ai: ${err.message}`)
+  console.warn('agnostic-ai: the binary will be fetched on first run instead')
+})