amxx-builder 1.5.1

package/src/commands/deps-tree.js

@@ -0,0 +1,92 @@
+'use strict';
+
+const path = require('path');
+
+const logger = require('../logger');
+const { parseManifest, resolveGithubToken } = require('../manifest');
+const { resolveRepoRefs } = require('../repo-fetcher');
+const { buildDepTree, assembleRootDeps } = require('../deps-tree');
+const { resolveManifestPath, loadEnv } = require('./shared');
+
+async function runDepsTree(options) {
+  const manifestPath = options.manifest ? path.resolve(options.manifest) : resolveManifestPath(undefined);
+  loadEnv(manifestPath);
+
+  const noFetch = options.fetch === false;
+  const asJson  = options.json || false;
+  const cycleOnly = options.cycleOnly || false;
+
+  const manifest = parseManifest(manifestPath);
+
+  await resolveRepoRefs(manifest.repos, (repo) => resolveGithubToken(manifest, repo));
+
+  const { rootDeps, getDepsOverride } = assembleRootDeps(manifest);
+
+  const tree = await buildDepTree(rootDeps, {
+    tokenFor: (repo) => resolveGithubToken(manifest, repo),
+    noFetch,
+    depth:   Number.isInteger(options.depth) ? options.depth : 0,
+    from:    'manifest',
+    getDepsOverride,
+  });
+
+  const filtered = cycleOnly ? filterCycles(tree) : tree;
+
+  if (asJson) {
+    process.stdout.write(JSON.stringify(filtered, null, 2) + '\n');
+    return;
+  }
+
+  printTree(filtered);
+}
+
+function printTree(tree) {
+  if (!tree.dependencies || tree.dependencies.length === 0) {
+    logger.info('No dependencies');
+    return;
+  }
+  logger.info('Dependency tree:');
+  for (const node of tree.dependencies) {
+    printNode(node, '', true);
+  }
+}
+
+function printNode(node, prefix, isLast) {
+  const connector = isLast ? '└── ' : '├── ';
+  const childPrefix = isLast ? '    ' : '│   ';
+
+  const tag = buildNodeTag(node);
+  logger.dim(`${prefix}${connector}${node.repo}@${node.ref || 'HEAD'}${tag}`);
+
+  if (node.cycle) return;
+
+  for (let i = 0; i < node.dependencies.length; i++) {
+    printNode(node.dependencies[i], prefix + childPrefix, i === node.dependencies.length - 1);
+  }
+}
+
+function buildNodeTag(node) {
+  const parts = [];
+  if (node.from)           parts.push(`from ${node.from}`);
+  if (node.resolvedRef && node.ref !== node.resolvedRef) {
+    parts.push(`→ ${node.resolvedRef}`);
+  }
+  if (node.cycle)          parts.push('⚠ cycle');
+  if (node.shared)         parts.push('(shared)');
+  if (node.error)          parts.push(`✗ ${node.error}`);
+  return parts.length ? `  (${parts.join(', ')})` : '';
+}
+
+function filterCycles(tree) {
+  const collect = [];
+  function walk(nodes) {
+    for (const n of nodes) {
+      if (n.cycle) collect.push(n);
+      else walk(n.dependencies);
+    }
+  }
+  walk(tree.dependencies || []);
+  return { dependencies: collect };
+}
+
+module.exports = { runDepsTree };

package/src/commands/doctor.js

