@orderful/droid 0.24.0 → 0.25.0

package/src/tools/codex/skills/droid-codex/scripts/git-preamble.ts

@@ -0,0 +1,156 @@
+#!/usr/bin/env bun
+/**
+ * codex git-preamble
+ *
+ * Ensures the codex repo is on a clean main branch with latest changes.
+ * Run this before ANY codex operation (read or write).
+ *
+ * Usage:
+ *   droid config codex | droid exec droid-codex git-preamble --config -
+ *
+ * What it does:
+ *   1. Checkout main (abort any stuck merge/rebase)
+ *   2. Stash any uncommitted changes
+ *   3. Pull latest with rebase
+ *
+ * Output (JSON):
+ *   { "success": true, "branch": "main", "stashed": false }
+ */
+
+import { execSync } from 'child_process';
+import { readFileSync, existsSync } from 'fs';
+
+interface Config {
+  codex_repo: string;
+}
+
+interface Result {
+  success: boolean;
+  branch?: string;
+  stashed?: boolean;
+  error?: string;
+}
+
+function parseArgs(args: string[]): { config: Config | null } {
+  let config: Config | null = null;
+
+  for (let i = 0; i < args.length; i++) {
+    const arg = args[i];
+    if (arg === '--config' && args[i + 1]) {
+      const configArg = args[++i];
+      if (configArg === '-') {
+        const stdin = readFileSync(0, 'utf-8').trim();
+        config = JSON.parse(stdin) as Config;
+      } else {
+        config = JSON.parse(configArg) as Config;
+      }
+    }
+  }
+
+  return { config };
+}
+
+function expandPath(p: string): string {
+  if (p.startsWith('~/')) {
+    return p.replace('~', process.env.HOME || '');
+  }
+  return p;
+}
+
+function run(cmd: string, cwd: string): { ok: boolean; output: string } {
+  try {
+    const output = execSync(cmd, {
+      cwd,
+      encoding: 'utf-8',
+      stdio: ['pipe', 'pipe', 'pipe'],
+    });
+    return { ok: true, output: output.trim() };
+  } catch (err: unknown) {
+    const error = err as { stderr?: string; message?: string };
+    return { ok: false, output: error.stderr || error.message || 'Unknown error' };
+  }
+}
+
+function gitPreamble(repoPath: string): Result {
+  const cwd = expandPath(repoPath);
+
+  // Verify repo exists
+  if (!existsSync(cwd)) {
+    return {
+      success: false,
+      error: `Codex repo not found at ${cwd}. Run: git clone git@github.com:orderful/orderful-codex.git ${cwd}`,
+    };
+  }
+
+  // 1. Abort any stuck operations (silent failures are fine)
+  run('git merge --abort', cwd);
+  run('git rebase --abort', cwd);
+  run('git cherry-pick --abort', cwd);
+
+  // 2. Checkout main
+  const checkout = run('git checkout main', cwd);
+  if (!checkout.ok && !checkout.output.includes('Already on')) {
+    return {
+      success: false,
+      error: `Failed to checkout main: ${checkout.output}`,
+    };
+  }
+
+  // 3. Stash any uncommitted changes
+  const statusCheck = run('git status --porcelain', cwd);
+  let stashed = false;
+  if (statusCheck.ok && statusCheck.output.length > 0) {
+    const stash = run('git stash push -m "codex-auto-stash"', cwd);
+    stashed = stash.ok && !stash.output.includes('No local changes');
+  }
+
+  // 4. Pull latest
+  const pull = run('git pull --rebase', cwd);
+  if (!pull.ok) {
+    // Try to recover - maybe there's a conflict
+    run('git rebase --abort', cwd);
+    const retryPull = run('git pull --rebase', cwd);
+    if (!retryPull.ok) {
+      return {
+        success: false,
+        error: `Failed to pull latest: ${retryPull.output}. The codex repo may have conflicts that need manual resolution.`,
+      };
+    }
+  }
+
+  // Get current branch to confirm
+  const branch = run('git branch --show-current', cwd);
+
+  return {
+    success: true,
+    branch: branch.ok ? branch.output : 'main',
+    stashed,
+  };
+}
+
+// Main
+const args = process.argv.slice(2);
+const { config } = parseArgs(args);
+
+if (!config) {
+  console.log(JSON.stringify({
+    success: false,
+    error: 'Missing --config. Usage: droid config codex | droid exec droid-codex git-preamble --config -',
+  }));
+  process.exit(1);
+}
+
+if (!config.codex_repo) {
+  console.log(JSON.stringify({
+    success: false,
+    error: 'Missing codex_repo in config. Run: droid config codex --set codex_repo=~/path/to/codex',
+  }));
+  process.exit(1);
+}
+
+const result = gitPreamble(config.codex_repo);
+console.log(JSON.stringify(result, null, 2));
+
+if (!result.success) {
+  process.exit(1);
+}

