reposuite 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 RepoSuite
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+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.

package/README.md

@@ -0,0 +1,46 @@
+# reposuite
+
+Developer toolkit for repo navigation, task automation, and browser control.
+
+## Install
+
+```bash
+npm i -g reposuite
+```
+
+## Usage
+
+```bash
+reposuite --help
+```
+
+## Supported platforms
+
+- macOS: amd64, arm64
+- Linux: amd64, arm64
+- Windows: amd64, arm64
+
+## Notes
+
+RepoSuite downloads platform-specific binaries from GitHub Releases during install.
+To install a specific release, set `REPOSUITE_VERSION` (example: `v1.2.3`).
+
+Optional alias (print-only, no auto changes):
+
+```bash
+alias rp="reposuite"
+```
+
+## Troubleshooting
+
+If installation fails with a download error, check that GitHub Releases are reachable from your network and try reinstalling:
+
+```bash
+npm i -g reposuite
+```
+
+You can validate the installer flow without downloads:
+
+```bash
+npm run smoke:install
+```

package/RELEASE.md

@@ -0,0 +1,10 @@
+# Release checklist
+
+1. Tag the private Go repo with the release version.
+2. Confirm binaries are uploaded to GitHub Releases under `vX.Y.Z`.
+3. Bump npm wrapper version in `package.json`.
+4. Run `npm pack` and validate contents.
+5. Run `npm publish`.
+6. Verify with `npm view reposuite` and install test.
+7. Optionally run `npm run smoke:install` to validate installer scaffolding.
+8. If testing a specific release asset, set `REPOSUITE_VERSION=vX.Y.Z` before install.

package/bin/reposuite.js

@@ -0,0 +1,63 @@
+#!/usr/bin/env node
+const path = require("path");
+const { spawn } = require("child_process");
+
+function normalizePlatform(platform) {
+  if (platform === "darwin") return "darwin";
+  if (platform === "linux") return "linux";
+  if (platform === "win32") return "windows";
+  return null;
+}
+
+function normalizeArch(arch) {
+  if (arch === "x64") return "amd64";
+  if (arch === "arm64") return "arm64";
+  return null;
+}
+
+const platform = normalizePlatform(process.platform);
+const arch = normalizeArch(process.arch);
+
+if (!platform || !arch) {
+  console.error(
+    `Unsupported platform or architecture: ${process.platform}/${process.arch}`
+  );
+  process.exit(1);
+}
+
+const exeName = platform === "windows" ? "reposuite.exe" : "reposuite";
+const binPath = path.join(
+  __dirname,
+  "..",
+  ".reposuite",
+  "bin",
+  platform,
+  arch,
+  exeName
+);
+
+try {
+  require("fs").accessSync(binPath);
+} catch (error) {
+  console.error("RepoSuite binary not found.");
+  console.error(`Expected path: ${binPath}`);
+  console.error(
+    "Reinstall the package or run `node scripts/install.js` from this directory."
+  );
+  process.exit(1);
+}
+
+const child = spawn(binPath, process.argv.slice(2), { stdio: "inherit" });
+
+child.on("exit", (code, signal) => {
+  if (signal) {
+    process.kill(process.pid, signal);
+    return;
+  }
+  process.exit(code === null ? 1 : code);
+});
+
+child.on("error", (error) => {
+  console.error(`Failed to start RepoSuite: ${error.message}`);
+  process.exit(1);
+});

package/package.json

@@ -0,0 +1,23 @@
+{
+  "name": "reposuite",
+  "version": "0.1.0",
+  "description": "Developer toolkit for repo navigation, task automation, and browser control.",
+  "license": "MIT",
+  "bin": {
+    "reposuite": "bin/reposuite.js"
+  },
+  "scripts": {
+    "postinstall": "node scripts/install.js",
+    "smoke:install": "node scripts/smoke-install.js"
+  },
+  "files": [
+    "bin/",
+    "scripts/",
+    "README.md",
+    "LICENSE",
+    "RELEASE.md"
+  ],
+  "engines": {
+    "node": ">=18"
+  }
+}

package/scripts/install.js