@@ -0,0 +1,77 @@
+'use strict';
+
+const fs   = require('fs');
+const path = require('path');
+const { execSync } = require('child_process');
+
+const logger = require('../logger');
+const { getCacheDir } = require('../cache-dir');
+const { dirSize, fmtSize } = require('../cache-info');
+
+async function runDoctor(options) {
+  const ok = [];
+  const warn = [];
+  const note = [];
+
+  const nodeMajor = parseInt(process.version.slice(1).split('.')[0], 10);
+  (nodeMajor >= 16 ? ok : warn).push(`Node.js: ${process.version.slice(1)}${nodeMajor >= 16 ? '' : ' (minimum 16 required)'}`);
+
+  try {
+    const gitVer = execSync('git --version', { encoding: 'utf8', stdio: ['pipe', 'pipe', 'ignore'] }).trim();
+    ok.push(`Git: ${gitVer.replace('git version ', '')} (optional — only for github.ssh: true)`);
+  } catch {
+    note.push('Git: not found (optional — only needed for github.ssh: true)');
+  }
+
+  try {
+    const npmVer = execSync('npm --version', { encoding: 'utf8', stdio: ['pipe', 'pipe', 'ignore'] }).trim();
+    ok.push(`npm: ${npmVer}`);
+  } catch {
+    warn.push('npm: not found in PATH');
+  }
+
+  try {
+    const axios = require('axios');
+    const resp = await axios.get('https://api.github.com', { timeout: 5000 });
+    if (resp.status === 200 || resp.status === 403) {
+      ok.push('GitHub API: reachable');
+    } else {
+      warn.push(`GitHub API: returned ${resp.status}`);
+    }
+  } catch {
+    warn.push('GitHub API: unreachable (check internet)');
+  }
+
+  const manifestPath = options.manifest
+    ? path.resolve(options.manifest)
+    : fs.existsSync('./amxbuild.yml') ? './amxbuild.yml'
+    : fs.existsSync('./amxbuild.yaml') ? './amxbuild.yaml'
+    : null;
+
+  if (manifestPath && fs.existsSync(manifestPath)) {
+    try {
+      const { parseManifest } = require('../manifest');
+      parseManifest(manifestPath);
+      ok.push(`Manifest: valid (${path.basename(manifestPath)})`);
+    } catch (err) {
+      warn.push(`Manifest: invalid — ${err.message}`);
+    }
+  } else {
+    ok.push('Manifest: not found (run amxb init)');
+  }
+
+  const cacheDir = getCacheDir();
+  const cacheSize = fmtSize(dirSize(cacheDir));
+  ok.push(`Cache: ${cacheDir} (${cacheSize})`);
+
+  logger.info('=== System Check ===');
+  for (const msg of ok) logger.success(`  ✓ ${msg}`);
+  for (const msg of note) logger.info(`  · ${msg}`);
+  for (const msg of warn) logger.warn(`  ⚠ ${msg}`);
+
+  if (warn.length) {
+    process.exitCode = 1;
+  }
+}
+
+module.exports = { runDoctor };

package/src/commands/dry-run.js

@@ -0,0 +1,64 @@
+'use strict';
+
+const path = require('path');
+const logger = require('../logger');
+const { buildPlanData } = require('../build-plan');
+
+function printDryRun(manifest) {
+  const out = manifest.output;
+  const expand = (tpl) => tpl.replaceAll('{name}', manifest.name).replaceAll('{version}', manifest.version);
+
+  logger.info(`=== DRY RUN: ${manifest.name} v${manifest.version} ===`);
+
+  logger.info(`\nCompiler:`);
+  logger.dim(`  amxxpc ${manifest.amxmodx.version || 'latest'} — dir: ${manifest.amxmodx.dir}`);
+  if (manifest.platform) logger.dim(`  target platform: ${manifest.platform}`);
+  if (manifest.amxmodx.defines.length) {
+    logger.dim(`  defines: ${manifest.amxmodx.defines.map(d => `-D${d}`).join(' ')}`);
+  }
+
+  if (manifest.repos.length) {
+    logger.info(`\nRepos (${manifest.repos.length}):`);
+    for (const r of manifest.repos) {
+      const ref = r.ref || 'default branch';
+      logger.dim(`  ${r.repo} @ ${ref}  [dir: ${r.amxmodx_dir}]`);
+    }
+  }
+
+  if (manifest.globalDeps.length) {
+    logger.info(`\nGlobal deps (${manifest.globalDeps.length}):`);
+    for (const d of manifest.globalDeps) {
+      const src = d.source === 'release' ? 'release' : 'git';
+      logger.dim(`  [${src}] ${d.repo}@${d.ref}${d.include_path ? ':' + d.include_path : ''}`);
+    }
+  }
+
+  if (manifest.assets.sources.length) {
+    logger.info(`\nAsset sources (${manifest.assets.sources.length}):`);
+    for (const s of manifest.assets.sources) {
+      if (s.type === 'amxmodx') {
+        logger.dim(`  [amxmodx] ${manifest.amxmodx.version || 'latest'} (${manifest.platform || 'host'})`);
+      } else if (s.type === 'release') {
+        logger.dim(`  [release] ${s.repo}@${s.ref}  cache: ${s.cache || 'global'}`);
+      } else if (s.type === 'local') {
+        logger.dim(`  [local] assets/`);
+      } else {
+        logger.dim(`  [url] ${s.url}  cache: ${s.cache || 'none'}`);
+      }
+    }
+  }
+
+  logger.info(`\nOutput:`);
+  if (out.pack === false) {
+    logger.dim(`  copy → ${path.resolve(out.dir)}/${expand(out.amxmodx_path)}/`);
+  } else {
+    logger.dim(`  archive → ${path.resolve(out.dir)}/${expand(out.archive_name)}`);
+    logger.dim(`  amxmodx path in archive: ${expand(out.amxmodx_path)}/`);
+  }
+  if (out.assets_path) logger.dim(`  assets path: ${expand(out.assets_path)}/`);
+  logger.dim(`  generate_ini: ${out.generate_ini}  |  on_conflict: ${out.on_conflict}`);
+
+  logger.info(`\n=== END DRY RUN ===`);
+}
+
+module.exports = { printDryRun, buildPlanData };

