@rikalabs/repo-lint 0.1.0

package/bin/repo-lint

@@ -0,0 +1,23 @@
+#!/usr/bin/env node
+
+const { spawn } = require("child_process");
+const path = require("path");
+const fs = require("fs");
+
+const binName = process.platform === "win32" ? "repo-lint.exe" : "repo-lint";
+const binPath = path.join(__dirname, binName);
+
+if (!fs.existsSync(binPath)) {
+  console.error("repo-lint binary not found. Try reinstalling the package:");
+  console.error("  npm install repo-lint");
+  process.exit(1);
+}
+
+const child = spawn(binPath, process.argv.slice(2), {
+  stdio: "inherit",
+  shell: false,
+});
+
+child.on("close", (code) => {
+  process.exit(code ?? 0);
+});

package/index.js

@@ -0,0 +1,9 @@
+module.exports.defineConfig = (config) => config;
+module.exports.dir = (children) => ({ type: "dir", children: children || {} });
+module.exports.file = (pattern) => ({ type: "file", pattern });
+module.exports.opt = (node) => ({ ...node, optional: true });
+module.exports.param = (opts, child) => ({ type: "param", ...opts, child });
+module.exports.many = (optsOrChild, child) => {
+  if (child) return { type: "many", ...optsOrChild, child };
+  return { type: "many", child: optsOrChild };
+};

package/install.js

@@ -0,0 +1,129 @@
+#!/usr/bin/env node
+
+const { execSync, spawn } = require("child_process");
+const fs = require("fs");
+const path = require("path");
+const https = require("https");
+const os = require("os");
+const zlib = require("zlib");
+
+const PACKAGE_VERSION = require("./package.json").version;
+const REPO = "Rika-Labs/repo-lint";
+const BIN_NAME = process.platform === "win32" ? "repo-lint.exe" : "repo-lint";
+const BIN_DIR = path.join(__dirname, "bin");
+const BIN_PATH = path.join(BIN_DIR, BIN_NAME);
+
+function getPlatformInfo() {
+  const platform = os.platform();
+  const arch = os.arch();
+
+  const platformMap = {
+    darwin: {
+      x64: "repo-lint-darwin-x64",
+      arm64: "repo-lint-darwin-arm64",
+    },
+    linux: {
+      x64: "repo-lint-linux-x64",
+      arm64: "repo-lint-linux-arm64",
+    },
+    win32: {
+      x64: "repo-lint-windows-x64",
+    },
+  };
+
+  const archMap = platformMap[platform];
+  if (!archMap) {
+    throw new Error(`Unsupported platform: ${platform}`);
+  }
+
+  const binaryName = archMap[arch];
+  if (!binaryName) {
+    throw new Error(`Unsupported architecture: ${arch} on ${platform}`);
+  }
+
+  const ext = platform === "win32" ? ".zip" : ".tar.gz";
+  return { binaryName, ext, platform };
+}
+
+function downloadFile(url) {
+  return new Promise((resolve, reject) => {
+    const handleResponse = (response) => {
+      if (response.statusCode === 302 || response.statusCode === 301) {
+        https.get(response.headers.location, handleResponse).on("error", reject);
+        return;
+      }
+
+      if (response.statusCode !== 200) {
+        reject(new Error(`Failed to download: ${response.statusCode}`));
+        return;
+      }
+
+      const chunks = [];
+      response.on("data", (chunk) => chunks.push(chunk));
+      response.on("end", () => resolve(Buffer.concat(chunks)));
+      response.on("error", reject);
+    };
+
+    https.get(url, handleResponse).on("error", reject);
+  });
+}
+
+async function extractTarGz(buffer, destDir) {
+  const tar = require("tar");
+  const tmpFile = path.join(os.tmpdir(), `repo-lint-${Date.now()}.tar.gz`);
+  
+  fs.writeFileSync(tmpFile, buffer);
+  
+  await tar.extract({
+    file: tmpFile,
+    cwd: destDir,
+  });
+  
+  fs.unlinkSync(tmpFile);
+}
+
+async function extractZip(buffer, destDir) {
+  const AdmZip = require("adm-zip");
+  const zip = new AdmZip(buffer);
+  zip.extractAllTo(destDir, true);
+}
+
+async function install() {
+  try {
+    const { binaryName, ext, platform } = getPlatformInfo();
+    const version = `v${PACKAGE_VERSION}`;
+    const assetName = `${binaryName}${ext}`;
+    const url = `https://github.com/${REPO}/releases/download/${version}/${assetName}`;
+
+    console.log(`Downloading repo-lint ${version} for ${platform}...`);
+
+    if (!fs.existsSync(BIN_DIR)) {
+      fs.mkdirSync(BIN_DIR, { recursive: true });
+    }
+
+    const buffer = await downloadFile(url);
+
+    console.log("Extracting...");
+
+    if (ext === ".tar.gz") {
+      await extractTarGz(buffer, BIN_DIR);
+    } else {
+      await extractZip(buffer, BIN_DIR);
+    }
+
+    if (platform !== "win32") {
+      fs.chmodSync(BIN_PATH, 0o755);
+    }
+
+    console.log(`repo-lint installed successfully to ${BIN_PATH}`);
+  } catch (error) {
+    console.error("Failed to install repo-lint binary:", error.message);
+    console.error("");
+    console.error("You can install manually:");
+    console.error("  - Download from: https://github.com/Rika-Labs/repo-lint/releases");
+    console.error("  - Or install via cargo: cargo install repo-lint");
+    process.exit(1);
+  }
+}
+
+install();

