@orderful/droid 0.24.0 → 0.25.0

package/dist/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/dist/tools/codex/skills/droid-codex/scripts/git-start-write.d.ts

@@ -0,0 +1,23 @@
+#!/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" }
+ */
+export {};
+//# sourceMappingURL=git-start-write.d.ts.map

package/dist/tools/codex/skills/droid-codex/scripts/git-start-write.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"git-start-write.d.ts","sourceRoot":"","sources":["../../../../../../src/tools/codex/skills/droid-codex/scripts/git-start-write.ts"],"names":[],"mappings":";AACA;;;;;;;;;;;;;;;;;;;GAmBG"}

package/dist/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);
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@orderful/droid",
-  "version": "0.24.0",
+  "version": "0.25.0",
   "description": "AI workflow toolkit for sharing skills, commands, and agents across the team",
   "type": "module",
   "bin": {

package/src/bin/droid.ts

@@ -8,6 +8,7 @@ import { installCommand } from '../commands/install';
 import { uninstallCommand } from '../commands/uninstall';
 import { updateCommand } from '../commands/update';
 import { tuiCommand } from '../commands/tui';
+import { execCommand } from '../commands/exec';
 import { getVersion } from '../lib/version';
 
 const version = getVersion();
@@ -25,6 +26,7 @@ program
 program
   .command('config')
   .description('View or edit configuration')
+  .argument('[tool]', 'Get merged config for a tool (for deterministic scripts)')
   .option('-e, --edit', 'Open config in editor')
   .option('-g, --get <key>', 'Get a specific config value')
   .option('-s, --set <key=value>', 'Set a config value')
@@ -58,6 +60,13 @@ program
   .description('Launch interactive TUI dashboard')
   .action(tuiCommand);
 
+program
+  .command('exec <tool> <script>')
+  .description('Execute a tool script')
+  .argument('[args...]', 'Arguments to pass to the script')
+  .allowUnknownOption()
+  .action(execCommand);
+
 // If no command provided, launch TUI
 if (process.argv.length === 2) {
   tuiCommand();

package/src/commands/config.ts

@@ -6,7 +6,9 @@ import {
   getConfigValue,
   setConfigValue,
   configExists,
+  loadSkillOverrides,
 } from '../lib/config';
+import { getAITag } from '../lib/types';
 
 interface ConfigOptions {
   edit?: boolean;
@@ -14,9 +16,41 @@ interface ConfigOptions {
   set?: string;
 }
 
-export async function configCommand(options: ConfigOptions): Promise<void> {
+/**
+ * Merged config for a tool
+ * Contains global values plus tool-specific overrides
+ */
+export interface ToolConfig {
+  user_mention: string;
+  ai_mention: string;
+  [key: string]: unknown; // Tool-specific overrides (e.g., preserve_comments)
+}
+
+/**
+ * Get merged config for a tool (global + overrides)
+ * Used by deterministic scripts via `droid config <tool>`
+ */
+export function getToolConfig(toolName: string): ToolConfig {
+  const globalConfig = loadConfig();
+  const overrides = loadSkillOverrides(toolName);
+
+  return {
+    user_mention: globalConfig.user_mention,
+    ai_mention: getAITag(),
+    ...overrides, // Tool handles its own defaults
+  };
+}
+
+export async function configCommand(tool?: string, options?: ConfigOptions): Promise<void> {
+  // If tool provided, return merged config as JSON
+  if (tool) {
+    const toolConfig = getToolConfig(tool);
+    console.log(JSON.stringify(toolConfig, null, 2));
+    return;
+  }
+
   // Handle --edit flag
-  if (options.edit) {
+  if (options?.edit) {
     const configPath = getConfigPath();
     const editor = process.env.EDITOR || 'vim';
 
@@ -35,7 +69,7 @@ export async function configCommand(options: ConfigOptions): Promise<void> {
   }
 
   // Handle --get flag
-  if (options.get) {
+  if (options?.get) {
     const value = getConfigValue(options.get);
     if (value === undefined) {
       console.log(chalk.yellow(`Config key '${options.get}' not found`));
@@ -51,7 +85,7 @@ export async function configCommand(options: ConfigOptions): Promise<void> {
   }
 
   // Handle --set flag
-  if (options.set) {
+  if (options?.set) {
     const match = options.set.match(/^([^=]+)=(.*)$/);
     if (!match) {
       console.error(chalk.red('Invalid format. Use: --set key=value'));