@@ -0,0 +1,282 @@
+const fs = require("fs");
+const os = require("os");
+const path = require("path");
+const https = require("https");
+const crypto = require("crypto");
+const { spawnSync } = require("child_process");
+
+function normalizePlatform(platform) {
+  if (platform === "darwin") return "darwin";
+  if (platform === "linux") return "linux";
+  if (platform === "win32") return "windows";
+  return null;
+}
+
+function normalizeArch(arch) {
+  if (arch === "x64") return "amd64";
+  if (arch === "arm64") return "arm64";
+  return null;
+}
+
+const platform = normalizePlatform(process.platform);
+const arch = normalizeArch(process.arch);
+
+if (!platform || !arch) {
+  console.error(
+    `Unsupported platform or architecture: ${process.platform}/${process.arch}`
+  );
+  process.exit(1);
+}
+
+const owner = process.env.REPOSUITE_OWNER || "reposuite";
+const repo = process.env.REPOSUITE_REPO || "reposuite";
+
+let version = process.env.REPOSUITE_VERSION;
+if (!version) {
+  const pkgPath = path.join(__dirname, "..", "package.json");
+  const pkg = JSON.parse(fs.readFileSync(pkgPath, "utf8"));
+  version = `v${pkg.version}`;
+}
+
+const asset =
+  platform === "windows"
+    ? `reposuite_windows_${arch}.zip`
+    : `reposuite_${platform}_${arch}.tar.gz`;
+
+const url = `https://github.com/${owner}/${repo}/releases/download/${version}/${asset}`;
+const checksumsUrl = `https://github.com/${owner}/${repo}/releases/download/${version}/checksums.txt`;
+const targetDir = path.join(
+  __dirname,
+  "..",
+  ".reposuite",
+  "bin",
+  platform,
+  arch
+);
+const exeName = platform === "windows" ? "reposuite.exe" : "reposuite";
+
+function downloadToFile(sourceUrl, destPath, redirects = 0) {
+  if (redirects > 5) {
+    return Promise.reject(new Error("Too many redirects"));
+  }
+
+  return new Promise((resolve, reject) => {
+    https
+      .get(sourceUrl, (res) => {
+        const redirect =
+          res.statusCode >= 300 &&
+          res.statusCode < 400 &&
+          res.headers.location;
+        if (redirect) {
+          res.resume();
+          resolve(downloadToFile(res.headers.location, destPath, redirects + 1));
+          return;
+        }
+
+        if (res.statusCode !== 200) {
+          res.resume();
+          reject(
+            new Error(`Download failed (${res.statusCode}) from ${sourceUrl}`)
+          );
+          return;
+        }
+
+        const file = fs.createWriteStream(destPath);
+        res.pipe(file);
+        file.on("finish", () => file.close(resolve));
+        file.on("error", (error) => {
+          file.close(() => reject(error));
+        });
+      })
+      .on("error", reject);
+  });
+}
+
+function downloadToString(sourceUrl, redirects = 0) {
+  if (redirects > 5) {
+    return Promise.reject(new Error("Too many redirects"));
+  }
+
+  return new Promise((resolve, reject) => {
+    https
+      .get(sourceUrl, (res) => {
+        const redirect =
+          res.statusCode >= 300 &&
+          res.statusCode < 400 &&
+          res.headers.location;
+        if (redirect) {
+          res.resume();
+          resolve(downloadToString(res.headers.location, redirects + 1));
+          return;
+        }
+
+        if (res.statusCode === 404) {
+          res.resume();
+          resolve(null);
+          return;
+        }
+
+        if (res.statusCode !== 200) {
+          res.resume();
+          reject(
+            new Error(`Download failed (${res.statusCode}) from ${sourceUrl}`)
+          );
+          return;
+        }
+
+        let data = "";
+        res.setEncoding("utf8");
+        res.on("data", (chunk) => {
+          data += chunk;
+        });
+        res.on("end", () => resolve(data));
+      })
+      .on("error", reject);
+  });
+}
+
+function sha256File(filePath) {
+  return new Promise((resolve, reject) => {
+    const hash = crypto.createHash("sha256");
+    const stream = fs.createReadStream(filePath);
+    stream.on("data", (chunk) => hash.update(chunk));
+    stream.on("end", () => resolve(hash.digest("hex")));
+    stream.on("error", reject);
+  });
+}
+
+function extractArchive(archivePath) {
+  if (platform === "windows") {
+    const result = spawnSync(
+      "powershell.exe",
+      [
+        "-NoProfile",
+        "-Command",
+        `Expand-Archive -Path "${archivePath}" -DestinationPath "${targetDir}" -Force`,
+      ],
+      { stdio: "inherit" }
+    );
+    if (result.status !== 0) {
+      throw new Error("Failed to extract zip archive.");
+    }
+    return;
+  }
+
+  const result = spawnSync(
+    "tar",
+    ["-xzf", archivePath, "-C", targetDir],
+    { stdio: "inherit" }
+  );
+  if (result.status !== 0) {
+    throw new Error("Failed to extract tar.gz archive.");
+  }
+}
+
+function findFileRecursive(dir, name) {
+  const entries = fs.readdirSync(dir, { withFileTypes: true });
+  for (const entry of entries) {
+    const fullPath = path.join(dir, entry.name);
+    if (entry.isFile() && entry.name === name) {
+      return fullPath;
+    }
+    if (entry.isDirectory()) {
+      const found = findFileRecursive(fullPath, name);
+      if (found) return found;
+    }
+  }
+  return null;
+}
+
+async function verifyChecksum(archivePath) {
+  const checksumText = await downloadToString(checksumsUrl);
+  if (!checksumText) {
+    throw new Error(
+      "checksums.txt not found. Expected a file containing lines like: <sha256> <asset>"
+    );
+  }
+
+  const lines = checksumText
+    .split(/\r?\n/)
+    .map((value) => value.trim())
+    .filter(Boolean);
+
+  let expected = null;
+  for (const line of lines) {
+    const parts = line.split(/\s+/);
+    if (parts.length < 2) continue;
+    const name = parts[1].replace(/^\*/, "");
+    if (name === asset) {
+      expected = parts[0];
+      break;
+    }
+  }
+
+  if (!expected) {
+    throw new Error(
+      `Checksum entry not found. Expected a line like: <sha256> *${asset}`
+    );
+  }
+  const actual = await sha256File(archivePath);
+  if (expected !== actual) {
+    throw new Error("Checksum validation failed.");
+  }
+  console.log("Checksum validated.");
+}
+
+async function main() {
+  fs.mkdirSync(targetDir, { recursive: true });
+
+  console.log(`Platform: ${platform}`);
+  console.log(`Architecture: ${arch}`);
+  console.log(`Asset: ${asset}`);
+  console.log(`URL: ${url}`);
+  console.log(`Target directory: ${targetDir}`);
+
+  if (version === "v0.0.0") {
+    console.log(
+      "Version is v0.0.0; skipping download. Set REPOSUITE_VERSION to install a release."
+    );
+    return;
+  }
+
+  const tempDir = fs.mkdtempSync(path.join(os.tmpdir(), "reposuite-"));
+  const archivePath = path.join(tempDir, asset);
+
+  try {
+    console.log("Downloading release asset...");
+    await downloadToFile(url, archivePath);
+    await verifyChecksum(archivePath);
+    console.log("Extracting archive...");
+    extractArchive(archivePath);
+
+    const desiredPath = path.join(targetDir, exeName);
+    let binPath = fs.existsSync(desiredPath)
+      ? desiredPath
+      : findFileRecursive(targetDir, exeName);
+
+    if (!binPath) {
+      throw new Error("RepoSuite binary not found after extraction.");
+    }
+
+    if (binPath !== desiredPath) {
+      fs.copyFileSync(binPath, desiredPath);
+      if (binPath !== desiredPath) {
+        fs.unlinkSync(binPath);
+      }
+      binPath = desiredPath;
+    }
+
+    if (platform !== "windows") {
+      fs.chmodSync(binPath, 0o755);
+    }
+
+    console.log(`Installed binary: ${binPath}`);
+  } finally {
+    fs.rmSync(tempDir, { recursive: true, force: true });
+  }
+}
+
+main().catch((error) => {
+  console.error(`Install failed: ${error.message}`);
+  process.exit(1);
+});

package/scripts/smoke-install.js

@@ -0,0 +1,9 @@
+const { spawnSync } = require("child_process");
+const path = require("path");
+
+const result = spawnSync("node", [path.join(__dirname, "install.js")], {
+  stdio: "inherit",
+  env: { ...process.env, REPOSUITE_VERSION: "v0.0.0" },
+});
+
+process.exit(result.status === null ? 1 : result.status);