pondorasti 0.1.1

package/README.md

@@ -0,0 +1,128 @@
+# Pondorasti CLI
+
+🖥️ Mission control for pondorasti - A command-line tool for automated macOS setup and configuration.
+
+Built with [Bun](https://bun.sh), [Yargs](https://yargs.js.org/) for command parsing, and [Ink](https://github.com/vadimdemedes/ink) for rich terminal UI when needed.
+
+## Features
+
+- 🍺 **Homebrew Management**: Install, update, and manage Homebrew packages
+- 📂 **Smart Cloning**: Clone GitHub repos to organized `~/repos/<owner>/<repo>` structure
+- 📦 **Native Output**: Shows real brew output for transparency
+- 🚀 **Fast**: Powered by Bun for blazing-fast execution
+- 🔧 **Extensible**: Easy to add new commands
+
+## Prerequisites
+
+- macOS (optimized for Apple Silicon)
+- [Bun](https://bun.sh) runtime
+- [GitHub CLI](https://cli.github.com/) (`gh`) for clone command
+
+## Installation
+
+```bash
+# Install Bun if you haven't already
+curl -fsSL https://bun.sh/install | bash
+
+# Clone the repository
+git clone https://github.com/pondorasti/pondorasti.git
+cd pondorasti
+
+# Install dependencies
+bun install
+
+# Run commands
+bun run packages/cli/src/index.ts <command>
+
+# Or install globally
+bun link
+pondorasti <command>
+# or use the short alias
+pd <command>
+```
+
+## Usage
+
+### Commands
+
+#### `clone` - Clone GitHub repositories
+
+Clones repositories to `~/repos/<owner>/<repo>` and opens a shell in the directory.
+
+```bash
+# Clone using various URL formats
+pd clone https://github.com/owner/repo
+pd clone git@github.com:owner/repo.git
+pd clone owner/repo
+
+# Also works with tree/blob URLs (branch/file paths are stripped)
+pd clone https://github.com/owner/repo/tree/main
+pd clone https://github.com/owner/repo/blob/main/src/file.ts
+```
+
+#### `brew` - Manage Homebrew
+
+```bash
+# Install Homebrew
+pd brew install
+
+# Run brew bundle from Brewfile
+pd brew bundle
+```
+
+### Global Options
+
+```bash
+--help, -h      Show help
+--version, -v   Show version
+```
+
+## Development
+
+```bash
+# Run in development mode
+bun dev
+
+# Run tests
+bun test
+
+# Build for production
+bun build --compile --outfile=pondorasti src/index.ts
+```
+
+## Architecture
+
+```
+packages/cli/
+├── src/
+│   ├── index.ts           # CLI entry with yargs
+│   ├── commands/          # Command implementations
+│   │   ├── brew.ts        # Homebrew management
+│   │   └── clone.ts       # GitHub repo cloning
+│   ├── tools/             # External tool wrappers
+│   │   └── homebrew.ts    # Homebrew operations
+│   └── utils/             # Utilities
+│       ├── cli-helpers.ts # CLI utilities
+│       ├── github.ts      # GitHub URL parsing
+│       └── github.test.ts # Tests for GitHub utils
+├── Brewfile               # Package definitions (at repo root)
+└── package.json           # Project configuration
+```
+
+## Future Commands
+
+- `dotfiles` - Manage dotfiles and configurations
+- `macos` - Configure macOS system preferences
+- `setup` - Full system setup wizard
+
+## Contributing
+
+1. Fork the repository
+2. Create your feature branch (`git checkout -b feature/amazing-feature`)
+3. Commit your changes (`git commit -m 'Add some amazing feature'`)
+4. Push to the branch (`git push origin feature/amazing-feature`)
+5. Open a Pull Request
+
+## License
+
+MIT

package/package.json

@@ -0,0 +1,38 @@
+{
+  "name": "pondorasti",
+  "version": "0.1.1",
+  "description": "CLI for pondorasti",
+  "author": "Alexandru Ţurcanu",
+  "license": "MIT",
+  "main": "src/index.ts",
+  "keywords": [
+    "cli",
+    "macos",
+    "homebrew",
+    "dotfiles",
+    "setup"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "bin": {
+    "pondorasti": "./src/index.ts",
+    "pd": "./src/index.ts"
+  },
+  "scripts": {
+    "start": "bun run src/index.ts",
+    "dev": "bun --watch src/index.ts",
+    "test": "bun test"
+  },
+  "dependencies": {
+    "ink": "^6.5.1",
+    "ink-gradient": "^3.0.0",
+    "ink-spinner": "^5.0.0",
+    "react": "^19.2.0",
+    "yargs": "^18.0.0"
+  },
+  "devDependencies": {
+    "@types/react": "^19.2.7",
+    "@types/yargs": "^17.0.35"
+  }
+}

package/src/commands/brew.ts

@@ -0,0 +1,89 @@
+import type { CommandModule } from "yargs"
+import { $ } from "bun"
+import { Homebrew } from "../tools/homebrew"
+import { failHandler } from "../utils/cli-helpers"
+import * as path from "path"
+import * as fs from "fs"
+
+// -------------------------------------------------------------------------------------------------------------------
+// Subcommands
+// -------------------------------------------------------------------------------------------------------------------
+
+const installCommand: CommandModule = {
+  command: "install",
+  describe: "Install Homebrew",
+  handler: async () => {
+    if (Homebrew.isInstalled()) {
+      const brewPath = Homebrew.getBrewPath()
+      console.log(`✓ Homebrew is already installed at ${brewPath}`)
+
+      try {
+        await $`brew --version`
+      } catch (error) {
+        console.error("⚠ Homebrew is installed but not working properly")
+      }
+
+      return
+    }
+
+    try {
+      await $`/bin/bash -c "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/HEAD/install.sh)"`
+    } catch (error) {
+      console.error("✗ Failed to install Homebrew")
+      process.exit(1)
+    }
+  },
+}
+
+const bundleCommand: CommandModule = {
+  command: "bundle",
+  describe: "Run brew bundle from Brewfile",
+  handler: async () => {
+    if (!Homebrew.isInstalled()) {
+      console.error("✗ Homebrew is not installed. Run 'pondorasti brew install' first.")
+      process.exit(1)
+    }
+
+    // Brewfile is always at the root of the pondorasti repo
+    const brewfilePath = path.join(__dirname, "..", "..", "..", "..", "Brewfile")
+
+    if (!fs.existsSync(brewfilePath)) {
+      console.error("✗ Brewfile not found at expected location:", brewfilePath)
+      console.error("This is likely a bug in the CLI configuration.")
+      process.exit(1)
+    }
+
+    try {
+      await Homebrew.runBundle(brewfilePath)
+    } catch (error) {
+      console.error("✗ Failed to run brew bundle")
+      process.exit(1)
+    }
+  },
+}
+
+// -------------------------------------------------------------------------------------------------------------------
+// Main brew command
+// -------------------------------------------------------------------------------------------------------------------
+
+const brewCommand: CommandModule = {
+  command: "brew",
+  describe: "Manage Homebrew and install packages",
+  builder: (yargs) => {
+    return yargs //
+      .command(installCommand)
+      .command(bundleCommand)
+      .demandCommand(1)
+      .help()
+      .strict()
+      .fail(failHandler)
+  },
+  handler: () => {
+    // This handler is called when no subcommand is provided
+    // But the fail handler above will handle it
+  },
+}
+
+// -------------------------------------------------------------------------------------------------------------------
+
+export default brewCommand

package/src/commands/clone.ts

@@ -0,0 +1,83 @@
+import type { CommandModule } from "yargs"
+import { $, spawn } from "bun"
+import * as path from "path"
+import * as fs from "fs"
+import * as os from "os"
+import { parseGitHubUrl } from "../utils/github"
+
+const openShell = async (cwd: string) => {
+  console.log(`\nOpening shell in ${cwd}...`)
+  const shell = process.env.SHELL || "/bin/zsh"
+  const proc = spawn([shell], {
+    cwd,
+    stdin: "inherit",
+    stdout: "inherit",
+    stderr: "inherit",
+  })
+  await proc.exited
+}
+
+const cloneCommand: CommandModule<{}, { url: string }> = {
+  command: "clone <url>",
+  describe: "Clone a GitHub repository to ~/repos/<owner>/<repo>",
+  builder: (yargs) => {
+    return yargs.positional("url", {
+      describe: "GitHub repository URL",
+      type: "string",
+      demandOption: true,
+    })
+  },
+  handler: async (argv) => {
+    const { url } = argv
+
+    const parsed = parseGitHubUrl(url)
+    if (!parsed) {
+      console.error("✗ Invalid GitHub URL format")
+      console.error("  Expected formats:")
+      console.error("    https://github.com/owner/repo")
+      console.error("    git@github.com:owner/repo.git")
+      console.error("    owner/repo")
+      process.exit(1)
+    }
+
+    const { owner, repo } = parsed
+
+    // Check if gh CLI is installed
+    try {
+      await $`which gh`.quiet()
+    } catch {
+      console.error("✗ GitHub CLI (gh) is not installed")
+      console.error("  Install with: brew install gh")
+      process.exit(1)
+    }
+
+    // Construct the target directory
+    const reposDir = path.join(os.homedir(), "repos", owner)
+    const targetDir = path.join(reposDir, repo)
+
+    // Check if repo already exists
+    if (fs.existsSync(targetDir)) {
+      console.log(`✓ Repository already exists at ${targetDir}`)
+      await openShell(targetDir)
+      return
+    }
+
+    // Create the parent directory if it doesn't exist
+    if (!fs.existsSync(reposDir)) {
+      fs.mkdirSync(reposDir, { recursive: true })
+    }
+
+    // Clone the repository using gh CLI
+    console.log(`Cloning ${owner}/${repo}...`)
+    try {
+      await $`gh repo clone ${owner}/${repo} ${targetDir}`
+      console.log(`\n✓ Successfully cloned to ${targetDir}`)
+      await openShell(targetDir)
+    } catch (error) {
+      console.error(`\n✗ Failed to clone repository`)
+      process.exit(1)
+    }
+  },
+}
+
+export default cloneCommand

package/src/index.ts

@@ -0,0 +1,22 @@
+#!/usr/bin/env bun
+import yargs from "yargs"
+import { hideBin } from "yargs/helpers"
+import brewCommand from "./commands/brew"
+import cloneCommand from "./commands/clone"
+import { failHandler } from "./utils/cli-helpers"
+
+yargs(hideBin(process.argv))
+  .scriptName("pondorasti")
+  .usage("$0 <command> [options]")
+  .command(brewCommand)
+  .command(cloneCommand)
+  .demandCommand(1)
+  .recommendCommands()
+  .strict()
+  .version()
+  .alias("v", "version")
+  .help()
+  .alias("h", "help")
+  .epilogue("For more information, visit https://github.com/pondorasti/pondorasti/blob/main/packages/cli/README.md")
+  .fail(failHandler)
+  .parse()

package/src/tools/homebrew.ts

@@ -0,0 +1,58 @@
+import * as fs from "fs"
+import { $ } from "bun"
+
+const BREW_PATH_M1 = "/opt/homebrew/bin/brew"
+
+class Homebrew {
+  private static brewPath: string | null = null
+
+  static isInstalled(): boolean {
+    if (fs.existsSync(BREW_PATH_M1)) {
+      this.brewPath = BREW_PATH_M1
+      return true
+    }
+
+    try {
+      const result = Bun.spawnSync(["which", "brew"], { stdout: "pipe", stderr: "pipe" })
+
+      if (result.exitCode === 0 && result.stdout) {
+        this.brewPath = result.stdout.toString().trim()
+        return true
+      }
+    } catch {}
+
+    return false
+  }
+
+  static getBrewPath(): string | null {
+    if (this.brewPath) {
+      return this.brewPath
+    }
+
+    if (fs.existsSync(BREW_PATH_M1)) {
+      this.brewPath = BREW_PATH_M1
+      return this.brewPath
+    }
+
+    try {
+      const result = Bun.spawnSync(["which", "brew"], { stdout: "pipe", stderr: "pipe" })
+
+      if (result.exitCode === 0 && result.stdout) {
+        this.brewPath = result.stdout.toString().trim()
+        return this.brewPath
+      }
+    } catch {}
+
+    return null
+  }
+
+  static async runBundle(brewfilePath?: string): Promise<void> {
+    if (brewfilePath) {
+      await $`brew bundle --file=${brewfilePath}`
+    } else {
+      await $`brew bundle`
+    }
+  }
+}
+
+export { Homebrew }

package/src/utils/cli-helpers.ts

@@ -0,0 +1,28 @@
+import type { Argv } from "yargs"
+
+function failHandler(msg: string | undefined | null, err: Error | undefined, yargs: Argv) {
+  // Handle the case where no command/subcommand was provided
+  if (!err && (!msg || msg.includes("Not enough non-option arguments"))) {
+    yargs.showHelp("log")
+    process.exit(0)
+  }
+
+  // Handle unknown arguments - show error in red but help in normal color
+  if (!err && msg && msg.includes("Unknown argument")) {
+    console.error(msg)
+    console.log()
+    yargs.showHelp("log")
+    process.exit(1)
+  }
+
+  if (err) {
+    console.error("Error:", err.message)
+  } else if (msg) {
+    console.error(msg)
+    console.log()
+    yargs.showHelp("error")
+  }
+  process.exit(1)
+}
+
+export { failHandler }

package/src/utils/github.test.ts

@@ -0,0 +1,93 @@
+import { describe, expect, test } from "bun:test"
+import { parseGitHubUrl } from "./github"
+
+describe("parseGitHubUrl", () => {
+  test("parses standard HTTPS URLs", () => {
+    expect(parseGitHubUrl("https://github.com/owner/repo")).toEqual({
+      owner: "owner",
+      repo: "repo",
+    })
+  })
+
+  test("parses HTTPS URLs with .git suffix", () => {
+    expect(parseGitHubUrl("https://github.com/owner/repo.git")).toEqual({
+      owner: "owner",
+      repo: "repo",
+    })
+  })
+
+  test("parses SSH URLs", () => {
+    expect(parseGitHubUrl("git@github.com:owner/repo.git")).toEqual({
+      owner: "owner",
+      repo: "repo",
+    })
+  })
+
+  test("parses SSH URLs without .git suffix", () => {
+    expect(parseGitHubUrl("git@github.com:owner/repo")).toEqual({
+      owner: "owner",
+      repo: "repo",
+    })
+  })
+
+  test("parses short owner/repo format", () => {
+    expect(parseGitHubUrl("owner/repo")).toEqual({
+      owner: "owner",
+      repo: "repo",
+    })
+  })
+
+  test("parses tree URLs (branch paths)", () => {
+    expect(parseGitHubUrl("https://github.com/owner/repo/tree/main")).toEqual({
+      owner: "owner",
+      repo: "repo",
+    })
+  })
+
+  test("parses tree URLs with nested paths", () => {
+    expect(parseGitHubUrl("https://github.com/owner/repo/tree/main/src/components")).toEqual({
+      owner: "owner",
+      repo: "repo",
+    })
+  })
+
+  test("parses blob URLs (file paths)", () => {
+    expect(parseGitHubUrl("https://github.com/owner/repo/blob/main/file.ts")).toEqual({
+      owner: "owner",
+      repo: "repo",
+    })
+  })
+
+  test("parses blob URLs with nested file paths", () => {
+    expect(parseGitHubUrl("https://github.com/owner/repo/blob/main/src/utils/helpers.ts")).toEqual({
+      owner: "owner",
+      repo: "repo",
+    })
+  })
+
+  test("handles trailing slashes", () => {
+    expect(parseGitHubUrl("https://github.com/owner/repo/")).toEqual({
+      owner: "owner",
+      repo: "repo",
+    })
+  })
+
+  test("handles whitespace", () => {
+    expect(parseGitHubUrl("  https://github.com/owner/repo  ")).toEqual({
+      owner: "owner",
+      repo: "repo",
+    })
+  })
+
+  test("returns null for invalid URLs", () => {
+    expect(parseGitHubUrl("not-a-valid-url")).toBeNull()
+  })
+
+  test("returns null for empty string", () => {
+    expect(parseGitHubUrl("")).toBeNull()
+  })
+
+  test("returns null for URLs without owner/repo", () => {
+    expect(parseGitHubUrl("https://github.com/")).toBeNull()
+  })
+})

package/src/utils/github.ts

@@ -0,0 +1,20 @@
+export const parseGitHubUrl = (url: string): { owner: string; repo: string } | null => {
+  const normalized = url.trim().replace(/\/+$/, "")
+
+  // Strip /tree/... or /blob/... suffixes (branch/file paths)
+  const withoutTree = normalized.replace(/\/(tree|blob)\/.*$/, "")
+
+  const patterns = [
+    /github\.com[:/]([^/]+)\/([^/.]+)(\.git)?$/, // Handles https and SSH formats
+    /^([^/]+)\/([^/.]+)(\.git)?$/, // Handles owner/repo format
+  ]
+
+  for (const pattern of patterns) {
+    const match = withoutTree.match(pattern)
+    if (match) {
+      return { owner: match[1], repo: match[2] }
+    }
+  }
+
+  return null
+}