@archlinter/cli 0.1.0

package/bin/archlint.js

@@ -0,0 +1,123 @@
+#!/usr/bin/env node
+
+const { platform, arch } = process;
+const { existsSync } = require('fs');
+const { join } = require('path');
+const { spawnSync } = require('child_process');
+
+function getBinaryName() {
+  return platform === 'win32' ? 'archlint.exe' : 'archlint';
+}
+
+function isMusl() {
+  if (platform !== 'linux') return false;
+  try {
+    const { execSync } = require('child_process');
+    const output = execSync('ldd --version 2>&1 || true', { encoding: 'utf8' });
+    return output.includes('musl');
+  } catch {
+    try {
+      const os = require('fs').readFileSync('/etc/os-release', 'utf8');
+      return os.includes('Alpine');
+    } catch {
+      return false;
+    }
+  }
+}
+
+function getPlatformKey() {
+  const platformMap = {
+    darwin: {
+      arm64: 'darwin-arm64',
+      x64: 'darwin-x64',
+    },
+    linux: {
+      arm64: 'linux-arm64',
+      x64: isMusl() ? 'linux-x64-musl' : 'linux-x64',
+    },
+    win32: {
+      x64: 'win32-x64',
+    },
+  };
+
+  const platformArch = platformMap[platform]?.[arch];
+  if (!platformArch) {
+    throw new Error(
+      `Unsupported platform: ${platform}-${arch}. ` +
+      `Supported: darwin-arm64, darwin-x64, linux-x64, linux-arm64, linux-x64-musl, win32-x64`
+    );
+  }
+
+  return platformArch;
+}
+
+function getBinaryPath() {
+  const platformKey = getPlatformKey();
+  const binaryName = getBinaryName();
+
+  const possiblePaths = [
+    // 1. Local node_modules (npm/pnpm/yarn classic)
+    join(__dirname, '..', '..', `cli-${platformKey}`, 'bin', binaryName),
+    // 2. pnpm nested structure
+    join(__dirname, '..', 'node_modules', '@archlinter', `cli-${platformKey}`, 'bin', binaryName),
+    // 3. Development/Monorepo path
+    join(__dirname, '..', '..', '..', 'packages', `cli-${platformKey}`, 'bin', binaryName),
+  ];
+
+  for (const p of possiblePaths) {
+    if (existsSync(p)) {
+      return p;
+    }
+  }
+
+  // 4. Try require.resolve for package managers that support it
+  try {
+    const pkgName = `@archlinter/cli-${platformKey}`;
+    // We try to resolve the package directory. Since main/bin might not be index.js,
+    // we resolve the package.json path and go from there.
+    const pkgJsonPath = require.resolve(`${pkgName}/package.json`);
+    const pkgDir = join(pkgJsonPath, '..');
+    const p = join(pkgDir, 'bin', binaryName);
+    if (existsSync(p)) {
+      return p;
+    }
+  } catch {
+    // Package not installed or resolve failed
+  }
+
+  return null;
+}
+
+function run() {
+  const binaryPath = getBinaryPath();
+
+  if (!binaryPath) {
+    const platformKey = getPlatformKey();
+    console.error(`Error: Could not find archlint binary for ${platform}-${arch}`);
+    console.error('');
+    console.error('This usually means the optional dependency was not installed.');
+    console.error('Try running: npm install @archlinter/cli --force');
+    console.error('');
+    console.error(`Or install the platform-specific package directly:`);
+    console.error(`  npm install @archlinter/cli-${platformKey}`);
+    process.exit(1);
+  }
+
+  const result = spawnSync(binaryPath, process.argv.slice(2), {
+    stdio: 'inherit',
+    env: process.env,
+  });
+
+  if (result.error) {
+    if (result.error.code === 'EACCES') {
+      console.error(`Error: Permission denied. Try: chmod +x "${binaryPath}"`);
+    } else {
+      console.error(`Error running archlint: ${result.error.message}`);
+    }
+    process.exit(1);
+  }
+
+  process.exit(result.status ?? 0);
+}
+
+run();

package/package.json

@@ -0,0 +1,42 @@
+{
+  "name": "@archlinter/cli",
+  "version": "0.1.0",
+  "description": "Fast architecture smell detector for TypeScript/JavaScript",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/archlinter/archlint.git",
+    "directory": "packages/cli"
+  },
+  "homepage": "https://github.com/archlinter/archlint#readme",
+  "bugs": {
+    "url": "https://github.com/archlinter/archlint/issues"
+  },
+  "bin": {
+    "archlint": "bin/archlint.js"
+  },
+  "files": [
+    "bin",
+    "scripts"
+  ],
+  "optionalDependencies": {
+    "@archlinter/cli-darwin-arm64": "workspace:*",
+    "@archlinter/cli-darwin-x64": "workspace:*",
+    "@archlinter/cli-linux-x64": "workspace:*",
+    "@archlinter/cli-linux-arm64": "workspace:*",
+    "@archlinter/cli-linux-x64-musl": "workspace:*",
+    "@archlinter/cli-win32-x64": "workspace:*"
+  },
+  "engines": {
+    "node": ">=18"
+  },
+  "keywords": [
+    "architecture",
+    "lint",
+    "typescript",
+    "javascript",
+    "code-quality",
+    "static-analysis",
+    "cli"
+  ]
+}

package/scripts/platform.js

@@ -0,0 +1,24 @@
+// CLI platform detection helper
+const { platform, arch } = process;
+
+function isMusl() {
+  if (platform !== 'linux') return false;
+  const { execSync } = require('child_process');
+  try {
+    const output = execSync('ldd --version 2>&1 || true', { encoding: 'utf8' });
+    return output.includes('musl');
+  } catch {
+    return false;
+  }
+}
+
+function getPlatformKey() {
+  if (platform === 'darwin' && arch === 'arm64') return 'darwin-arm64';
+  if (platform === 'darwin' && arch === 'x64') return 'darwin-x64';
+  if (platform === 'linux' && arch === 'x64') return isMusl() ? 'linux-x64-musl' : 'linux-x64';
+  if (platform === 'linux' && arch === 'arm64') return 'linux-arm64';
+  if (platform === 'win32' && arch === 'x64') return 'win32-x64';
+  return null;
+}
+
+module.exports = { getPlatformKey };

package/scripts/postinstall.js

@@ -0,0 +1,9 @@
+// Postinstall script for @archlinter/cli
+const { getPlatformKey } = require('./platform');
+
+const platformKey = getPlatformKey();
+if (platformKey) {
+  console.log(`Successfully detected platform: ${platformKey}`);
+} else {
+  console.warn('Could not detect platform for @archlinter/cli');
+}