package/src/tools/codex/skills/droid-codex/scripts/git-scripts.test.ts

@@ -0,0 +1,364 @@
+import { describe, it, expect, beforeEach, afterEach } from 'bun:test';
+import { execSync, spawnSync } from 'child_process';
+import { mkdtempSync, rmSync, mkdirSync, writeFileSync, existsSync } from 'fs';
+import { join } from 'path';
+import { tmpdir } from 'os';
+
+/**
+ * Integration tests for codex git scripts.
+ *
+ * These tests create real git repos and run the actual scripts,
+ * validating both the JSON output and the resulting git state.
+ */
+
+const SCRIPTS_DIR = __dirname;
+
+interface ScriptResult {
+  success: boolean;
+  branch?: string;
+  stashed?: boolean;
+  from?: string;
+  pr_url?: string;
+  error?: string;
+}
+
+function runScript(
+  scriptName: string,
+  args: string[],
+  config: Record<string, unknown>
+): ScriptResult {
+  const scriptPath = join(SCRIPTS_DIR, `${scriptName}.ts`);
+  const configJson = JSON.stringify(config);
+
+  const result = spawnSync('bun', ['run', scriptPath, '--config', configJson, ...args], {
+    encoding: 'utf-8',
+    cwd: process.cwd(),
+  });
+
+  if (result.error) {
+    return { success: false, error: result.error.message };
+  }
+
+  try {
+    return JSON.parse(result.stdout.trim());
+  } catch {
+    return {
+      success: false,
+      error: `Failed to parse output: ${result.stdout}\nStderr: ${result.stderr}`,
+    };
+  }
+}
+
+function git(cwd: string, ...args: string[]): string {
+  // Quote arguments that contain spaces
+  const quotedArgs = args.map(arg => (arg.includes(' ') ? `"${arg}"` : arg));
+  return execSync(`git ${quotedArgs.join(' ')}`, { cwd, encoding: 'utf-8' }).trim();
+}
+
+function createTestRepo(): { repo: string; remote: string } {
+  // Create temp directories for repo and "remote"
+  const baseDir = mkdtempSync(join(tmpdir(), 'codex-test-'));
+  const remoteDir = join(baseDir, 'remote.git');
+  const repoDir = join(baseDir, 'repo');
+
+  // Create bare "remote" repo
+  mkdirSync(remoteDir);
+  git(remoteDir, 'init', '--bare');
+
+  // Create working repo
+  mkdirSync(repoDir);
+  git(repoDir, 'init');
+  git(repoDir, 'config', 'user.email', 'test@test.com');
+  git(repoDir, 'config', 'user.name', 'Test User');
+
+  // Create initial commit
+  writeFileSync(join(repoDir, 'README.md'), '# Test Repo\n');
+  git(repoDir, 'add', '.');
+  git(repoDir, 'commit', '-m', 'Initial commit');
+
+  // Rename to main if needed
+  try {
+    git(repoDir, 'branch', '-M', 'main');
+  } catch {
+    // Already on main
+  }
+
+  // Add remote and push
+  git(repoDir, 'remote', 'add', 'origin', remoteDir);
+  git(repoDir, 'push', '-u', 'origin', 'main');
+
+  return { repo: repoDir, remote: remoteDir };
+}
+
+function createTestRepoSimple(): string {
+  const { repo } = createTestRepo();
+  return repo;
+}
+
+function cleanupTestRepo(path: string): void {
+  try {
+    rmSync(path, { recursive: true, force: true });
+  } catch {
+    // Ignore cleanup errors
+  }
+}
+
+describe('git-preamble', () => {
+  let testRepo: string;
+  let baseDir: string;
+
+  beforeEach(() => {
+    const { repo } = createTestRepo();
+    testRepo = repo;
+    // baseDir is the parent of repo
+    baseDir = join(testRepo, '..');
+  });
+
+  afterEach(() => {
+    cleanupTestRepo(baseDir);
+  });
+
+  it('succeeds on clean main branch', () => {
+    const result = runScript('git-preamble', [], { codex_repo: testRepo });
+
+    expect(result.success).toBe(true);
+    expect(result.branch).toBe('main');
+    expect(result.stashed).toBe(false);
+  });
+
+  it('returns to main from feature branch', () => {
+    // Create and checkout a feature branch
+    git(testRepo, 'checkout', '-b', 'feature/test');
+
+    const result = runScript('git-preamble', [], { codex_repo: testRepo });
+
+    expect(result.success).toBe(true);
+    expect(result.branch).toBe('main');
+
+    // Verify we're actually on main
+    const currentBranch = git(testRepo, 'branch', '--show-current');
+    expect(currentBranch).toBe('main');
+  });
+
+  it('stashes uncommitted changes', () => {
+    // Create uncommitted changes
+    writeFileSync(join(testRepo, 'dirty.txt'), 'uncommitted');
+    git(testRepo, 'add', 'dirty.txt');
+
+    const result = runScript('git-preamble', [], { codex_repo: testRepo });
+
+    expect(result.success).toBe(true);
+    expect(result.stashed).toBe(true);
+
+    // Verify the file is no longer in working directory
+    const status = git(testRepo, 'status', '--porcelain');
+    expect(status).toBe('');
+  });
+
+  it('fails with missing repo', () => {
+    const result = runScript('git-preamble', [], { codex_repo: '/nonexistent/path' });
+
+    expect(result.success).toBe(false);
+    expect(result.error).toContain('not found');
+  });
+
+  it('aborts stuck rebase', () => {
+    // Create a situation with a stuck rebase (simulate by creating the file)
+    mkdirSync(join(testRepo, '.git', 'rebase-merge'), { recursive: true });
+    writeFileSync(join(testRepo, '.git', 'rebase-merge', 'git-rebase-todo'), '');
+
+    const result = runScript('git-preamble', [], { codex_repo: testRepo });
+
+    // Should succeed after aborting the rebase
+    expect(result.success).toBe(true);
+  });
+});
+
+describe('git-start-write', () => {
+  let testRepo: string;
+  let baseDir: string;
+
+  beforeEach(() => {
+    const { repo } = createTestRepo();
+    testRepo = repo;
+    baseDir = join(testRepo, '..');
+  });
+
+  afterEach(() => {
+    cleanupTestRepo(baseDir);
+  });
+
+  it('creates a new branch from main', () => {
+    const result = runScript('git-start-write', ['--branch', 'codex/test-branch'], {
+      codex_repo: testRepo,
+    });
+
+    expect(result.success).toBe(true);
+    expect(result.branch).toBe('codex/test-branch');
+    expect(result.from).toBe('main');
+
+    // Verify we're on the new branch
+    const currentBranch = git(testRepo, 'branch', '--show-current');
+    expect(currentBranch).toBe('codex/test-branch');
+  });
+
+  it('resets existing branch to main', () => {
+    // Create branch with a commit
+    git(testRepo, 'checkout', '-b', 'codex/existing');
+    writeFileSync(join(testRepo, 'old-file.txt'), 'old content');
+    git(testRepo, 'add', '.');
+    git(testRepo, 'commit', '-m', 'Old commit');
+    git(testRepo, 'checkout', 'main');
+
+    // Start write should reset it
+    const result = runScript('git-start-write', ['--branch', 'codex/existing'], {
+      codex_repo: testRepo,
+    });
+
+    expect(result.success).toBe(true);
+
+    // The old file should not exist (branch was reset)
+    expect(existsSync(join(testRepo, 'old-file.txt'))).toBe(false);
+  });
+
+  it('fails without branch argument', () => {
+    const result = runScript('git-start-write', [], { codex_repo: testRepo });
+
+    expect(result.success).toBe(false);
+    expect(result.error).toContain('--branch');
+  });
+
+  it('runs preamble first (returns from feature branch)', () => {
+    // Start on a different branch
+    git(testRepo, 'checkout', '-b', 'feature/other');
+
+    const result = runScript('git-start-write', ['--branch', 'codex/new'], {
+      codex_repo: testRepo,
+    });
+
+    expect(result.success).toBe(true);
+    expect(result.branch).toBe('codex/new');
+  });
+});
+
+describe('git-finish-write', () => {
+  let testRepo: string;
+  let baseDir: string;
+
+  beforeEach(() => {
+    const { repo } = createTestRepo();
+    testRepo = repo;
+    baseDir = join(testRepo, '..');
+    // Start on a feature branch (simulating after git-start-write)
+    git(testRepo, 'checkout', '-b', 'codex/test-feature');
+  });
+
+  afterEach(() => {
+    cleanupTestRepo(baseDir);
+  });
+
+  it('commits changes and returns to main', () => {
+    // Create a change
+    writeFileSync(join(testRepo, 'new-file.md'), '# New Content\n');
+
+    const result = runScript(
+      'git-finish-write',
+      ['--message', 'test: add new file', '--pr-title', 'Test PR', '--pr-body', 'Test body'],
+      { codex_repo: testRepo }
+    );
+
+    // Note: PR creation will fail (no remote), but commit should succeed
+    // and we should return to main
+    const currentBranch = git(testRepo, 'branch', '--show-current');
+    expect(currentBranch).toBe('main');
+
+    // Verify the commit exists on the feature branch
+    const log = git(testRepo, 'log', 'codex/test-feature', '--oneline', '-1');
+    expect(log).toContain('test: add new file');
+  });
+
+  it('fails when on main branch', () => {
+    git(testRepo, 'checkout', 'main');
+
+    const result = runScript(
+      'git-finish-write',
+      ['--message', 'bad commit', '--pr-title', 'Bad PR'],
+      { codex_repo: testRepo }
+    );
+
+    expect(result.success).toBe(false);
+    expect(result.error).toContain('Cannot commit directly to main');
+  });
+
+  it('fails with no changes to commit', () => {
+    const result = runScript(
+      'git-finish-write',
+      ['--message', 'empty commit', '--pr-title', 'Empty PR'],
+      { codex_repo: testRepo }
+    );
+
+    expect(result.success).toBe(false);
+    expect(result.error).toContain('No changes to commit');
+  });
+
+  it('fails without required arguments', () => {
+    const noMessage = runScript('git-finish-write', ['--pr-title', 'Test'], {
+      codex_repo: testRepo,
+    });
+    expect(noMessage.success).toBe(false);
+    expect(noMessage.error).toContain('--message');
+
+    const noTitle = runScript('git-finish-write', ['--message', 'Test'], {
+      codex_repo: testRepo,
+    });
+    expect(noTitle.success).toBe(false);
+    expect(noTitle.error).toContain('--pr-title');
+  });
+});
+
+describe('full workflow', () => {
+  let testRepo: string;
+  let baseDir: string;
+
+  beforeEach(() => {
+    const { repo } = createTestRepo();
+    testRepo = repo;
+    baseDir = join(testRepo, '..');
+  });
+
+  afterEach(() => {
+    cleanupTestRepo(baseDir);
+  });
+
+  it('preamble -> start-write -> make changes -> finish-write', () => {
+    // 1. Preamble
+    const preamble = runScript('git-preamble', [], { codex_repo: testRepo });
+    expect(preamble.success).toBe(true);
+
+    // 2. Start write
+    const start = runScript('git-start-write', ['--branch', 'codex/full-test'], {
+      codex_repo: testRepo,
+    });
+    expect(start.success).toBe(true);
+    expect(start.branch).toBe('codex/full-test');
+
+    // 3. Make changes (create directory first)
+    mkdirSync(join(testRepo, 'topics'), { recursive: true });
+    writeFileSync(join(testRepo, 'topics', 'test-topic.md'), '# Test Topic\n');
+
+    // 4. Finish write (PR will fail but commit should work)
+    const finish = runScript(
+      'git-finish-write',
+      ['--message', 'topic: add test-topic', '--pr-title', 'Topic: test-topic'],
+      { codex_repo: testRepo }
+    );
+
+    // Should return to main regardless of PR status
+    const currentBranch = git(testRepo, 'branch', '--show-current');
+    expect(currentBranch).toBe('main');
+
+    // Verify commit exists on feature branch
+    const commits = git(testRepo, 'log', 'codex/full-test', '--oneline');
+    expect(commits).toContain('topic: add test-topic');
+  });
+});

