@org-press/deploy-github-pages 0.9.12

package/LICENSE

@@ -0,0 +1,29 @@
+GNU GENERAL PUBLIC LICENSE
+Version 2, June 1991
+
+Copyright (C) 1989, 1991 Free Software Foundation, Inc.
+51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA
+
+Everyone is permitted to copy and distribute verbatim copies
+of this license document, but changing it is not allowed.
+
+For the full license text, see: https://www.gnu.org/licenses/old-licenses/gpl-2.0.txt
+
+---
+
+Org-Press - Static site generator for org-mode files
+Copyright (C) 2024-2026
+
+This program is free software; you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation; either version 2 of the License, or
+(at your option) any later version.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with this program; if not, write to the Free Software
+Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.

package/README.md

@@ -0,0 +1,177 @@
+# @org-press/deploy-github-pages
+
+GitHub Pages deploy adapter for [org-press](https://orgp.dev).
+
+Deploys static sites to GitHub Pages by pushing to the `gh-pages` branch.
+
+## Installation
+
+```bash
+npm install @org-press/deploy-github-pages
+# or
+pnpm add @org-press/deploy-github-pages
+```
+
+## Usage
+
+### Basic Usage
+
+```typescript
+import { githubPagesAdapter } from '@org-press/deploy-github-pages';
+
+export default defineConfig({
+  deploy: {
+    adapter: githubPagesAdapter({
+      repo: 'user/my-site',
+    }),
+  },
+});
+```
+
+### With Custom Domain
+
+```typescript
+import { githubPagesAdapter } from '@org-press/deploy-github-pages';
+
+export default defineConfig({
+  deploy: {
+    adapter: githubPagesAdapter({
+      repo: 'user/my-site',
+      cname: 'mysite.com',
+    }),
+  },
+});
+```
+
+### Full Configuration
+
+```typescript
+import { githubPagesAdapter } from '@org-press/deploy-github-pages';
+
+export default defineConfig({
+  deploy: {
+    adapter: githubPagesAdapter({
+      // GitHub repository (user/repo or org/repo format)
+      // If not specified, auto-detects from git remote
+      repo: 'user/my-site',
+
+      // Target branch (default: 'gh-pages')
+      branch: 'gh-pages',
+
+      // Custom domain for CNAME file
+      cname: 'mysite.com',
+
+      // Add .nojekyll file (default: true)
+      // Recommended for pre-built static sites
+      noJekyll: true,
+
+      // Commit message (default: 'Deploy to GitHub Pages')
+      message: 'Deploy docs from CI',
+
+      // Remote name (default: 'origin')
+      remote: 'origin',
+    }),
+  },
+});
+```
+
+## Configuration Options
+
+| Option | Type | Default | Description |
+|--------|------|---------|-------------|
+| `repo` | `string` | Auto-detected | GitHub repository in `user/repo` format |
+| `branch` | `string` | `'gh-pages'` | Target branch for deployment |
+| `cname` | `string` | - | Custom domain (creates CNAME file) |
+| `noJekyll` | `boolean` | `true` | Add `.nojekyll` file to disable Jekyll |
+| `message` | `string` | `'Deploy to GitHub Pages'` | Git commit message |
+| `remote` | `string` | `'origin'` | Git remote name |
+
+## How It Works
+
+The adapter deploys your site by:
+
+1. Adding a `.nojekyll` file (optional, recommended)
+2. Adding a `CNAME` file if a custom domain is configured
+3. Initializing a new git repository in your build output directory
+4. Committing all files
+5. Force pushing to the `gh-pages` branch on GitHub
+
+This approach ensures a clean deployment each time without accumulating history.
+
+## Auto-Detection
+
+If `repo` is not specified, the adapter attempts to auto-detect the repository from your git remote:
+
+```bash
+# Supports both HTTPS and SSH remote URLs:
+https://github.com/user/repo.git
+git@github.com:user/repo.git
+```
+
+## Dry Run Mode
+
+Test your deployment without actually pushing:
+
+```typescript
+const result = await deploy({
+  adapter: githubPagesAdapter({ repo: 'user/repo' }),
+  dryRun: true,
+});
+
+console.log(result.url); // Predicted GitHub Pages URL
+```
+
+## GitHub Pages URL
+
+The adapter returns the correct URL based on your repository:
+
+- **User/Org pages** (`username.github.io`): `https://username.github.io`
+- **Project pages** (`user/project`): `https://user.github.io/project`
+- **Custom domain**: `https://your-domain.com`
+
+## Requirements
+
+- Git must be installed and available in PATH
+- Push access to the target repository
+- For private repos, appropriate authentication (SSH key or token)
+
+## CI/CD Example
+
+### GitHub Actions
+
+```yaml
+name: Deploy to GitHub Pages
+
+on:
+  push:
+    branches: [main]
+
+jobs:
+  deploy:
+    runs-on: ubuntu-latest
+    permissions:
+      contents: write
+    steps:
+      - uses: actions/checkout@v4
+
+      - uses: pnpm/action-setup@v2
+        with:
+          version: 8
+
+      - uses: actions/setup-node@v4
+        with:
+          node-version: 20
+          cache: 'pnpm'
+
+      - run: pnpm install
+      - run: pnpm build
+
+      - name: Deploy
+        run: pnpm deploy
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+```
+
+## License
+
+GPL-2.0

package/dist/index.js

@@ -0,0 +1,235 @@
+// src/adapter.ts
+import { spawnSync } from "child_process";
+import { writeFileSync, existsSync, rmSync } from "fs";
+import { join } from "path";
+var GitHubPagesAdapter = class {
+  name = "github-pages";
+  description = "Deploy to GitHub Pages";
+  config;
+  constructor(config = {}) {
+    this.config = config;
+  }
+  /**
+   * Validate adapter configuration
+   *
+   * Checks:
+   * - git is available in PATH
+   * - Repository format is valid (if specified)
+   */
+  async validate(adapterConfig) {
+    const errors = [];
+    const warnings = [];
+    const gitCheck = spawnSync("git", ["--version"], {
+      encoding: "utf-8",
+      timeout: 5e3
+    });
+    if (gitCheck.status !== 0) {
+      errors.push("git is not available in PATH");
+    }
+    const repo = adapterConfig.options.repo || this.config.repo;
+    if (repo) {
+      const repoPattern = /^[\w.-]+\/[\w.-]+$/;
+      if (!repoPattern.test(repo)) {
+        errors.push(
+          `Invalid repository format: "${repo}". Expected format: "user/repo" or "org/repo"`
+        );
+      }
+    }
+    const branch = adapterConfig.options.branch || this.config.branch || "gh-pages";
+    const branchPattern = /^[\w./-]+$/;
+    if (!branchPattern.test(branch)) {
+      errors.push(`Invalid branch name: "${branch}"`);
+    }
+    if (!repo) {
+      warnings.push(
+        "No repository specified. Will attempt to auto-detect from git remote."
+      );
+    }
+    return {
+      valid: errors.length === 0,
+      errors,
+      warnings
+    };
+  }
+  /**
+   * Execute deployment to GitHub Pages
+   *
+   * Initializes a git repository in the output directory,
+   * adds all files, and force pushes to the gh-pages branch.
+   */
+  async deploy(context) {
+    const { outDir, metadata, adapterConfig, dryRun, logger } = context;
+    const branch = adapterConfig.branch || this.config.branch || "gh-pages";
+    const cname = adapterConfig.cname ?? this.config.cname;
+    const noJekyll = adapterConfig.noJekyll ?? this.config.noJekyll ?? true;
+    const message = adapterConfig.message || this.config.message || "Deploy to GitHub Pages";
+    const remote = adapterConfig.remote || this.config.remote || "origin";
+    let repo = adapterConfig.repo || this.config.repo;
+    if (!repo) {
+      repo = this.autoDetectRepo();
+      if (!repo) {
+        return {
+          success: false,
+          error: "Could not auto-detect repository. Please specify repo in adapter config."
+        };
+      }
+      logger.info(`Auto-detected repository: ${repo}`);
+    }
+    logger.info(`Deploying to GitHub Pages: ${repo}`);
+    logger.info(`Branch: ${branch}`);
+    if (cname) {
+      logger.info(`Custom domain: ${cname}`);
+    }
+    if (dryRun) {
+      logger.info("Dry run mode - skipping actual deployment");
+      return {
+        success: true,
+        deploymentId: `dry-run-${Date.now()}`,
+        url: this.getPageUrl(repo, cname),
+        logs: ["Dry run completed successfully"]
+      };
+    }
+    try {
+      if (noJekyll) {
+        const nojekyllPath = join(outDir, ".nojekyll");
+        writeFileSync(nojekyllPath, "");
+        logger.debug("Added .nojekyll file");
+      }
+      if (cname) {
+        const cnamePath = join(outDir, "CNAME");
+        writeFileSync(cnamePath, cname);
+        logger.debug(`Added CNAME file: ${cname}`);
+      }
+      const gitDir = join(outDir, ".git");
+      if (existsSync(gitDir)) {
+        rmSync(gitDir, { recursive: true });
+      }
+      const initResult = this.runGit(["init"], outDir);
+      if (!initResult.success) {
+        return {
+          success: false,
+          error: `Failed to initialize git repository: ${initResult.error}`
+        };
+      }
+      logger.debug("Initialized git repository");
+      this.runGit(
+        ["config", "user.email", "github-pages-deploy@org-press"],
+        outDir
+      );
+      this.runGit(["config", "user.name", "org-press deploy"], outDir);
+      const addResult = this.runGit(["add", "-A"], outDir);
+      if (!addResult.success) {
+        return {
+          success: false,
+          error: `Failed to add files: ${addResult.error}`
+        };
+      }
+      logger.debug("Added all files to git");
+      const commitResult = this.runGit(
+        ["commit", "-m", message],
+        outDir
+      );
+      if (!commitResult.success) {
+        return {
+          success: false,
+          error: `Failed to create commit: ${commitResult.error}`
+        };
+      }
+      logger.debug("Created commit");
+      const remoteUrl = `https://github.com/${repo}.git`;
+      const remoteAddResult = this.runGit(
+        ["remote", "add", remote, remoteUrl],
+        outDir
+      );
+      if (!remoteAddResult.success) {
+        this.runGit(["remote", "set-url", remote, remoteUrl], outDir);
+      }
+      logger.debug(`Set remote ${remote} to ${remoteUrl}`);
+      logger.info(`Pushing to ${remote}/${branch}...`);
+      const pushResult = this.runGit(
+        ["push", "-f", remote, `HEAD:${branch}`],
+        outDir
+      );
+      if (!pushResult.success) {
+        return {
+          success: false,
+          error: `Failed to push to GitHub: ${pushResult.error}`,
+          logs: pushResult.output ? [pushResult.output] : void 0
+        };
+      }
+      logger.info("Successfully deployed to GitHub Pages!");
+      return {
+        success: true,
+        deploymentId: `${repo}@${branch}`,
+        url: this.getPageUrl(repo, cname),
+        logs: pushResult.output ? [pushResult.output] : void 0
+      };
+    } catch (err) {
+      const error = err instanceof Error ? err.message : String(err);
+      logger.error(`Deployment failed: ${error}`);
+      return {
+        success: false,
+        error: `Deployment failed: ${error}`
+      };
+    }
+  }
+  /**
+   * Auto-detect repository from git remote
+   */
+  autoDetectRepo() {
+    const result = spawnSync("git", ["remote", "get-url", "origin"], {
+      encoding: "utf-8",
+      timeout: 5e3
+    });
+    if (result.status !== 0 || !result.stdout) {
+      return void 0;
+    }
+    const url = result.stdout.trim();
+    const httpsMatch = url.match(/github\.com[/:]([^/]+)\/([^/.]+)/);
+    if (httpsMatch) {
+      return `${httpsMatch[1]}/${httpsMatch[2]}`;
+    }
+    return void 0;
+  }
+  /**
+   * Get the GitHub Pages URL for the repository
+   */
+  getPageUrl(repo, cname) {
+    if (cname) {
+      return `https://${cname}`;
+    }
+    const [user, repoName] = repo.split("/");
+    if (repoName === `${user}.github.io`) {
+      return `https://${user}.github.io`;
+    }
+    return `https://${user}.github.io/${repoName}`;
+  }
+  /**
+   * Run a git command and return the result
+   */
+  runGit(args, cwd) {
+    const result = spawnSync("git", args, {
+      cwd,
+      encoding: "utf-8",
+      timeout: 6e4
+    });
+    if (result.status !== 0) {
+      return {
+        success: false,
+        output: result.stdout,
+        error: result.stderr || result.stdout || "Unknown git error"
+      };
+    }
+    return {
+      success: true,
+      output: result.stdout
+    };
+  }
+};
+function githubPagesAdapter(config = {}) {
+  return new GitHubPagesAdapter(config);
+}
+export {
+  GitHubPagesAdapter,
+  githubPagesAdapter
+};

package/package.json

@@ -0,0 +1,48 @@
+{
+  "name": "@org-press/deploy-github-pages",
+  "version": "0.9.12",
+  "description": "GitHub Pages deploy adapter for org-press",
+  "license": "GPL-2.0",
+  "type": "module",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    }
+  },
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "files": [
+    "dist",
+    "src",
+    "README.md"
+  ],
+  "peerDependencies": {
+    "@org-press/deploy": ">=0.9.0"
+  },
+  "devDependencies": {
+    "tsup": "^8.0.0",
+    "typescript": "~5.7.3",
+    "@types/node": "^20.0.0",
+    "vitest": "^3.1.4",
+    "@org-press/deploy": "0.9.12"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "homepage": "https://orgp.dev",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/org-press/org-press.git"
+  },
+  "bugs": {
+    "url": "https://github.com/org-press/org-press/issues"
+  },
+  "scripts": {
+    "build": "tsup",
+    "dev": "tsup --watch",
+    "test": "vitest",
+    "test:ci": "vitest --run",
+    "clean": "rm -rf dist"
+  }
+}