rulesync-cli 0.1.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Masao Kitamura
+
+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/dist/index.js

@@ -0,0 +1,222 @@
+#!/usr/bin/env node
+
+// src/index.ts
+import { readFileSync as readFileSync3 } from "fs";
+import { Command } from "commander";
+
+// src/commands/login.ts
+import { createInterface } from "readline";
+
+// src/config.ts
+import { readFileSync, writeFileSync, existsSync } from "fs";
+import { join } from "path";
+import { homedir } from "os";
+var CONFIG_FILE = ".rulesync.json";
+var AUTH_DIR = join(homedir(), ".rulesync");
+var AUTH_FILE = join(AUTH_DIR, "auth.json");
+async function loadProjectConfig() {
+  const configPath = join(process.cwd(), CONFIG_FILE);
+  if (!existsSync(configPath)) return null;
+  const raw = readFileSync(configPath, "utf-8");
+  return JSON.parse(raw);
+}
+async function saveProjectConfig(config) {
+  const configPath = join(process.cwd(), CONFIG_FILE);
+  writeFileSync(configPath, JSON.stringify(config, null, 2) + "\n");
+}
+async function loadAuthConfig() {
+  if (!existsSync(AUTH_FILE)) return null;
+  const raw = readFileSync(AUTH_FILE, "utf-8");
+  return JSON.parse(raw);
+}
+async function saveAuthConfig(config) {
+  const { mkdirSync } = await import("fs");
+  mkdirSync(AUTH_DIR, { recursive: true });
+  writeFileSync(AUTH_FILE, JSON.stringify(config, null, 2) + "\n");
+}
+
+// src/commands/login.ts
+async function prompt(question) {
+  const rl = createInterface({ input: process.stdin, output: process.stdout });
+  return new Promise((resolve) => {
+    rl.question(question, (answer) => {
+      rl.close();
+      resolve(answer.trim());
+    });
+  });
+}
+async function login() {
+  console.log("RuleSync Login\n");
+  const apiKey = await prompt("API Key (from Settings page): ");
+  if (!apiKey.startsWith("rs_")) {
+    console.error("Invalid key format. Keys start with rs_");
+    process.exit(1);
+  }
+  const apiUrl = await prompt("API URL [http://localhost:3000]: ");
+  await saveAuthConfig({
+    apiKey,
+    apiUrl: apiUrl || "http://localhost:3000"
+  });
+  console.log("\nAuthenticated! Config saved to ~/.rulesync/auth.json");
+}
+
+// src/commands/init.ts
+import { createInterface as createInterface2 } from "readline";
+
+// src/api.ts
+async function apiRequest(path, options = {}) {
+  const authConfig = await loadAuthConfig();
+  if (!authConfig) {
+    throw new Error("Not authenticated. Run: rulesync login");
+  }
+  const url = `${authConfig.apiUrl}${path}`;
+  const res = await fetch(url, {
+    ...options,
+    headers: {
+      "Content-Type": "application/json",
+      Authorization: `Bearer ${authConfig.apiKey}`,
+      ...options.headers
+    }
+  });
+  if (!res.ok) {
+    const body = await res.text();
+    throw new Error(`API error ${res.status}: ${body}`);
+  }
+  return res.json();
+}
+
+// src/commands/init.ts
+async function prompt2(question, defaultValue) {
+  const rl = createInterface2({ input: process.stdin, output: process.stdout });
+  const suffix = defaultValue ? ` [${defaultValue}]` : "";
+  return new Promise((resolve) => {
+    rl.question(`${question}${suffix}: `, (answer) => {
+      rl.close();
+      resolve(answer.trim() || defaultValue || "");
+    });
+  });
+}
+async function init() {
+  console.log("RuleSync Init\n");
+  const projectName = await prompt2("Project name");
+  const outputFile = await prompt2("Output file", "CLAUDE.md");
+  let rulesets = [];
+  try {
+    rulesets = await apiRequest("/api/rulesets");
+  } catch {
+    console.log("(Could not fetch rulesets \u2014 you can add them manually)");
+  }
+  let selectedSlugs = [];
+  if (rulesets.length > 0) {
+    console.log("\nAvailable rulesets:");
+    rulesets.forEach((rs, i) => {
+      console.log(`  ${i + 1}. ${rs.name} (${rs.slug})`);
+    });
+    const selection = await prompt2(
+      "\nSelect rulesets (comma-separated numbers)"
+    );
+    if (selection) {
+      const indices = selection.split(",").map((s) => parseInt(s.trim()) - 1);
+      selectedSlugs = indices.filter((i) => i >= 0 && i < rulesets.length).map((i) => rulesets[i].slug);
+    }
+  }
+  await saveProjectConfig({
+    project: projectName,
+    output: outputFile,
+    rulesets: selectedSlugs
+  });
+  console.log(`
+Created .rulesync.json`);
+  console.log('Run "rulesync-cli pull" to sync your rules file.');
+}
+
+// src/commands/pull.ts
+import { writeFileSync as writeFileSync2 } from "fs";
+import { join as join2 } from "path";
+async function pull() {
+  const config = await loadProjectConfig();
+  if (!config) {
+    console.error("No .rulesync.json found. Run: rulesync-cli init");
+    process.exit(1);
+  }
+  console.log(
+    `Fetching rulesets: ${config.rulesets.join(", ")}...`
+  );
+  const data = await apiRequest(`/api/sync/${encodeURIComponent(config.project)}`);
+  const outputPath = join2(process.cwd(), config.output);
+  writeFileSync2(outputPath, data.content);
+  const rulesetInfo = data.rulesets.map((r) => `${r.slug}@v${r.version}`).join(", ");
+  console.log(
+    `Wrote ${config.output} (${data.rulesets.length} rulesets: ${rulesetInfo})`
+  );
+}
+
+// src/commands/push.ts
+import { readFileSync as readFileSync2, existsSync as existsSync2 } from "fs";
+import { join as join3 } from "path";
+import { createInterface as createInterface3 } from "readline";
+async function prompt3(question) {
+  const rl = createInterface3({ input: process.stdin, output: process.stdout });
+  return new Promise((resolve) => {
+    rl.question(question, (answer) => {
+      rl.close();
+      resolve(answer.trim());
+    });
+  });
+}
+async function push() {
+  const config = await loadProjectConfig();
+  if (!config) {
+    console.error("No .rulesync.json found. Run: rulesync-cli init");
+    process.exit(1);
+  }
+  const filePath = join3(process.cwd(), config.output);
+  if (!existsSync2(filePath)) {
+    console.error(`File not found: ${config.output}`);
+    process.exit(1);
+  }
+  const content = readFileSync2(filePath, "utf-8");
+  const slug = await prompt3("Upload to ruleset slug: ");
+  if (!slug) {
+    console.error("Slug is required.");
+    process.exit(1);
+  }
+  const result = await apiRequest(`/api/rulesets/${slug}/versions`, {
+    method: "POST",
+    body: JSON.stringify({ content })
+  });
+  console.log(`Published ${slug}@v${result.version}`);
+}
+
+// src/commands/status.ts
+async function status() {
+  const auth = await loadAuthConfig();
+  const config = await loadProjectConfig();
+  console.log("RuleSync Status\n");
+  if (auth) {
+    console.log(`Auth: Configured (${auth.apiUrl})`);
+    console.log(`Key:  ${auth.apiKey.slice(0, 12)}...`);
+  } else {
+    console.log("Auth: Not configured (run: rulesync-cli login)");
+  }
+  console.log("");
+  if (config) {
+    console.log(`Project:  ${config.project}`);
+    console.log(`Output:   ${config.output}`);
+    console.log(`Rulesets: ${config.rulesets.join(", ") || "(none)"}`);
+  } else {
+    console.log("Project: No .rulesync.json (run: rulesync-cli init)");
+  }
+}
+
+// src/index.ts
+var pkg = JSON.parse(readFileSync3(new URL("../package.json", import.meta.url), "utf-8"));
+var program = new Command();
+program.name("rulesync-cli").description("Sync CLAUDE.md files across repos via RuleSync").version(pkg.version);
+program.command("login").description("Authenticate with your RuleSync API key").action(login);
+program.command("init").description("Initialize .rulesync.json in the current project").action(init);
+program.command("pull").description("Fetch rulesets and write the rules file").action(pull);
+program.command("push").description("Upload local rules file as a new ruleset version").action(push);
+program.command("status").description("Show current config and auth status").action(status);
+program.action(pull);
+await program.parseAsync();

package/package.json

@@ -0,0 +1,40 @@
+{
+  "name": "rulesync-cli",
+  "version": "0.1.1",
+  "description": "CLI to sync CLAUDE.md files across repos via RuleSync",
+  "type": "module",
+  "license": "MIT",
+  "author": "Masao Kitamura <masaok@gmail.com>",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/masaok/rulesync-next.git"
+  },
+  "homepage": "https://rulesync.dev",
+  "keywords": [
+    "claude",
+    "claude-md",
+    "ai-rules",
+    "sync",
+    "cli",
+    "agents-md"
+  ],
+  "bin": {
+    "rulesync-cli": "dist/index.js"
+  },
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "tsup",
+    "dev": "tsup --watch",
+    "prepublishOnly": "tsup",
+    "release": "npm version patch && npm publish --access public"
+  },
+  "dependencies": {
+    "commander": "^13.0.0"
+  },
+  "devDependencies": {
+    "tsup": "^8.0.0",
+    "typescript": "^5.0.0"
+  }
+}