package/src/commands/init.js

@@ -0,0 +1,228 @@
+'use strict';
+
+const fs   = require('fs');
+const path = require('path');
+
+const logger = require('../logger');
+
+const TEMPLATES_DIR = path.join(__dirname, '..', '..', 'templates');
+const SCHEMA_URL    = 'https://raw.githubusercontent.com/AmxxModularEcosystem/amxx-builder/master/schema/amxbuild.schema.json';
+
+async function runInitInteractive(options) {
+  const { Input, Confirm } = require('enquirer');
+  const defaultName = options.name || path.basename(process.cwd());
+
+  const name = await new Input({
+    name: 'name',
+    message: 'Project name',
+    initial: defaultName,
+  }).run();
+
+  await new Input({
+    name: 'description',
+    message: 'Project description (optional)',
+    initial: '',
+  }).run();
+
+  const doWorkflow = await new Confirm({
+    name: 'workflow',
+    message: 'Generate GitHub CI workflow?',
+    initial: false,
+  }).run();
+
+  const doPlugin = await new Confirm({
+    name: 'plugin',
+    message: 'Create a plugin .sma file?',
+    initial: true,
+  }).run();
+  const pluginName = doPlugin ? await new Input({
+    name: 'pluginName',
+    message: 'Plugin filename (without .sma)',
+    initial: name,
+  }).run() : null;
+
+  const doGitignore = await new Confirm({
+    name: 'gitignore',
+    message: 'Create .gitignore?',
+    initial: true,
+  }).run();
+
+  const doDeploy = await new Confirm({
+    name: 'deploy',
+    message: 'Create .env with deploy stubs?',
+    initial: false,
+  }).run();
+
+  const doOpencode = await new Confirm({
+    name: 'opencode',
+    message: 'Create .opencode/opencode.json with MCP config (amxb mcp)?',
+    initial: false,
+  }).run();
+
+  const doScript = await new Confirm({
+    name: 'script',
+    message: 'Create build.bat / build.sh quick-build scripts?',
+    initial: true,
+  }).run();
+
+  const actions = [];
+  actions.push('amxbuild.yml');
+  if (doWorkflow) actions.push('.github/workflows/ci.yml');
+  if (pluginName) actions.push(`amxmodx/scripting/${pluginName}.sma`);
+  if (doGitignore) actions.push('.gitignore');
+  if (doDeploy) actions.push('.env');
+  if (doOpencode) actions.push('.opencode/opencode.json');
+  if (doScript) actions.push('build.bat', 'build.sh');
+
+  logger.info('Creating:');
+  for (const a of actions) logger.dim(`  ${a}`);
+
+  const version = require('../../package.json').version;
+  const actionTag = `v${version.split('.')[0]}`;
+
+  writeIfAbsent('amxbuild.yml', renderTemplate('init-manifest.yml', { name, schemaUrl: SCHEMA_URL }));
+
+  if (doWorkflow) {
+    const dest = path.join('.github', 'workflows', 'ci.yml');
+    fs.mkdirSync(path.dirname(dest), { recursive: true });
+    writeIfAbsent(dest, renderTemplate('init-workflow.yml', { actionTag }));
+  }
+
+  if (pluginName) {
+    const dest = path.join('amxmodx', 'scripting', `${pluginName}.sma`);
+    fs.mkdirSync(path.dirname(dest), { recursive: true });
+    writeIfAbsent(dest, '');
+  }
+
+  if (doGitignore) {
+    writeIfAbsent('.gitignore', [
+      '*.amxx', '*.zip', '.env', '.amxb-cache', '.claude', 'build', 'dist', '',
+    ].join('\n'));
+  }
+
+  if (doDeploy) {
+    writeIfAbsent('.env', renderTemplate('init-deploy.env'));
+  }
+
+  if (doOpencode) {
+    writeOpencodeConfig();
+  }
+
+  if (doScript) {
+    writeBuildScripts();
+  }
+}
+
+function runInit(options) {
+  const pkgName = options.name || path.basename(process.cwd());
+  const version = require('../../package.json').version;
+  const actionTag = `v${version.split('.')[0]}`;
+
+  writeIfAbsent('amxbuild.yml', renderTemplate('init-manifest.yml', { name: pkgName, schemaUrl: SCHEMA_URL }));
+
+  if (options.workflow || options.ci) {
+    const dest = path.join('.github', 'workflows', 'ci.yml');
+    fs.mkdirSync(path.dirname(dest), { recursive: true });
+    writeIfAbsent(dest, renderTemplate('init-workflow.yml', { actionTag }));
+  }
+
+  if (options.plugin) {
+    const dest = path.join('amxmodx', 'scripting', `${options.plugin}.sma`);
+    fs.mkdirSync(path.dirname(dest), { recursive: true });
+    writeIfAbsent(dest, '');
+  }
+
+  if (options.gitignore) {
+    writeIfAbsent('.gitignore', [
+      '*.amxx', '*.zip', '.env', '.amxb-cache', '.claude', 'build', 'dist', '',
+    ].join('\n'));
+  }
+
+  if (options.deploy) {
+    writeIfAbsent('.env', renderTemplate('init-deploy.env'));
+  }
+
+  if (options.opencode) {
+    writeOpencodeConfig();
+  }
+
+  if (options.script) {
+    writeBuildScripts();
+  }
+}
+
+function writeBuildScripts() {
+  const batCreated = writeIfAbsent('build.bat', renderTemplate('init-build.bat').replace(/\r?\n/g, '\r\n'));
+  const shCreated  = writeIfAbsent('build.sh',  renderTemplate('init-build.sh'));
+
+  if (shCreated && process.platform !== 'win32') {
+    try {
+      fs.chmodSync('build.sh', 0o755);
+      logger.dim('  chmod +x build.sh');
+    } catch (err) {
+      logger.warn(`Could not make build.sh executable: ${err.message}`);
+    }
+  }
+
+  return batCreated || shCreated;
+}
+
+function writeIfAbsent(filePath, content) {
+  if (fs.existsSync(filePath)) {
+    logger.warn(`${filePath} already exists, skipping`);
+    return false;
+  }
+  fs.writeFileSync(filePath, content);
+  logger.success(`Created ${filePath}`);
+  return true;
+}
+
+function writeOpencodeConfig() {
+  const dir   = '.opencode';
+  const file  = path.join(dir, 'opencode.json');
+  const mcpKey = 'amxx-dep-resolver';
+  const mcpConfig = {
+    type: 'local',
+    command: ['amxb', 'mcp'],
+    enabled: true,
+  };
+
+  if (!fs.existsSync(file)) {
+    fs.mkdirSync(dir, { recursive: true });
+    fs.writeFileSync(file, JSON.stringify({
+      $schema: 'https://opencode.ai/config.json',
+      mcp: { [mcpKey]: mcpConfig },
+    }, null, 2) + '\n');
+    logger.success(`Created ${file}`);
+    return;
+  }
+
+  let cfg;
+  try {
+    cfg = JSON.parse(fs.readFileSync(file, 'utf8'));
+  } catch (err) {
+    logger.warn(`${file} exists but is invalid JSON, skipping merge`);
+    return;
+  }
+
+  if (cfg.mcp?.[mcpKey]) {
+    logger.warn(`${file} already has MCP config (amxx-dep-resolver), skipping`);
+    return;
+  }
+
+  cfg.mcp = cfg.mcp || {};
+  cfg.mcp[mcpKey] = mcpConfig;
+  cfg.$schema = cfg.$schema || 'https://opencode.ai/config.json';
+  fs.writeFileSync(file, JSON.stringify(cfg, null, 2) + '\n');
+  logger.success(`Updated ${file} with MCP config (amxb mcp)`);
+}
+
+function renderTemplate(name, vars = {}) {
+  let content = fs.readFileSync(path.join(TEMPLATES_DIR, name), 'utf8');
+  for (const [key, value] of Object.entries(vars)) {
+    content = content.replaceAll(`{{${key}}}`, value);
+  }
+  return content;
+}
+
+module.exports = { runInit, runInitInteractive };

