npm - rulesync-cli - Versions diffs - 0.1.4 → 0.1.9 - Mend

rulesync-cli 0.1.4 → 0.1.9

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (2) hide show

package/dist/index.js +598 -54
package/package.json +4 -3

package/dist/index.js CHANGED Viewed

@@ -1,11 +1,12 @@
 #!/usr/bin/env node
 // src/index.ts
-import { readFileSync as readFileSync3 } from "fs";
+import { readFileSync as readFileSync4 } from "fs";
 import { Command } from "commander";
 // src/commands/login.ts
-import { createInterface } from "readline";
+import { createServer } from "http";
+import { execFile } from "child_process";
 // src/config.ts
 import { readFileSync, writeFileSync, existsSync } from "fs";
@@ -30,38 +31,89 @@ async function loadAuthConfig() {
   return JSON.parse(raw);
 }
 async function saveAuthConfig(config) {
-  const { mkdirSync } = await import("fs");
-  mkdirSync(AUTH_DIR, { recursive: true });
+  const { mkdirSync: mkdirSync2 } = await import("fs");
+  mkdirSync2(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());
-    });
-  });
+var PROD_URL = "https://rulesync.dev";
+function openBrowser(url) {
+  const platform = process.platform;
+  if (platform === "darwin") {
+    execFile("open", [url]);
+  } else if (platform === "win32") {
+    execFile("cmd", ["/c", "start", "", url]);
+  } else {
+    execFile("xdg-open", [url]);
+  }
 }
