@lousy-agents/cli 2.7.1 → 2.8.0

package/dist/mcp-server.js

@@ -45262,6 +45262,161 @@ async function watchConfig(options) {
     return new FileSystemEnvironmentGateway();
 }
 
+// EXTERNAL MODULE: external "node:child_process"
+var external_node_child_process_ = __webpack_require__(1421);
+;// CONCATENATED MODULE: ./src/gateways/github-ruleset-gateway.ts
+/**
+ * Gateway for interacting with GitHub repository rulesets via Octokit.
+ */ 
+
+
+
+const execFileAsync = (0,external_node_util_.promisify)(external_node_child_process_.execFile);
+const RulesetRuleSchema = schemas_object({
+    type: schemas_string(),
+    parameters: record(schemas_string(), unknown()).optional()
+});
+const RulesetSchema = schemas_object({
+    id: schemas_number(),
+    name: schemas_string(),
+    enforcement: schemas_string(),
+    rules: schemas_array(RulesetRuleSchema).optional()
+});
+/**
+ * Parses a GitHub remote URL to extract owner and repo name
+ */ function parseRepoFromRemoteUrl(remoteUrl) {
+    const httpsMatch = remoteUrl.match(/github\.com\/([\w-]+)\/([\w.-]+?)(?:\.git)?$/);
+    if (httpsMatch) {
+        return {
+            owner: httpsMatch[1],
+            repo: httpsMatch[2]
+        };
+    }
+    const sshMatch = remoteUrl.match(/github\.com:([\w-]+)\/([\w.-]+?)(?:\.git)?$/);
+    if (sshMatch) {
+        return {
+            owner: sshMatch[1],
+            repo: sshMatch[2]
+        };
+    }
+    return null;
+}
+function defaultExec(command, args, options) {
+    return execFileAsync(command, args, {
+        encoding: "utf-8",
+        maxBuffer: 10 * 1024 * 1024,
+        cwd: options?.cwd
+    });
+}
+/**
+ * Extracts a descriptive error message from an Octokit error, including HTTP status when available
+ */ function formatOctokitError(error) {
+    const message = error instanceof Error ? error.message : "";
+    const status = error instanceof Object && "status" in error ? error.status : undefined;
+    const parts = [];
+    if (typeof status === "number") {
+        parts.push(`status ${status}`);
+    }
+    if (message) {
+        parts.push(message);
+    }
+    return parts.length > 0 ? parts.join(" - ") : "Unknown error";
+}
+/**
+ * GitHub ruleset gateway implementation using Octokit
+ */ class OctokitRulesetGateway {
+    octokit;
+    exec;
+    constructor(octokit = null, exec = defaultExec){
+        this.octokit = octokit;
+        this.exec = exec;
+    }
+    async isAuthenticated() {
+        if (!this.octokit) {
+            return false;
+        }
+        try {
+            await this.octokit.rest.users.getAuthenticated();
+            return true;
+        } catch  {
+            return false;
+        }
+    }
+    async getRepoInfo(targetDir) {
+        try {
+            const { stdout } = await this.exec("git", [
+                "remote",
+                "get-url",
+                "origin"
+            ], {
+                cwd: targetDir
+            });
+            return parseRepoFromRemoteUrl(stdout.trim());
+        } catch  {
+            return null;
+        }
+    }
+    async listRulesets(owner, repo) {
+        if (!this.octokit) {
+            throw new Error("Not authenticated");
+        }
+        try {
+            const { data } = await this.octokit.rest.repos.getRepoRulesets({
+                owner,
+                repo
+            });
+            return z.array(RulesetSchema).parse(data);
+        } catch (error) {
+            const details = formatOctokitError(error);
+            throw new Error(`Failed to list rulesets for ${owner}/${repo}: ${details}`);
+        }
+    }
+    async createRuleset(owner, repo, payload) {
+        if (!this.octokit) {
+            throw new Error("Not authenticated");
+        }
+        try {
+            await this.octokit.rest.repos.createRepoRuleset({
+                owner,
+                repo,
+                ...payload
+            });
+        } catch (error) {
+            const details = formatOctokitError(error);
+            throw new Error(`Failed to create ruleset for ${owner}/${repo}: ${details}`);
+        }
+    }
+}
+/**
+ * Resolves a GitHub token from GH_TOKEN/GITHUB_TOKEN env vars, with gh CLI fallback
+ */ async function resolveGitHubToken() {
+    const envToken = process.env.GH_TOKEN || process.env.GITHUB_TOKEN;
+    if (envToken) {
+        return envToken;
+    }
+    try {
+        const { stdout } = await execFileAsync("gh", [
+            "auth",
+            "token"
+        ], {
+            encoding: "utf-8"
+        });
+        const token = stdout.trim();
+        return token || null;
+    } catch  {
+        return null;
+    }
+}
+/**
+ * Creates the default GitHub ruleset gateway with resolved auth token
+ */ async function createGitHubRulesetGateway() {
+    const token = await resolveGitHubToken();
+    const octokit = token ? new Octokit({
+        auth: token
+    }) : null;
+    return new OctokitRulesetGateway(octokit);
+}
+
 ;// CONCATENATED MODULE: ./src/gateways/instruction-analysis-gateway.ts
 /**
  * Gateway for analyzing repository instructions for feedback loop coverage
@@ -46119,6 +46274,7 @@ async function watchConfig(options) {
 
 
 
+
 ;// CONCATENATED MODULE: ./src/mcp/tools/types.ts
 /**
  * Shared types and utilities for MCP tool handlers.