package/src/tools/codex/skills/droid-codex/scripts/git-start-write.ts

@@ -0,0 +1,172 @@
+#!/usr/bin/env bun
+/**
+ * codex git-start-write
+ *
+ * Prepares the codex repo for a write operation by running preamble
+ * and creating a new branch.
+ *
+ * Usage:
+ *   droid config codex | droid exec droid-codex git-start-write --config - --branch codex/new-feature
+ *
+ * Options:
+ *   --config <json>   Config with codex_repo path (required)
+ *   --branch <name>   Branch name to create (required)
+ *
+ * What it does:
+ *   1. Run git-preamble (ensure clean main)
+ *   2. Create and checkout the new branch
+ *
+ * Output (JSON):
+ *   { "success": true, "branch": "codex/new-feature", "from": "main" }
+ */
+
+import { execSync } from 'child_process';
+import { readFileSync, existsSync } from 'fs';
+
+interface Config {
+  codex_repo: string;
+}
+
+interface Result {
+  success: boolean;
+  branch?: string;
+  from?: string;
+  error?: string;
+}
+
+function parseArgs(args: string[]): { config: Config | null; branch: string | null } {
+  let config: Config | null = null;
+  let branch: string | null = null;
+
+  for (let i = 0; i < args.length; i++) {
+    const arg = args[i];
+    if (arg === '--config' && args[i + 1]) {
+      const configArg = args[++i];
+      if (configArg === '-') {
+        const stdin = readFileSync(0, 'utf-8').trim();
+        config = JSON.parse(stdin) as Config;
+      } else {
+        config = JSON.parse(configArg) as Config;
+      }
+    } else if (arg === '--branch' && args[i + 1]) {
+      branch = args[++i];
+    }
+  }
+
+  return { config, branch };
+}
+
+function expandPath(p: string): string {
+  if (p.startsWith('~/')) {
+    return p.replace('~', process.env.HOME || '');
+  }
+  return p;
+}
+
+function run(cmd: string, cwd: string): { ok: boolean; output: string } {
+  try {
+    const output = execSync(cmd, {
+      cwd,
+      encoding: 'utf-8',
+      stdio: ['pipe', 'pipe', 'pipe'],
+    });
+    return { ok: true, output: output.trim() };
+  } catch (err: unknown) {
+    const error = err as { stderr?: string; message?: string };
+    return { ok: false, output: error.stderr || error.message || 'Unknown error' };
+  }
+}
+
+function gitStartWrite(repoPath: string, branchName: string): Result {
+  const cwd = expandPath(repoPath);
+
+  // Verify repo exists
+  if (!existsSync(cwd)) {
+    return {
+      success: false,
+      error: `Codex repo not found at ${cwd}`,
+    };
+  }
+
+  // 1. Run preamble steps inline (ensure clean main)
+  run('git merge --abort', cwd);
+  run('git rebase --abort', cwd);
+  run('git cherry-pick --abort', cwd);
+
+  const checkout = run('git checkout main', cwd);
+  if (!checkout.ok && !checkout.output.includes('Already on')) {
+    return { success: false, error: `Failed to checkout main: ${checkout.output}` };
+  }
+
+  // Stash uncommitted changes
+  const statusCheck = run('git status --porcelain', cwd);
+  if (statusCheck.ok && statusCheck.output.length > 0) {
+    run('git stash push -m "codex-auto-stash"', cwd);
+  }
+
+  // Pull latest
+  const pull = run('git pull --rebase', cwd);
+  if (!pull.ok) {
+    run('git rebase --abort', cwd);
+    const retryPull = run('git pull --rebase', cwd);
+    if (!retryPull.ok) {
+      return { success: false, error: `Failed to pull latest: ${retryPull.output}` };
+    }
+  }
+
+  // 2. Create and checkout new branch
+  // First check if branch already exists (locally or remotely)
+  const branchExists = run(`git show-ref --verify --quiet refs/heads/${branchName}`, cwd);
+  if (branchExists.ok) {
+    // Branch exists, check it out and reset to main
+    run(`git checkout ${branchName}`, cwd);
+    run('git reset --hard main', cwd);
+  } else {
+    // Create new branch
+    const createBranch = run(`git checkout -b ${branchName}`, cwd);
+    if (!createBranch.ok) {
+      return { success: false, error: `Failed to create branch: ${createBranch.output}` };
+    }
+  }
+
+  return {
+    success: true,
+    branch: branchName,
+    from: 'main',
+  };
+}
+
+// Main
+const args = process.argv.slice(2);
+const { config, branch } = parseArgs(args);
+
+if (!config) {
+  console.log(JSON.stringify({
+    success: false,
+    error: 'Missing --config. Usage: droid config codex | droid exec droid-codex git-start-write --config - --branch <name>',
+  }));
+  process.exit(1);
+}
+
+if (!config.codex_repo) {
+  console.log(JSON.stringify({
+    success: false,
+    error: 'Missing codex_repo in config',
+  }));
+  process.exit(1);
+}
+
+if (!branch) {
+  console.log(JSON.stringify({
+    success: false,
+    error: 'Missing --branch argument',
+  }));
+  process.exit(1);
+}
+
+const result = gitStartWrite(config.codex_repo, branch);
+console.log(JSON.stringify(result, null, 2));
+
+if (!result.success) {
+  process.exit(1);
+}