package/package.json

@@ -0,0 +1,46 @@
+{
+  "name": "@rikalabs/repo-lint",
+  "version": "0.1.0",
+  "description": "High-performance filesystem layout linter with TypeScript DSL config",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/Rika-Labs/repo-lint"
+  },
+  "homepage": "https://github.com/Rika-Labs/repo-lint",
+  "bugs": {
+    "url": "https://github.com/Rika-Labs/repo-lint/issues"
+  },
+  "keywords": [
+    "linter",
+    "filesystem",
+    "structure",
+    "typescript",
+    "monorepo",
+    "architecture",
+    "lint"
+  ],
+  "main": "index.js",
+  "types": "types/index.d.ts",
+  "bin": {
+    "repo-lint": "./bin/repo-lint"
+  },
+  "files": [
+    "index.js",
+    "install.js",
+    "bin",
+    "types"
+  ],
+  "scripts": {
+    "postinstall": "node install.js"
+  },
+  "dependencies": {
+    "tar": "^7.0.0"
+  },
+  "optionalDependencies": {
+    "adm-zip": "^0.5.10"
+  },
+  "engines": {
+    "node": ">=16"
+  }
+}

package/types/index.d.ts

@@ -0,0 +1,74 @@
+export interface DefineConfigOptions {
+  mode?: "strict" | "warn";
+  layout: LayoutNode;
+  rules?: RulesConfig;
+  boundaries?: BoundariesConfig;
+  deps?: DepsConfig;
+}
+
+export type LayoutNode =
+  | DirNode
+  | FileNode
+  | ParamNode
+  | ManyNode;
+
+export interface DirNode {
+  type: "dir";
+  children: Record<string, LayoutNode>;
+  optional?: boolean;
+}
+
+export interface FileNode {
+  type: "file";
+  pattern?: string;
+  optional?: boolean;
+}
+
+export interface ParamNode {
+  type: "param";
+  name: string;
+  case: CaseStyle;
+  child: LayoutNode;
+}
+
+export interface ManyNode {
+  type: "many";
+  case?: CaseStyle;
+  child: LayoutNode;
+}
+
+export type CaseStyle = "kebab" | "snake" | "camel" | "pascal" | "any";
+
+export interface RulesConfig {
+  forbidPaths?: string[];
+  forbidNames?: string[];
+}
+
+export interface BoundariesConfig {
+  modules: string;
+  publicApi: string;
+  forbidDeepImports?: boolean;
+}
+
+export interface DepsAllowRule {
+  from: string;
+  to: string[];
+}
+
+export interface DepsConfig {
+  allow?: DepsAllowRule[];
+}
+
+export function defineConfig(options: DefineConfigOptions): DefineConfigOptions;
+
+export function dir(children?: Record<string, LayoutNode>): DirNode;
+export function file(pattern?: string): FileNode;
+export function opt<T extends LayoutNode>(node: T): T & { optional: true };
+export function param(
+  options: { case: CaseStyle; name?: string },
+  child: LayoutNode
+): ParamNode;
+export function many(
+  options: { case?: CaseStyle } | LayoutNode,
+  child?: LayoutNode
+): ManyNode;