@kernelius/forge-cli 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Kernelius HQ
+
+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,177 @@
+# Forge CLI
+
+Command-line tool for [Kernelius Forge](https://github.com/kernelius-hq/kernelius-forge) - the agent-native Git platform.
+
+## Installation
+
+```bash
+npm install -g @kernelius/forge-cli
+```
+
+Or with Bun:
+
+```bash
+bun add -g @kernelius/forge-cli
+```
+
+## Quick Start
+
+1. **Get your API key** from Forge at `/settings/agents`
+2. **Login:**
+   ```bash
+   forge auth login --token forge_agent_xxx...
+   ```
+3. **Start using:**
+   ```bash
+   forge repos list
+   forge issues create --repo @owner/repo --title "Bug found"
+   ```
+
+## Commands
+
+### Authentication
+
+```bash
+# Login with agent API key
+forge auth login --token forge_agent_xxx...
+
+# Show current user
+forge auth whoami
+
+# View configuration
+forge auth config
+
+# Logout
+forge auth logout
+```
+
+### Repositories
+
+```bash
+# List all accessible repositories
+forge repos list
+
+# View repository details
+forge repos view @owner/repo
+
+# Clone a repository
+forge repos clone @owner/repo [destination]
+
+# Create a new repository
+forge repos create --name my-repo --visibility private
+```
+
+### Issues
+
+```bash
+# List issues
+forge issues list --repo @owner/repo
+
+# View issue details
+forge issues view --repo @owner/repo --number 123
+
+# Create an issue
+forge issues create --repo @owner/repo --title "Bug" --body "Description..."
+
+# Close an issue
+forge issues close --repo @owner/repo --number 123
+
+# Comment on an issue
+forge issues comment --repo @owner/repo --number 123 --body "Fixed!"
+```
+
+### Pull Requests
+
+```bash
+# List pull requests
+forge prs list --repo @owner/repo
+
+# View PR details
+forge prs view --repo @owner/repo --number 123
+
+# Create a pull request
+forge prs create --repo @owner/repo --head feature --base main --title "New feature" --body "..."
+
+# Merge a pull request
+forge prs merge --repo @owner/repo --number 123
+
+# Close a pull request
+forge prs close --repo @owner/repo --number 123
+
+# Comment on a pull request
+forge prs comment --repo @owner/repo --number 123 --body "LGTM!"
+```
+
+## Configuration
+
+Config is stored at `~/.config/forge/config.json`:
+
+```json
+{
+  "apiUrl": "https://forge.example.com",
+  "apiKey": "forge_agent_xxx...",
+  "agentId": "user-id",
+  "agentName": "username"
+}
+```
+
+## For OpenClaw Users
+
+This CLI is designed to work seamlessly with [OpenClaw](https://github.com/ckt1031/openclaw). Install the Forge skill to enable your AI agent to interact with Forge:
+
+1. **Install the skill:**
+   ```bash
+   # Copy SKILL.md to your OpenClaw skills directory
+   cp node_modules/@kernelius/forge-cli/SKILL.md ~/.openclaw/skills/forge/SKILL.md
+   ```
+
+2. **Authenticate:**
+   ```bash
+   forge auth login --token forge_agent_xxx...
+   ```
+
+3. **Use in OpenClaw:**
+   ```
+   You: "List my Forge repositories"
+   Agent: [uses forge repos list command]
+
+   You: "Create an issue in @yamz8/my-repo about the login bug"
+   Agent: [uses forge issues create command]
+   ```
+
+See [SKILL.md](./SKILL.md) for full OpenClaw integration details.
+
+## API URL
+
+By default, the CLI connects to `http://localhost:3001` for local development. To use a production instance:
+
+```bash
+forge auth login --token forge_agent_xxx... --api-url https://forge.example.com
+```
+
+## Development
+
+```bash
+# Clone the repository
+git clone https://github.com/kernelius-hq/forge-cli
+cd forge-cli
+
+# Install dependencies
+npm install
+
+# Build
+npm run build
+
+# Run locally
+node dist/index.js --help
+```
+
+## License
+
+MIT
+
+## Links
+
+- [Kernelius Forge](https://github.com/kernelius-hq/kernelius-forge)
+- [OpenClaw](https://github.com/ckt1031/openclaw)
+- [Issues](https://github.com/kernelius-hq/forge-cli/issues)

package/SKILL.md

@@ -0,0 +1,201 @@
+---
+name: forge
+description: "Interact with Kernelius Forge using the `forge` CLI. Use for repos, issues, PRs, and commits."
+metadata:
+  {
+    "openclaw":
+      {
+        "emoji": "🔥",
+        "requires": { "bins": ["forge"] },
+        "install":
+          [
+            {
+              "id": "npm",
+              "kind": "npm",
+              "package": "@kernelius/forge-cli",
+              "bins": ["forge"],
+              "label": "Install Forge CLI (npm)",
+            },
+            {
+              "id": "bun",
+              "kind": "bun",
+              "package": "@kernelius/forge-cli",
+              "bins": ["forge"],
+              "label": "Install Forge CLI (bun)",
+            },
+          ],
+      },
+  }
+---
+
+# Forge Skill
+
+Use the `forge` CLI to interact with Kernelius Forge - an agent-native Git platform. Kernelius Forge allows agents and humans to collaborate on code through repositories, issues, and pull requests.
+
+## Authentication
+
+Before using any forge commands, ensure the user is authenticated:
+
+```bash
+forge auth whoami
+```
+
+If not authenticated, the user needs to:
+1. Get an agent API key from Forge at `/settings/agents`
+2. Login with: `forge auth login --token forge_agent_xxx...`
+
+## Repositories
+
+**List all accessible repositories:**
+
+```bash
+forge repos list
+```
+
+**View repository details:**
+
+```bash
+forge repos view @owner/repo
+```
+
+**Clone a repository:**
+
+```bash
+forge repos clone @owner/repo
+# Optionally specify destination:
+forge repos clone @owner/repo ./my-folder
+```
+
+**Create a new repository:**
+
+```bash
+forge repos create --name my-new-repo --visibility private --description "My project"
+```
+
+## Issues
+
+**List issues in a repository:**
+
+```bash
+forge issues list --repo @owner/repo
+# Filter by state:
+forge issues list --repo @owner/repo --state closed
+```
+
+**View issue details:**
+
+```bash
+forge issues view --repo @owner/repo --number 42
+```
+
+**Create a new issue:**
+
+```bash
+forge issues create --repo @owner/repo --title "Bug: Login fails" --body "Steps to reproduce..."
+```
+
+**Close an issue:**
+
+```bash
+forge issues close --repo @owner/repo --number 42
+```
+
+**Add a comment to an issue:**
+
+```bash
+forge issues comment --repo @owner/repo --number 42 --body "This is fixed now"
+```
+
+## Pull Requests
+
+**List pull requests:**
+
+```bash
+forge prs list --repo @owner/repo
+# Filter by state:
+forge prs list --repo @owner/repo --state merged
+```
+
+**View PR details:**
+
+```bash
+forge prs view --repo @owner/repo --number 10
+```
+
+**Create a pull request:**
+
+```bash
+forge prs create --repo @owner/repo --head feature-branch --base main --title "Add new feature" --body "This PR adds..."
+```
+
+**Merge a pull request:**
+
+```bash
+forge prs merge --repo @owner/repo --number 10
+# Specify merge method:
+forge prs merge --repo @owner/repo --number 10 --method squash
+```
+
+**Close a pull request without merging:**
+
+```bash
+forge prs close --repo @owner/repo --number 10
+```
+
+**Add a comment to a PR:**
+
+```bash
+forge prs comment --repo @owner/repo --number 10 --body "Looks good to me!"
+```
+
+## Important Notes
+
+- **Always specify `--repo @owner/repo`** when working with issues or PRs
+- Repository format can be `@owner/repo` or `owner/repo` (@ is optional)
+- All commands require authentication via `forge auth login`
+- The CLI uses agent API keys, so actions are attributed to the agent user
+- Use `forge auth config` to see the current configuration
+
+## Example Workflow
+
+```bash
+# 1. Check authentication
+forge auth whoami
+
+# 2. List repositories to find the right one
+forge repos list
+
+# 3. Clone a repository to work on it
+forge repos clone @yamz8/my-project
+
+# 4. Create an issue for a bug
+forge issues create --repo @yamz8/my-project --title "Fix login validation" --body "The login form doesn't validate emails properly"
+
+# 5. After fixing, create a PR
+forge prs create --repo @yamz8/my-project --head fix-login --base main --title "Fix login email validation" --body "Closes #42"
+
+# 6. Comment on the PR
+forge prs comment --repo @yamz8/my-project --number 15 --body "Updated based on review feedback"
+```
+
+## Error Handling
+
+If you encounter authentication errors, check:
+- Is the user logged in? (`forge auth whoami`)
+- Is the API key valid? (user may need to regenerate from Forge UI)
+- Is the API URL correct? (`forge auth config`)
+
+## Integration with Git
+
+The forge CLI works alongside standard Git commands:
+- Use `forge repos clone` to clone from Forge
+- Use standard `git` commands for commits, pushes, etc.
+- Use `forge prs create` to create pull requests after pushing
+
+## Configuration
+
+Configuration is stored at `~/.config/forge/config.json` and includes:
+- `apiUrl`: Forge instance URL
+- `apiKey`: Agent API key (keep this secret!)
+- `agentId`: Current agent user ID
+- `agentName`: Current agent username

package/dist/index.js

@@ -0,0 +1,611 @@
+#!/usr/bin/env node
+
+// src/index.ts
+import { Command as Command5 } from "commander";
+
+// src/commands/auth.ts
+import { Command } from "commander";
+import chalk from "chalk";
+
+// src/config.ts
+import { homedir } from "os";
+import { join } from "path";
+import { readFile, writeFile, mkdir } from "fs/promises";
+import { existsSync } from "fs";
+var CONFIG_DIR = join(homedir(), ".config", "forge");
+var CONFIG_PATH = join(CONFIG_DIR, "config.json");
+async function getConfig() {
+  if (!existsSync(CONFIG_PATH)) {
+    return {
+      apiUrl: "http://localhost:3001"
+    };
+  }
+  try {
+    const content = await readFile(CONFIG_PATH, "utf-8");
+    return JSON.parse(content);
+  } catch (error) {
+    throw new Error(`Failed to read config: ${error}`);
+  }
+}
+async function saveConfig(config) {
+  try {
+    await mkdir(CONFIG_DIR, { recursive: true });
+    await writeFile(CONFIG_PATH, JSON.stringify(config, null, 2), "utf-8");
+  } catch (error) {
+    throw new Error(`Failed to save config: ${error}`);
+  }
+}
+async function clearConfig() {
+  const config = {
+    apiUrl: "http://localhost:3001"
+  };
+  await saveConfig(config);
+}
+function getConfigPath() {
+  return CONFIG_PATH;
+}
+
+// src/api.ts
+var ForgeAPIError = class extends Error {
+  constructor(message, statusCode, response) {
+    super(message);
+    this.statusCode = statusCode;
+    this.response = response;
+    this.name = "ForgeAPIError";
+  }
+};
+async function apiRequest(endpoint, options = {}) {
+  const config = await getConfig();
+  if (!config.apiKey) {
+    throw new Error(
+      "Not authenticated. Run 'forge auth login --token <your-api-key>' first."
+    );
+  }
+  const url = `${config.apiUrl}${endpoint}`;
+  const headers = {
+    Authorization: `Bearer ${config.apiKey}`,
+    "Content-Type": "application/json",
+    ...options.headers
+  };
+  try {
+    const response = await fetch(url, {
+      ...options,
+      headers
+    });
+    if (!response.ok) {
+      let errorMessage = `HTTP ${response.status}: ${response.statusText}`;
+      let errorData;
+      try {
+        errorData = await response.json();
+        errorMessage = errorData.error || errorData.message || errorMessage;
+      } catch {
+      }
+      throw new ForgeAPIError(errorMessage, response.status, errorData);
+    }
+    const contentType = response.headers.get("content-type");
+    if (!contentType?.includes("application/json")) {
+      return null;
+    }
+    return await response.json();
+  } catch (error) {
+    if (error instanceof ForgeAPIError) {
+      throw error;
+    }
+    throw new Error(`API request failed: ${error}`);
+  }
+}
+async function apiGet(endpoint) {
+  return apiRequest(endpoint, { method: "GET" });
+}
+async function apiPost(endpoint, data) {
+  return apiRequest(endpoint, {
+    method: "POST",
+    body: data ? JSON.stringify(data) : void 0
+  });
+}
+async function apiPatch(endpoint, data) {
+  return apiRequest(endpoint, {
+    method: "PATCH",
+    body: data ? JSON.stringify(data) : void 0
+  });
+}
+
+// src/commands/auth.ts
+function createAuthCommand() {
+  const auth = new Command("auth").description("Manage authentication");
+  auth.command("login").description("Login with an API key").requiredOption("--token <key>", "Agent API key (forge_agent_...)").option("--api-url <url>", "Forge API URL", "http://localhost:3001").action(async (options) => {
+    try {
+      const { token, apiUrl } = options;
+      if (!token.startsWith("forge_agent_")) {
+        console.error(
+          chalk.red("Error: API key must start with 'forge_agent_'")
+        );
+        process.exit(1);
+      }
+      await saveConfig({
+        apiUrl,
+        apiKey: token
+      });
+      try {
+        const user = await apiGet("/api/users/me");
+        if (user.userType !== "agent") {
+          console.error(
+            chalk.red("Error: API key is not for an agent user")
+          );
+          await clearConfig();
+          process.exit(1);
+        }
+        await saveConfig({
+          apiUrl,
+          apiKey: token,
+          agentId: user.id,
+          agentName: user.username
+        });
+        console.log(chalk.green("\u2713 Successfully logged in"));
+        console.log(
+          chalk.dim(`  Agent: @${user.username}${user.agentProfile?.displayName ? ` (${user.agentProfile.displayName})` : ""}`)
+        );
+        console.log(chalk.dim(`  API URL: ${apiUrl}`));
+      } catch (error) {
+        console.error(
+          chalk.red(`Error: Failed to verify API key - ${error.message}`)
+        );
+        await clearConfig();
+        process.exit(1);
+      }
+    } catch (error) {
+      console.error(chalk.red(`Error: ${error.message}`));
+      process.exit(1);
+    }
+  });
+  auth.command("logout").description("Logout and clear stored credentials").action(async () => {
+    try {
+      await clearConfig();
+      console.log(chalk.green("\u2713 Successfully logged out"));
+    } catch (error) {
+      console.error(chalk.red(`Error: ${error.message}`));
+      process.exit(1);
+    }
+  });
+  auth.command("whoami").description("Show current authenticated user").action(async () => {
+    try {
+      const config = await getConfig();
+      if (!config.apiKey) {
+        console.log(chalk.yellow("Not logged in"));
+        console.log(
+          chalk.dim("Run 'forge auth login --token <key>' to authenticate")
+        );
+        process.exit(1);
+      }
+      const user = await apiGet("/api/users/me");
+      console.log(chalk.bold(`@${user.username}`));
+      if (user.agentProfile?.displayName) {
+        console.log(chalk.dim(`  Name: ${user.agentProfile.displayName}`));
+      }
+      if (user.agentProfile?.emoji) {
+        console.log(chalk.dim(`  Emoji: ${user.agentProfile.emoji}`));
+      }
+      console.log(chalk.dim(`  Type: ${user.userType}`));
+      console.log(chalk.dim(`  API URL: ${config.apiUrl}`));
+    } catch (error) {
+      console.error(chalk.red(`Error: ${error.message}`));
+      process.exit(1);
+    }
+  });
+  auth.command("config").description("Show configuration file location and contents").action(async () => {
+    try {
+      const config = await getConfig();
+      const configPath = getConfigPath();
+      console.log(chalk.bold("Configuration"));
+      console.log(chalk.dim(`  Path: ${configPath}`));
+      console.log(chalk.dim(`  API URL: ${config.apiUrl}`));
+      console.log(
+        chalk.dim(`  Authenticated: ${config.apiKey ? "Yes" : "No"}`)
+      );
+      if (config.agentName) {
+        console.log(chalk.dim(`  Agent: @${config.agentName}`));
+      }
+    } catch (error) {
+      console.error(chalk.red(`Error: ${error.message}`));
+      process.exit(1);
+    }
+  });
+  return auth;
+}
+
+// src/commands/repos.ts
+import { Command as Command2 } from "commander";
+import chalk2 from "chalk";
+import { spawn } from "child_process";
+function createReposCommand() {
+  const repos = new Command2("repos").description(
+    "Manage repositories"
+  );
+  repos.command("list").description("List accessible repositories").action(async () => {
+    try {
+      const repositories = await apiGet("/api/repositories");
+      if (repositories.length === 0) {
+        console.log(chalk2.yellow("No repositories found"));
+        return;
+      }
+      console.log(chalk2.bold(`Repositories (${repositories.length})`));
+      console.log();
+      for (const repo of repositories) {
+        const identifier = `@${repo.ownerIdentifier}/${repo.name}`;
+        const visibility = repo.visibility === "private" ? "\u{1F512}" : "\u{1F310}";
+        console.log(`${visibility} ${chalk2.cyan(identifier)}`);
+        if (repo.description) {
+          console.log(chalk2.dim(`   ${repo.description}`));
+        }
+      }
+    } catch (error) {
+      console.error(chalk2.red(`Error: ${error.message}`));
+      process.exit(1);
+    }
+  });
+  repos.command("view").description("View repository details").argument("<repo>", "Repository (@owner/name)").action(async (repoArg) => {
+    try {
+      const [ownerIdentifier, name] = parseRepoArg(repoArg);
+      const repo = await apiGet(
+        `/api/repositories/${ownerIdentifier}/${name}`
+      );
+      console.log(chalk2.bold(`${repo.ownerIdentifier}/${repo.name}`));
+      if (repo.description) {
+        console.log(chalk2.dim(repo.description));
+      }
+      console.log();
+      console.log(chalk2.dim(`  Visibility: ${repo.visibility}`));
+      console.log(chalk2.dim(`  Type: ${repo.repoType || "standard"}`));
+      console.log(chalk2.dim(`  Created: ${new Date(repo.createdAt).toLocaleDateString()}`));
+    } catch (error) {
+      console.error(chalk2.red(`Error: ${error.message}`));
+      process.exit(1);
+    }
+  });
+  repos.command("clone").description("Clone a repository").argument("<repo>", "Repository (@owner/name)").argument("[destination]", "Destination directory").action(async (repoArg, destination) => {
+    try {
+      const [ownerIdentifier, name] = parseRepoArg(repoArg);
+      const config = await getConfig();
+      await apiGet(`/api/repositories/${ownerIdentifier}/${name}`);
+      const apiUrl = new URL(config.apiUrl);
+      const cloneUrl = `${apiUrl.protocol}//${apiUrl.host}/git/${ownerIdentifier}/${name}`;
+      const dest = destination || name;
+      console.log(chalk2.dim(`Cloning ${ownerIdentifier}/${name} into ${dest}...`));
+      const gitProcess = spawn(
+        "git",
+        ["clone", cloneUrl, dest],
+        {
+          stdio: "inherit",
+          env: {
+            ...process.env,
+            GIT_TERMINAL_PROMPT: "0"
+          }
+        }
+      );
+      await new Promise((resolve, reject) => {
+        gitProcess.on("exit", (code) => {
+          if (code === 0) {
+            resolve();
+          } else {
+            reject(new Error(`git clone exited with code ${code}`));
+          }
+        });
+      });
+      console.log(chalk2.green(`\u2713 Repository cloned successfully`));
+    } catch (error) {
+      console.error(chalk2.red(`Error: ${error.message}`));
+      process.exit(1);
+    }
+  });
+  repos.command("create").description("Create a new repository").requiredOption("--name <name>", "Repository name").option("--description <desc>", "Repository description").option("--visibility <type>", "Visibility (public/private)", "private").option("--org <identifier>", "Organization identifier (defaults to your personal org)").action(async (options) => {
+    try {
+      const { name, description, visibility, org } = options;
+      const user = await apiGet("/api/users/me");
+      const orgIdentifier = org || user.username;
+      const repo = await apiPost("/api/repositories", {
+        name,
+        description,
+        visibility,
+        orgIdentifier
+      });
+      console.log(chalk2.green("\u2713 Repository created successfully"));
+      console.log(chalk2.dim(`  @${repo.ownerIdentifier}/${repo.name}`));
+    } catch (error) {
+      console.error(chalk2.red(`Error: ${error.message}`));
+      process.exit(1);
+    }
+  });
+  return repos;
+}
+function parseRepoArg(arg) {
+  const match = arg.match(/^@?([^/]+)\/(.+)$/);
+  if (!match) {
+    throw new Error(
+      `Invalid repository format: ${arg}. Expected format: @owner/name or owner/name`
+    );
+  }
+  return [match[1], match[2]];
+}
+
+// src/commands/issues.ts
+import { Command as Command3 } from "commander";
+import chalk3 from "chalk";
+function createIssuesCommand() {
+  const issues = new Command3("issues").description("Manage issues");
+  issues.command("list").description("List issues in a repository").requiredOption("--repo <repo>", "Repository (@owner/name)").option("--state <state>", "Filter by state (open/closed)", "open").action(async (options) => {
+    try {
+      const [ownerIdentifier, name] = parseRepoArg2(options.repo);
+      const issuesList = await apiGet(
+        `/api/repositories/${ownerIdentifier}/${name}/issues?state=${options.state}`
+      );
+      if (issuesList.length === 0) {
+        console.log(chalk3.yellow(`No ${options.state} issues found`));
+        return;
+      }
+      console.log(
+        chalk3.bold(`Issues in @${ownerIdentifier}/${name} (${issuesList.length})`)
+      );
+      console.log();
+      for (const issue of issuesList) {
+        const stateIcon = issue.state === "open" ? "\u{1F7E2}" : "\u26AA";
+        console.log(
+          `${stateIcon} #${issue.number} ${chalk3.cyan(issue.title)}`
+        );
+        console.log(
+          chalk3.dim(`   by @${issue.author.username} \xB7 ${new Date(issue.createdAt).toLocaleDateString()}`)
+        );
+      }
+    } catch (error) {
+      console.error(chalk3.red(`Error: ${error.message}`));
+      process.exit(1);
+    }
+  });
+  issues.command("view").description("View issue details").requiredOption("--repo <repo>", "Repository (@owner/name)").requiredOption("--number <number>", "Issue number").action(async (options) => {
+    try {
+      const [ownerIdentifier, name] = parseRepoArg2(options.repo);
+      const issue = await apiGet(
+        `/api/repositories/${ownerIdentifier}/${name}/issues/${options.number}`
+      );
+      const stateIcon = issue.state === "open" ? "\u{1F7E2}" : "\u26AA";
+      console.log(
+        `${stateIcon} ${chalk3.bold(`#${issue.number} ${issue.title}`)}`
+      );
+      console.log(
+        chalk3.dim(
+          `by @${issue.author.username} \xB7 ${new Date(issue.createdAt).toLocaleDateString()}`
+        )
+      );
+      console.log();
+      if (issue.body) {
+        console.log(issue.body);
+        console.log();
+      }
+      console.log(chalk3.dim(`State: ${issue.state}`));
+      if (issue.closedAt) {
+        console.log(
+          chalk3.dim(`Closed: ${new Date(issue.closedAt).toLocaleDateString()}`)
+        );
+      }
+    } catch (error) {
+      console.error(chalk3.red(`Error: ${error.message}`));
+      process.exit(1);
+    }
+  });
+  issues.command("create").description("Create a new issue").requiredOption("--repo <repo>", "Repository (@owner/name)").requiredOption("--title <title>", "Issue title").option("--body <body>", "Issue description").action(async (options) => {
+    try {
+      const [ownerIdentifier, name] = parseRepoArg2(options.repo);
+      const issue = await apiPost(
+        `/api/repositories/${ownerIdentifier}/${name}/issues`,
+        {
+          title: options.title,
+          body: options.body || ""
+        }
+      );
+      console.log(chalk3.green("\u2713 Issue created successfully"));
+      console.log(chalk3.dim(`  #${issue.number} ${issue.title}`));
+      console.log(
+        chalk3.dim(`  @${ownerIdentifier}/${name}#${issue.number}`)
+      );
+    } catch (error) {
+      console.error(chalk3.red(`Error: ${error.message}`));
+      process.exit(1);
+    }
+  });
+  issues.command("close").description("Close an issue").requiredOption("--repo <repo>", "Repository (@owner/name)").requiredOption("--number <number>", "Issue number").action(async (options) => {
+    try {
+      const [ownerIdentifier, name] = parseRepoArg2(options.repo);
+      await apiPatch(
+        `/api/repositories/${ownerIdentifier}/${name}/issues/${options.number}`,
+        {
+          state: "closed"
+        }
+      );
+      console.log(chalk3.green("\u2713 Issue closed successfully"));
+    } catch (error) {
+      console.error(chalk3.red(`Error: ${error.message}`));
+      process.exit(1);
+    }
+  });
+  issues.command("comment").description("Add a comment to an issue").requiredOption("--repo <repo>", "Repository (@owner/name)").requiredOption("--number <number>", "Issue number").requiredOption("--body <body>", "Comment text").action(async (options) => {
+    try {
+      const [ownerIdentifier, name] = parseRepoArg2(options.repo);
+      await apiPost(
+        `/api/repositories/${ownerIdentifier}/${name}/issues/${options.number}/comments`,
+        {
+          body: options.body
+        }
+      );
+      console.log(chalk3.green("\u2713 Comment added successfully"));
+    } catch (error) {
+      console.error(chalk3.red(`Error: ${error.message}`));
+      process.exit(1);
+    }
+  });
+  return issues;
+}
+function parseRepoArg2(arg) {
+  const match = arg.match(/^@?([^/]+)\/(.+)$/);
+  if (!match) {
+    throw new Error(
+      `Invalid repository format: ${arg}. Expected format: @owner/name or owner/name`
+    );
+  }
+  return [match[1], match[2]];
+}
+
+// src/commands/prs.ts
+import { Command as Command4 } from "commander";
+import chalk4 from "chalk";
+function createPrsCommand() {
+  const prs = new Command4("prs").alias("pr").description("Manage pull requests");
+  prs.command("list").description("List pull requests in a repository").requiredOption("--repo <repo>", "Repository (@owner/name)").option("--state <state>", "Filter by state (open/closed/merged)", "open").action(async (options) => {
+    try {
+      const [ownerIdentifier, name] = parseRepoArg3(options.repo);
+      const prsList = await apiGet(
+        `/api/repositories/${ownerIdentifier}/${name}/pull-requests?state=${options.state}`
+      );
+      if (prsList.length === 0) {
+        console.log(chalk4.yellow(`No ${options.state} pull requests found`));
+        return;
+      }
+      console.log(
+        chalk4.bold(
+          `Pull Requests in @${ownerIdentifier}/${name} (${prsList.length})`
+        )
+      );
+      console.log();
+      for (const pr of prsList) {
+        const stateIcon = pr.state === "open" ? "\u{1F7E2}" : pr.state === "merged" ? "\u{1F7E3}" : "\u26AA";
+        console.log(`${stateIcon} #${pr.number} ${chalk4.cyan(pr.title)}`);
+        console.log(
+          chalk4.dim(
+            `   ${pr.headBranch} \u2192 ${pr.baseBranch} by @${pr.author.username} \xB7 ${new Date(pr.createdAt).toLocaleDateString()}`
+          )
+        );
+      }
+    } catch (error) {
+      console.error(chalk4.red(`Error: ${error.message}`));
+      process.exit(1);
+    }
+  });
+  prs.command("view").description("View pull request details").requiredOption("--repo <repo>", "Repository (@owner/name)").requiredOption("--number <number>", "PR number").action(async (options) => {
+    try {
+      const [ownerIdentifier, name] = parseRepoArg3(options.repo);
+      const pr = await apiGet(
+        `/api/repositories/${ownerIdentifier}/${name}/pull-requests/${options.number}`
+      );
+      const stateIcon = pr.state === "open" ? "\u{1F7E2}" : pr.state === "merged" ? "\u{1F7E3}" : "\u26AA";
+      console.log(`${stateIcon} ${chalk4.bold(`#${pr.number} ${pr.title}`)}`);
+      console.log(
+        chalk4.dim(
+          `${pr.headBranch} \u2192 ${pr.baseBranch} by @${pr.author.username} \xB7 ${new Date(pr.createdAt).toLocaleDateString()}`
+        )
+      );
+      console.log();
+      if (pr.body) {
+        console.log(pr.body);
+        console.log();
+      }
+      console.log(chalk4.dim(`State: ${pr.state}`));
+      if (pr.mergedAt) {
+        console.log(
+          chalk4.dim(`Merged: ${new Date(pr.mergedAt).toLocaleDateString()}`)
+        );
+      }
+      if (pr.closedAt) {
+        console.log(
+          chalk4.dim(`Closed: ${new Date(pr.closedAt).toLocaleDateString()}`)
+        );
+      }
+    } catch (error) {
+      console.error(chalk4.red(`Error: ${error.message}`));
+      process.exit(1);
+    }
+  });
+  prs.command("create").description("Create a new pull request").requiredOption("--repo <repo>", "Repository (@owner/name)").requiredOption("--head <branch>", "Head branch (source)").requiredOption("--base <branch>", "Base branch (target)").requiredOption("--title <title>", "PR title").option("--body <body>", "PR description").action(async (options) => {
+    try {
+      const [ownerIdentifier, name] = parseRepoArg3(options.repo);
+      const pr = await apiPost(
+        `/api/repositories/${ownerIdentifier}/${name}/pull-requests`,
+        {
+          headBranch: options.head,
+          baseBranch: options.base,
+          title: options.title,
+          body: options.body || ""
+        }
+      );
+      console.log(chalk4.green("\u2713 Pull request created successfully"));
+      console.log(chalk4.dim(`  #${pr.number} ${pr.title}`));
+      console.log(
+        chalk4.dim(`  @${ownerIdentifier}/${name}#${pr.number}`)
+      );
+    } catch (error) {
+      console.error(chalk4.red(`Error: ${error.message}`));
+      process.exit(1);
+    }
+  });
+  prs.command("merge").description("Merge a pull request").requiredOption("--repo <repo>", "Repository (@owner/name)").requiredOption("--number <number>", "PR number").option("--method <method>", "Merge method (merge/squash/rebase)", "merge").action(async (options) => {
+    try {
+      const [ownerIdentifier, name] = parseRepoArg3(options.repo);
+      await apiPost(
+        `/api/repositories/${ownerIdentifier}/${name}/pull-requests/${options.number}/merge`,
+        {
+          mergeMethod: options.method
+        }
+      );
+      console.log(chalk4.green("\u2713 Pull request merged successfully"));
+    } catch (error) {
+      console.error(chalk4.red(`Error: ${error.message}`));
+      process.exit(1);
+    }
+  });
+  prs.command("close").description("Close a pull request without merging").requiredOption("--repo <repo>", "Repository (@owner/name)").requiredOption("--number <number>", "PR number").action(async (options) => {
+    try {
+      const [ownerIdentifier, name] = parseRepoArg3(options.repo);
+      await apiPatch(
+        `/api/repositories/${ownerIdentifier}/${name}/pull-requests/${options.number}`,
+        {
+          state: "closed"
+        }
+      );
+      console.log(chalk4.green("\u2713 Pull request closed successfully"));
+    } catch (error) {
+      console.error(chalk4.red(`Error: ${error.message}`));
+      process.exit(1);
+    }
+  });
+  prs.command("comment").description("Add a comment to a pull request").requiredOption("--repo <repo>", "Repository (@owner/name)").requiredOption("--number <number>", "PR number").requiredOption("--body <body>", "Comment text").action(async (options) => {
+    try {
+      const [ownerIdentifier, name] = parseRepoArg3(options.repo);
+      await apiPost(
+        `/api/repositories/${ownerIdentifier}/${name}/pull-requests/${options.number}/comments`,
+        {
+          body: options.body
+        }
+      );
+      console.log(chalk4.green("\u2713 Comment added successfully"));
+    } catch (error) {
+      console.error(chalk4.red(`Error: ${error.message}`));
+      process.exit(1);
+    }
+  });
+  return prs;
+}
+function parseRepoArg3(arg) {
+  const match = arg.match(/^@?([^/]+)\/(.+)$/);
+  if (!match) {
+    throw new Error(
+      `Invalid repository format: ${arg}. Expected format: @owner/name or owner/name`
+    );
+  }
+  return [match[1], match[2]];
+}
+
+// src/index.ts
+var program = new Command5();
+program.name("forge").description("CLI tool for Kernelius Forge - the agent-native Git platform").version("0.1.0");
+program.addCommand(createAuthCommand());
+program.addCommand(createReposCommand());
+program.addCommand(createIssuesCommand());
+program.addCommand(createPrsCommand());
+program.parse();

package/package.json

@@ -0,0 +1,51 @@
+{
+  "name": "@kernelius/forge-cli",
+  "version": "0.1.0",
+  "description": "Command-line tool for Kernelius Forge - the agent-native Git platform",
+  "type": "module",
+  "bin": {
+    "forge": "./dist/index.js"
+  },
+  "files": [
+    "dist",
+    "README.md",
+    "SKILL.md"
+  ],
+  "scripts": {
+    "build": "tsup",
+    "dev": "tsup --watch",
+    "typecheck": "tsc --noEmit",
+    "prepublishOnly": "npm run build"
+  },
+  "dependencies": {
+    "chalk": "^5.3.0",
+    "commander": "^12.1.0",
+    "ora": "^8.1.1"
+  },
+  "devDependencies": {
+    "@types/node": "^22.10.5",
+    "tsup": "^8.3.5",
+    "typescript": "^5.7.3"
+  },
+  "keywords": [
+    "forge",
+    "cli",
+    "git",
+    "kernelius",
+    "agent",
+    "openclaw"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/kernelius-hq/forge-cli"
+  },
+  "bugs": {
+    "url": "https://github.com/kernelius-hq/forge-cli/issues"
+  },
+  "homepage": "https://github.com/kernelius-hq/forge-cli#readme",
+  "license": "MIT",
+  "author": {
+    "name": "Kernelius HQ",
+    "url": "https://github.com/kernelius-hq"
+  }
+}