-async function login() {
+async function login(options) {
+  const devPort = options.port || "3000";
+  const apiUrl = options.dev ? `http://localhost:${devPort}` : PROD_URL;
   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(`Authenticating with ${apiUrl}...
+`);
+  const key = await waitForBrowserAuth(apiUrl);
+  await saveAuthConfig({ apiKey: key, apiUrl });
   console.log("\nAuthenticated! Config saved to ~/.rulesync/auth.json");
 }
+function waitForBrowserAuth(apiUrl) {
+  return new Promise((resolve, reject) => {
+    let timeout;
+    const server = createServer((req, res) => {
+      const url = new URL(req.url, `http://localhost`);
+      if (url.pathname === "/callback") {
+        const key = url.searchParams.get("key");
+        if (key) {
+          res.writeHead(200, { "Content-Type": "text/html" });
+          res.end(`
+            <html>
+              <body style="font-family: system-ui, sans-serif; display: flex; align-items: center; justify-content: center; min-height: 100vh; margin: 0; background: #0a0a0a; color: #ededed;">
+                <div style="text-align: center;">
+                  <h1 style="font-size: 1.25rem; margin-bottom: 0.5rem;">CLI Authorized</h1>
+                  <p style="color: #888;">You can close this tab and return to the terminal.</p>
+                </div>
+              </body>
+            </html>
+          `);
+          clearTimeout(timeout);
+          server.close();
+          resolve(key);
+        } else {
+          res.writeHead(400, { "Content-Type": "text/plain" });
+          res.end("Missing key parameter");
+        }
+        return;
+      }
+      res.writeHead(404);
+      res.end();
+    });
+    server.listen(0, () => {
+      const address = server.address();
+      if (!address || typeof address === "string") {
+        reject(new Error("Failed to start local server"));
+        return;
+      }
+      const port = address.port;
+      const authUrl = `${apiUrl}/cli/auth?callback_port=${port}`;
+      console.log(`Opening browser to authorize...
+`);
+      console.log(`If the browser doesn't open, visit:
+  ${authUrl}
+`);
+      console.log("Waiting for authorization...");
+      openBrowser(authUrl);
+    });
+    timeout = setTimeout(() => {
+      server.close();
+      reject(new Error("Login timed out after 5 minutes"));
+    }, 5 * 60 * 1e3);
+  });
+}
 // src/commands/init.ts
-import { createInterface as createInterface2 } from "readline";
+import { createInterface } from "readline";
 // src/api.ts
 async function apiRequest(path, options = {}) {
@@ -86,8 +138,8 @@ async function apiRequest(path, options = {}) {
 }
 // src/commands/init.ts
-async function prompt2(question, defaultValue) {
-  const rl = createInterface2({ input: process.stdin, output: process.stdout });
+async function prompt(question, defaultValue) {
+  const rl = createInterface({ input: process.stdin, output: process.stdout });
   const suffix = defaultValue ? ` [${defaultValue}]` : "";
   return new Promise((resolve) => {
     rl.question(`${question}${suffix}: `, (answer) => {
@@ -98,8 +150,8 @@ async function prompt2(question, defaultValue) {
 }
 async function init() {
   console.log("RuleSync Init\n");
-  const projectName = await prompt2("Project name");
-  const outputFile = await prompt2("Output file", "CLAUDE.md");
+  const projectName = await prompt("Project name (optional, press Enter to skip)");
+  const outputFile = await prompt("Output file", "CLAUDE.md");
   let rulesets = [];
   try {
     rulesets = await apiRequest("/api/rulesets");
@@ -112,7 +164,7 @@ async function init() {
     rulesets.forEach((rs, i) => {
       console.log(`  ${i + 1}. ${rs.name} (${rs.slug})`);
     });
-    const selection = await prompt2(
+    const selection = await prompt(
       "\nSelect rulesets (comma-separated numbers)"
     );
     if (selection) {
@@ -120,39 +172,531 @@ async function init() {
       selectedSlugs = indices.filter((i) => i >= 0 && i < rulesets.length).map((i) => rulesets[i].slug);
     }
   }
-  await saveProjectConfig({
-    project: projectName,
+  const config = {
     output: outputFile,
     rulesets: selectedSlugs
-  });
+  };
+  if (projectName) {
+    config.project = projectName;
+  }
+  await saveProjectConfig(config);
   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);
+import { writeFileSync as writeFileSync2, readFileSync as readFileSync2, existsSync as existsSync2, mkdirSync } from "fs";
+import { join as join2, dirname } from "path";
+import { createInterface as createInterface2 } from "readline";
+// ../../node_modules/.pnpm/diff@8.0.4/node_modules/diff/libesm/diff/base.js
+var Diff = class {
+  diff(oldStr, newStr, options = {}) {
+    let callback;
+    if (typeof options === "function") {
+      callback = options;
+      options = {};
+    } else if ("callback" in options) {
+      callback = options.callback;
+    }
+    const oldString = this.castInput(oldStr, options);
+    const newString = this.castInput(newStr, options);
+    const oldTokens = this.removeEmpty(this.tokenize(oldString, options));
+    const newTokens = this.removeEmpty(this.tokenize(newString, options));
+    return this.diffWithOptionsObj(oldTokens, newTokens, options, callback);
   }
-  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})`
+  diffWithOptionsObj(oldTokens, newTokens, options, callback) {
+    var _a;
+    const done = (value) => {
+      value = this.postProcess(value, options);
+      if (callback) {
+        setTimeout(function() {
+          callback(value);
+        }, 0);
+        return void 0;
+      } else {
+        return value;
+      }
+    };
+    const newLen = newTokens.length, oldLen = oldTokens.length;
+    let editLength = 1;
+    let maxEditLength = newLen + oldLen;
+    if (options.maxEditLength != null) {
+      maxEditLength = Math.min(maxEditLength, options.maxEditLength);
+    }
+    const maxExecutionTime = (_a = options.timeout) !== null && _a !== void 0 ? _a : Infinity;
+    const abortAfterTimestamp = Date.now() + maxExecutionTime;
+    const bestPath = [{ oldPos: -1, lastComponent: void 0 }];
+    let newPos = this.extractCommon(bestPath[0], newTokens, oldTokens, 0, options);
+    if (bestPath[0].oldPos + 1 >= oldLen && newPos + 1 >= newLen) {
+      return done(this.buildValues(bestPath[0].lastComponent, newTokens, oldTokens));
+    }
+    let minDiagonalToConsider = -Infinity, maxDiagonalToConsider = Infinity;
+    const execEditLength = () => {
+      for (let diagonalPath = Math.max(minDiagonalToConsider, -editLength); diagonalPath <= Math.min(maxDiagonalToConsider, editLength); diagonalPath += 2) {
+        let basePath;
+        const removePath = bestPath[diagonalPath - 1], addPath = bestPath[diagonalPath + 1];
+        if (removePath) {
+          bestPath[diagonalPath - 1] = void 0;
+        }
+        let canAdd = false;
+        if (addPath) {
+          const addPathNewPos = addPath.oldPos - diagonalPath;
+          canAdd = addPath && 0 <= addPathNewPos && addPathNewPos < newLen;
+        }
+        const canRemove = removePath && removePath.oldPos + 1 < oldLen;
+        if (!canAdd && !canRemove) {
+          bestPath[diagonalPath] = void 0;
+          continue;
+        }
+        if (!canRemove || canAdd && removePath.oldPos < addPath.oldPos) {
+          basePath = this.addToPath(addPath, true, false, 0, options);
+        } else {
+          basePath = this.addToPath(removePath, false, true, 1, options);
+        }
+        newPos = this.extractCommon(basePath, newTokens, oldTokens, diagonalPath, options);
+        if (basePath.oldPos + 1 >= oldLen && newPos + 1 >= newLen) {
+          return done(this.buildValues(basePath.lastComponent, newTokens, oldTokens)) || true;
+        } else {
+          bestPath[diagonalPath] = basePath;
+          if (basePath.oldPos + 1 >= oldLen) {
+            maxDiagonalToConsider = Math.min(maxDiagonalToConsider, diagonalPath - 1);
+          }
+          if (newPos + 1 >= newLen) {
+            minDiagonalToConsider = Math.max(minDiagonalToConsider, diagonalPath + 1);
+          }
+        }
+      }
+      editLength++;
+    };
+    if (callback) {
+      (function exec() {
+        setTimeout(function() {
+          if (editLength > maxEditLength || Date.now() > abortAfterTimestamp) {
+            return callback(void 0);
+          }
+          if (!execEditLength()) {
+            exec();
+          }
+        }, 0);
+      })();
+    } else {
+      while (editLength <= maxEditLength && Date.now() <= abortAfterTimestamp) {
+        const ret = execEditLength();
+        if (ret) {
+          return ret;
+        }
+      }
+    }
+  }
+  addToPath(path, added, removed, oldPosInc, options) {
+    const last = path.lastComponent;
+    if (last && !options.oneChangePerToken && last.added === added && last.removed === removed) {
+      return {
+        oldPos: path.oldPos + oldPosInc,
+        lastComponent: { count: last.count + 1, added, removed, previousComponent: last.previousComponent }
+      };
+    } else {
+      return {
+        oldPos: path.oldPos + oldPosInc,
+        lastComponent: { count: 1, added, removed, previousComponent: last }
+      };
+    }
+  }
+  extractCommon(basePath, newTokens, oldTokens, diagonalPath, options) {
+    const newLen = newTokens.length, oldLen = oldTokens.length;
+    let oldPos = basePath.oldPos, newPos = oldPos - diagonalPath, commonCount = 0;
+    while (newPos + 1 < newLen && oldPos + 1 < oldLen && this.equals(oldTokens[oldPos + 1], newTokens[newPos + 1], options)) {
+      newPos++;
+      oldPos++;
+      commonCount++;
+      if (options.oneChangePerToken) {
+        basePath.lastComponent = { count: 1, previousComponent: basePath.lastComponent, added: false, removed: false };
+      }
+    }
+    if (commonCount && !options.oneChangePerToken) {
+      basePath.lastComponent = { count: commonCount, previousComponent: basePath.lastComponent, added: false, removed: false };
+    }
+    basePath.oldPos = oldPos;
+    return newPos;
+  }
+  equals(left, right, options) {
+    if (options.comparator) {
+      return options.comparator(left, right);
+    } else {
+      return left === right || !!options.ignoreCase && left.toLowerCase() === right.toLowerCase();
+    }
+  }
+  removeEmpty(array) {
+    const ret = [];
+    for (let i = 0; i < array.length; i++) {
+      if (array[i]) {
+        ret.push(array[i]);
+      }
+    }
+    return ret;
+  }
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  castInput(value, options) {
+    return value;
+  }
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  tokenize(value, options) {
+    return Array.from(value);
+  }
+  join(chars) {
+    return chars.join("");
+  }
+  postProcess(changeObjects, options) {
+    return changeObjects;
+  }
+  get useLongestToken() {
+    return false;
+  }
+  buildValues(lastComponent, newTokens, oldTokens) {
+    const components = [];
+    let nextComponent;
+    while (lastComponent) {
+      components.push(lastComponent);
+      nextComponent = lastComponent.previousComponent;
+      delete lastComponent.previousComponent;
+      lastComponent = nextComponent;
+    }
+    components.reverse();
+    const componentLen = components.length;
+    let componentPos = 0, newPos = 0, oldPos = 0;
+    for (; componentPos < componentLen; componentPos++) {
+      const component = components[componentPos];
+      if (!component.removed) {
+        if (!component.added && this.useLongestToken) {
+          let value = newTokens.slice(newPos, newPos + component.count);
+          value = value.map(function(value2, i) {
+            const oldValue = oldTokens[oldPos + i];
+            return oldValue.length > value2.length ? oldValue : value2;
+          });
+          component.value = this.join(value);
+        } else {
+          component.value = this.join(newTokens.slice(newPos, newPos + component.count));
+        }
+        newPos += component.count;
+        if (!component.added) {
+          oldPos += component.count;
+        }
+      } else {
+        component.value = this.join(oldTokens.slice(oldPos, oldPos + component.count));
+        oldPos += component.count;
+      }
+    }
+    return components;
+  }
+};
+// ../../node_modules/.pnpm/diff@8.0.4/node_modules/diff/libesm/diff/line.js
+var LineDiff = class extends Diff {
+  constructor() {
+    super(...arguments);
+    this.tokenize = tokenize;
+  }
+  equals(left, right, options) {
+    if (options.ignoreWhitespace) {
+      if (!options.newlineIsToken || !left.includes("\n")) {
+        left = left.trim();
+      }
+      if (!options.newlineIsToken || !right.includes("\n")) {
+        right = right.trim();
+      }
+    } else if (options.ignoreNewlineAtEof && !options.newlineIsToken) {
+      if (left.endsWith("\n")) {
+        left = left.slice(0, -1);
+      }
+      if (right.endsWith("\n")) {
+        right = right.slice(0, -1);
+      }
+    }
+    return super.equals(left, right, options);
+  }
+};
+var lineDiff = new LineDiff();
+function diffLines(oldStr, newStr, options) {
+  return lineDiff.diff(oldStr, newStr, options);
+}
+function tokenize(value, options) {
+  if (options.stripTrailingCr) {
+    value = value.replace(/\r\n/g, "\n");
+  }
+  const retLines = [], linesAndNewlines = value.split(/(\n|\r\n)/);
+  if (!linesAndNewlines[linesAndNewlines.length - 1]) {
+    linesAndNewlines.pop();
+  }
+  for (let i = 0; i < linesAndNewlines.length; i++) {
+    const line = linesAndNewlines[i];
+    if (i % 2 && !options.newlineIsToken) {
+      retLines[retLines.length - 1] += line;
+    } else {
+      retLines.push(line);
+    }
+  }
+  return retLines;
+}
+// ../../node_modules/.pnpm/diff@8.0.4/node_modules/diff/libesm/patch/create.js
+function structuredPatch(oldFileName, newFileName, oldStr, newStr, oldHeader, newHeader, options) {
+  let optionsObj;
+  if (!options) {
+    optionsObj = {};
+  } else if (typeof options === "function") {
+    optionsObj = { callback: options };
+  } else {
+    optionsObj = options;
+  }
+  if (typeof optionsObj.context === "undefined") {
+    optionsObj.context = 4;
+  }
+  const context = optionsObj.context;
+  if (optionsObj.newlineIsToken) {
+    throw new Error("newlineIsToken may not be used with patch-generation functions, only with diffing functions");
+  }
+  if (!optionsObj.callback) {
+    return diffLinesResultToPatch(diffLines(oldStr, newStr, optionsObj));
+  } else {
+    const { callback } = optionsObj;
+    diffLines(oldStr, newStr, Object.assign(Object.assign({}, optionsObj), { callback: (diff) => {
+      const patch = diffLinesResultToPatch(diff);
+      callback(patch);
+    } }));
+  }
+  function diffLinesResultToPatch(diff) {
+    if (!diff) {
+      return;
+    }
+    diff.push({ value: "", lines: [] });
+    function contextLines(lines) {
+      return lines.map(function(entry) {
+        return " " + entry;
+      });
+    }
+    const hunks = [];
+    let oldRangeStart = 0, newRangeStart = 0, curRange = [], oldLine = 1, newLine = 1;
+    for (let i = 0; i < diff.length; i++) {
+      const current = diff[i], lines = current.lines || splitLines(current.value);
+      current.lines = lines;
+      if (current.added || current.removed) {
+        if (!oldRangeStart) {
+          const prev = diff[i - 1];
+          oldRangeStart = oldLine;
+          newRangeStart = newLine;
+          if (prev) {
+            curRange = context > 0 ? contextLines(prev.lines.slice(-context)) : [];
+            oldRangeStart -= curRange.length;
+            newRangeStart -= curRange.length;
+          }
+        }
+        for (const line of lines) {
+          curRange.push((current.added ? "+" : "-") + line);
+        }
+        if (current.added) {
+          newLine += lines.length;
+        } else {
+          oldLine += lines.length;
+        }
+      } else {
+        if (oldRangeStart) {
+          if (lines.length <= context * 2 && i < diff.length - 2) {
+            for (const line of contextLines(lines)) {
+              curRange.push(line);
+            }
+          } else {
+            const contextSize = Math.min(lines.length, context);
+            for (const line of contextLines(lines.slice(0, contextSize))) {
+              curRange.push(line);
+            }
+            const hunk = {
+              oldStart: oldRangeStart,
+              oldLines: oldLine - oldRangeStart + contextSize,
+              newStart: newRangeStart,
+              newLines: newLine - newRangeStart + contextSize,
+              lines: curRange
+            };
+            hunks.push(hunk);
+            oldRangeStart = 0;
+            newRangeStart = 0;
+            curRange = [];
+          }
+        }
+        oldLine += lines.length;
+        newLine += lines.length;
+      }
+    }
+    for (const hunk of hunks) {
+      for (let i = 0; i < hunk.lines.length; i++) {
+        if (hunk.lines[i].endsWith("\n")) {
+          hunk.lines[i] = hunk.lines[i].slice(0, -1);
+        } else {
+          hunk.lines.splice(i + 1, 0, "\");
+          i++;
+        }
+      }
+    }
+    return {
+      oldFileName,
+      newFileName,
+      oldHeader,
+      newHeader,
+      hunks
+    };
+  }
+}
+function splitLines(text) {
+  const hasTrailingNl = text.endsWith("\n");
+  const result = text.split("\n").map((line) => line + "\n");
+  if (hasTrailingNl) {
+    result.pop();
+  } else {
+    result.push(result.pop().slice(0, -1));
+  }
+  return result;
+}
+// src/commands/pull.ts
+var RED = "\x1B[31m";
+var GREEN = "\x1B[32m";
+var CYAN = "\x1B[36m";
+var DIM = "\x1B[2m";
+var BOLD = "\x1B[1m";
+var RESET = "\x1B[0m";
+async function prompt2(question) {
+  const rl = createInterface2({ input: process.stdin, output: process.stdout });
+  return new Promise((resolve) => {
+    rl.question(question, (answer) => {
+      rl.close();
+      resolve(answer.trim().toLowerCase());
+    });
+  });
+}
+function printDiff(filePath, oldContent, newContent) {
+  const patch = structuredPatch(filePath, filePath, oldContent, newContent, "current", "incoming");
+  for (const hunk of patch.hunks) {
+    console.log(`${CYAN}@@ -${hunk.oldStart},${hunk.oldLines} +${hunk.newStart},${hunk.newLines} @@${RESET}`);
+    for (const line of hunk.lines) {
+      if (line.startsWith("+")) {
+        console.log(`${GREEN}${line}${RESET}`);
+      } else if (line.startsWith("-")) {
+        console.log(`${RED}${line}${RESET}`);
+      } else {
+        console.log(`${DIM}${line}${RESET}`);
+      }
+    }
+  }
+}
+async function promptAction(filePath, fileIndex, totalFiles) {
+  const label = `${DIM}[${fileIndex + 1}/${totalFiles}]${RESET}`;
+  const answer = await prompt2(
+    `${label} Apply changes to ${BOLD}${filePath}${RESET}? [${GREEN}y${RESET}]es / [${RED}n${RESET}]o / [${CYAN}a${RESET}]ll / [${RED}c${RESET}]ancel: `
   );
+  switch (answer) {
+    case "y":
+    case "yes":
+      return "approve";
+    case "n":
+    case "no":
+      return "skip";
+    case "a":
+    case "all":
+      return "approve-all";
+    case "c":
+    case "cancel":
+      return "cancel";
+    default:
+      return "approve";
+  }
+}
+async function writeWithApproval(files) {
+  let approveAll = false;
+  let written = 0;
+  let skipped = 0;
+  for (let i = 0; i < files.length; i++) {
+    const file = files[i];
+    const outputPath = join2(process.cwd(), file.path);
+    const oldContent = existsSync2(outputPath) ? readFileSync2(outputPath, "utf-8") : "";
+    const stripTimestamp = (s) => s.replace(/^<!-- Last synced: .* -->\n/m, "");
+    if (stripTimestamp(oldContent) === stripTimestamp(file.content)) {
+      console.log(`${DIM}${file.path} \u2014 no changes (${file.info})${RESET}`);
+      continue;
+    }
+    const isNew = !existsSync2(outputPath);
+    console.log(`
+${BOLD}${isNew ? "New file" : "Modified"}: ${file.path}${RESET} (${file.info})`);
+    if (isNew) {
+      console.log(`${GREEN}+ ${file.content.split("\n").length} lines${RESET}`);
+    } else {
+      printDiff(file.path, oldContent, file.content);
+    }
+    if (!approveAll) {
+      const action = await promptAction(file.path, i, files.length);
+      if (action === "cancel") {
+        console.log(`
+Cancelled. ${written} file(s) written, ${files.length - i} skipped.`);
+        return;
+      }
+      if (action === "skip") {
+        skipped++;
+        continue;
+      }
+      if (action === "approve-all") {
+        approveAll = true;
+      }
+    }
+    mkdirSync(dirname(outputPath), { recursive: true });
+    writeFileSync2(outputPath, file.content);
+    written++;
+    console.log(`${GREEN}  \u2713 Wrote ${file.path}${RESET}`);
+  }
+  console.log(`
+Done. ${written} written, ${skipped} skipped.`);
+}
+async function pull(options) {
+  const config = await loadProjectConfig();
+  let data;
+  if (config && config.rulesets.length > 0) {
+    console.log(`Fetching rulesets: ${config.rulesets.join(", ")}...`);
+    if (config.project) {
+      data = await apiRequest(`/api/sync/${encodeURIComponent(config.project)}`);
+    } else {
+      data = await apiRequest("/api/sync", {
+        method: "POST",
+        body: JSON.stringify({ rulesets: config.rulesets })
+      });
+    }
+  } else {
+    console.log("No .rulesync.json found \u2014 syncing all rulesets in your account...");
+    data = await apiRequest("/api/sync");
+  }
+  const filesToWrite = [];
+  if (data.files && data.files.length > 0) {
+    for (const file of data.files) {
+      const info = file.rulesets.map((r) => `${r.slug}@v${r.version}`).join(", ");
+      filesToWrite.push({ path: file.path, content: file.content, info });
+    }
+  } else {
+    const output = config?.output || "CLAUDE.md";
+    const info = data.rulesets.map((r) => `${r.slug}@v${r.version}`).join(", ");
+    filesToWrite.push({ path: output, content: data.content, info });
+  }
+  if (options.yes) {
+    for (const file of filesToWrite) {
+      const outputPath = join2(process.cwd(), file.path);
+      mkdirSync(dirname(outputPath), { recursive: true });
+      writeFileSync2(outputPath, file.content);
+      console.log(`Wrote ${file.path} (${file.info})`);
+    }
+  } else {
+    await writeWithApproval(filesToWrite);
+  }
 }
 // src/commands/push.ts
-import { readFileSync as readFileSync2, existsSync as existsSync2 } from "fs";
+import { readFileSync as readFileSync3, existsSync as existsSync3 } from "fs";
 import { join as join3 } from "path";
 import { createInterface as createInterface3 } from "readline";
 async function prompt3(question) {
@@ -171,11 +715,11 @@ async function push() {
     process.exit(1);
   }
   const filePath = join3(process.cwd(), config.output);
-  if (!existsSync2(filePath)) {
+  if (!existsSync3(filePath)) {
     console.error(`File not found: ${config.output}`);
     process.exit(1);
   }
-  const content = readFileSync2(filePath, "utf-8");
+  const content = readFileSync3(filePath, "utf-8");
   const slug = await prompt3("Upload to ruleset slug: ");
   if (!slug) {
     console.error("Slug is required.");
@@ -210,12 +754,12 @@ async function status() {
 }
 // src/index.ts
-var pkg = JSON.parse(readFileSync3(new URL("../package.json", import.meta.url), "utf-8"));
+var pkg = JSON.parse(readFileSync4(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("login").description("Authenticate via browser login").option("--dev", "Use localhost instead of rulesync.dev").option("--port <port>", "Dev server port (default: 3000, requires --dev)").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("pull").description("Fetch rulesets and write the rules file").option("-y, --yes", "Skip interactive approval, write all files").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);

package/package.json CHANGED Viewed

@@ -1,6 +1,6 @@
 {
   "name": "rulesync-cli",
-  "version": "0.1.4",
+  "version": "0.1.9",
   "description": "CLI to sync CLAUDE.md files across repos via RuleSync",
   "type": "module",
   "license": "MIT",
@@ -28,10 +28,11 @@
     "build": "tsup",
     "dev": "tsup --watch",
     "prepublishOnly": "tsup",
-    "release": "npm version patch && npm publish --access public"
+    "release": "npm version patch --no-git-tag-version && npm publish --access public"
   },
   "dependencies": {
-    "commander": "^13.0.0"
+    "commander": "^13.0.0",
+    "diff": "^8.0.4"
   },
   "devDependencies": {
     "tsup": "^8.0.0",