package/src/commands/mcp.js

@@ -0,0 +1,13 @@
+'use strict';
+
+const { startServer } = require('../../mcp/dep-resolver');
+
+/**
+ * Run the MCP server (stdin/stdout JSON-RPC).
+ * Intended to be spawned by opencode as a subprocess.
+ */
+async function runMcp() {
+  await startServer();
+}
+
+module.exports = { runMcp };

package/src/commands/releases.js

@@ -0,0 +1,45 @@
+'use strict';
+
+const logger = require('../logger');
+const { listReleases, listTags } = require('../release-lister');
+
+async function runReleases(repo, options) {
+  require('dotenv').config({ override: true });
+  const token = process.env.GITHUB_TOKEN || null;
+  const limit = options.limit || 10;
+  const asJson = options.json || false;
+
+  let entries;
+  if (options.tags) {
+    entries = await listTags(repo, { token, limit });
+  } else {
+    entries = await listReleases(repo, { token, limit, includeAssets: options.assets });
+  }
+
+  if (asJson) {
+    process.stdout.write(JSON.stringify(entries, null, 2) + '\n');
+    return;
+  }
+
+  if (entries.length === 0) {
+    logger.info(`No ${options.tags ? 'tags' : 'releases'} found for ${repo}`);
+    return;
+  }
+
+  const label = options.tags ? 'Tags' : 'Releases';
+  logger.info(`${label} for ${repo} (${entries.length}):`);
+  for (const e of entries) {
+    const line = options.tags
+      ? `  ${e.name}`
+      : `  ${e.tagName}  ${e.prerelease ? '(pre) ' : ''}${e.publishedAt ? `— ${e.publishedAt.slice(0, 10)}` : ''}`;
+    logger.dim(line);
+
+    if (e.assets && e.assets.length > 0) {
+      for (const a of e.assets) {
+        logger.dim(`    └ assets/${a.name}  (${(a.size / 1024).toFixed(0)} KB)`);
+      }
+    }
+  }
+}
+
+module.exports = { runReleases };

package/src/commands/resolve-manifest.js

@@ -0,0 +1,27 @@
+'use strict';
+
+const path = require('path');
+
+const logger = require('../logger');
+const { resolveManifest } = require('../manifest');
+const { resolveManifestPath, loadEnv } = require('./shared');
+
+async function runResolveManifest(options) {
+  const manifestPath = options.manifest ? path.resolve(options.manifest) : resolveManifestPath(undefined);
+  loadEnv(manifestPath);
+
+  const manifest = resolveManifest(manifestPath, {
+    set:    options.set,
+    define: options.define,
+  });
+
+  if (options.json) {
+    process.stdout.write(JSON.stringify(manifest, null, 2) + '\n');
+    return;
+  }
+
+  logger.info('Resolved manifest:');
+  logger.dim(JSON.stringify(manifest, null, 2));
+}
+
+module.exports = { runResolveManifest };