self-healing-cli 0.0.1

package/README.md

@@ -0,0 +1,130 @@
+# self-healing-cli
+
+A CI auto-fix CLI tool powered by [GitHub Copilot CLI](https://github.com/github/copilot). When your CI fails, it captures the error logs, asks Copilot to fix them, verifies the fix, and creates a PR — or leaves a comment if the fix doesn't work.
+
+## How It Works
+
+```
+CI command fails
+       |
+       v
+  +---------+     +-----------+     +----------+
+  | collect |---->|   heal    |---->| Copilot  |
+  | (logs)  |     | (analyze) |     | (fix)    |
+  +---------+     +-----------+     +----------+
+                       |
+                       v
+                  Has changes?
+                  /         \
+                yes          no
+                /              \
+           Verify          Comment:
+           command         "no changes"
+           /    \
+        pass    fail
+        /          \
+   Create PR    Comment:
+               "needs review"
+```
+
+## Install
+
+```bash
+pnpm install
+pnpm build
+```
+
+## Usage
+
+### `collect` — Capture CI logs
+
+Run a command and save its output to a file. Exits with the command's exit code.
+
+```bash
+self-healing collect --command <cmd> --output <file>
+```
+
+| Option | Description |
+|---|---|
+| `--command` | Command to run |
+| `--output` | Output log file path |
+
+Example:
+
+```bash
+self-healing collect --command "pnpm run check" --output check.log
+```
+
+### `heal` — Auto-fix with Copilot
+
+Read a log file, send it to Copilot CLI for analysis, verify the fix, and create a PR or comment.
+
+```bash
+self-healing heal --log <file> --verify <cmd> [--model <model>] [--tail <lines>]
+```
+
+| Option | Description | Default |
+|---|---|---|
+| `--log` | Input log file path | (required) |
+| `--verify` | Command to verify the fix | (required) |
+| `--model` | Copilot model to use | Copilot default |
+| `--tail` | Number of log lines to send | `100` |
+
+Example:
+
+```bash
+self-healing heal --log check.log --verify "pnpm run check" --model gpt-5.2
+```
+
+## GitHub Actions
+
+### Auto-heal on lint/test failure
+
+```yaml
+# .github/workflows/lint.yml
+- name: Lint
+  id: lint
+  continue-on-error: true
+  run: npx self-healing collect --command "pnpm run check" --output lint.log
+
+- name: Heal lint
+  if: steps.lint.outcome == 'failure'
+  env:
+    COPILOT_GITHUB_TOKEN: ${{ secrets.COPILOT_GITHUB_TOKEN }}
+    GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+  run: |
+    npm install -g @github/copilot
+    npx self-healing heal --log lint.log --verify "pnpm run check"
+```
+
+### Manual dispatch
+
+The `copilot.yml` workflow supports `workflow_dispatch` with custom `command` and `verify` inputs, so you can trigger a heal run from the GitHub Actions UI for any command.
+
+## Prerequisites
+
+- Node.js >= 22
+- [GitHub Copilot CLI](https://github.com/github/copilot) (`npm install -g @github/copilot`)
+- [GitHub CLI](https://cli.github.com/) (`gh`) — for creating PRs and comments
+- `COPILOT_GITHUB_TOKEN` secret in your repo
+
+## Development
+
+```bash
+pnpm install        # install dependencies
+pnpm dev            # watch mode
+pnpm build          # build
+pnpm test           # run tests
+pnpm run check      # lint + format (biome)
+```
+
+## Tech Stack
+
+- TypeScript (ESM)
+- [Rslib](https://rslib.rs/) — build
+- [Rstest](https://rstest.rs/) — test
+- [Biome](https://biomejs.dev/) — lint & format
+
+## License
+
+MIT

package/dist/cli.js

@@ -0,0 +1,273 @@
+#!/usr/bin/env node
+import node_fs from "node:fs";
+import node_path from "node:path";
+import { execSync } from "node:child_process";
+const exec = (command, options)=>{
+    try {
+        const stdout = execSync(command, {
+            cwd: options?.cwd,
+            env: options?.env ? {
+                ...process.env,
+                ...options.env
+            } : void 0,
+            encoding: 'utf-8',
+            stdio: [
+                'pipe',
+                'pipe',
+                'pipe'
+            ]
+        });
+        return {
+            ok: true,
+            stdout,
+            stderr: '',
+            exitCode: 0
+        };
+    } catch (error) {
+        const err = error;
+        return {
+            ok: false,
+            stdout: err.stdout ?? '',
+            stderr: err.stderr ?? '',
+            exitCode: err.status ?? 1
+        };
+    }
+};
+const prefix = '[self-healing]';
+const logger = {
+    info: (...args)=>console.log(prefix, ...args),
+    error: (...args)=>console.error(prefix, 'ERROR:', ...args),
+    success: (...args)=>console.log(prefix, '✓', ...args)
+};
+const collect = (options)=>{
+    const { command, outputFile } = options;
+    logger.info(`Running: ${command}`);
+    const result = exec(`${command} 2>&1`);
+    const output = result.stdout + result.stderr;
+    const dir = node_path.dirname(outputFile);
+    if (!node_fs.existsSync(dir)) node_fs.mkdirSync(dir, {
+        recursive: true
+    });
+    node_fs.writeFileSync(outputFile, output, 'utf-8');
+    logger.info(`Log saved to ${outputFile} (exit code: ${result.exitCode})`);
+    return {
+        exitCode: result.exitCode,
+        logFile: outputFile
+    };
+};
+const getCurrentBranch = (cwd)=>{
+    const result = exec('git branch --show-current', {
+        cwd
+    });
+    return result.stdout.trim();
+};
+const hasChanges = (cwd)=>{
+    const result = exec('git status --porcelain', {
+        cwd
+    });
+    return result.stdout.trim().length > 0;
+};
+const createBranch = (name, cwd)=>{
+    exec(`git checkout -b ${name}`, {
+        cwd
+    });
+};
+const commitAll = (message, cwd)=>{
+    exec('git add -A', {
+        cwd
+    });
+    exec(`git commit -m "${message}"`, {
+        cwd
+    });
+};
+const push = (branch, cwd)=>{
+    exec(`git push origin ${branch}`, {
+        cwd
+    });
+};
+const configBot = (cwd)=>{
+    exec('git config user.name "github-actions[bot]"', {
+        cwd
+    });
+    exec('git config user.email "github-actions[bot]@users.noreply.github.com"', {
+        cwd
+    });
+};
+const buildPrBody = (options)=>`## Auto-generated Fix
+
+This PR was automatically created to fix CI failures on **${options.baseBranch}**.
+
+### Error Log
+\`\`\`
+${options.logSnippet}
+\`\`\`
+
+---
+*Generated by self-healing-cli*`;
+const createPullRequest = (options)=>{
+    const result = exec(`gh pr create --title "${options.title}" --body "${options.body.replace(/"/g, '\\"')}" --base "${options.base}" --head "${options.head}"`, {
+        cwd: options.cwd
+    });
+    if (!result.ok) logger.error('Failed to create PR:', result.stderr);
+    return result.stdout.trim();
+};
+const commentOnCommit = (options)=>{
+    const result = exec(`gh api repos/{owner}/{repo}/commits/${options.sha}/comments -f body="${options.body.replace(/"/g, '\\"')}"`, {
+        cwd: options.cwd
+    });
+    if (!result.ok) logger.error('Failed to comment on commit:', result.stderr);
+};
+const readLogTail = (logFile, lines)=>{
+    const content = node_fs.readFileSync(logFile, 'utf-8');
+    const allLines = content.split('\n');
+    return allLines.slice(-lines).join('\n');
+};
+const buildCopilotPrompt = (options)=>[
+        'Analyze this CI failure and fix it.',
+        'After applying fixes, verify by running:',
+        `  ${options.verifyCommand}`,
+        '',
+        'Error log:',
+        options.errorLog
+    ].join('\n');
+const heal = (options)=>{
+    const { logFile, verifyCommand, tailLines = 100, model } = options;
+    const errorLog = readLogTail(logFile, tailLines);
+    logger.info(`Read ${tailLines} lines from ${logFile}`);
+    const prompt = buildCopilotPrompt({
+        errorLog,
+        verifyCommand
+    });
+    const baseBranch = getCurrentBranch();
+    const shaResult = exec('git rev-parse HEAD');
+    const commitSha = shaResult.stdout.trim();
+    const fixBranch = `auto-fix/self-healing-${Date.now()}`;
+    configBot();
+    createBranch(fixBranch);
+    logger.info(`Created branch: ${fixBranch}`);
+    logger.info('Asking Copilot to analyze and fix...');
+    const modelFlag = model ? ` --model ${model}` : '';
+    const escapedPrompt = prompt.replace(/"/g, '\\"');
+    const copilotResult = exec(`copilot --prompt "${escapedPrompt}" --yolo${modelFlag}`);
+    if (!copilotResult.ok) {
+        logger.error('Copilot CLI failed:', copilotResult.stderr);
+        const body = `## Self-Healing CLI\n\nCopilot CLI failed to run.\n\n\`\`\`\n${copilotResult.stderr}\n\`\`\``;
+        commentOnCommit({
+            sha: commitSha,
+            body
+        });
+        return {
+            fixed: false,
+            comment: body
+        };
+    }
+    if (!hasChanges()) {
+        logger.info('Copilot made no file changes');
+        const body = '## Self-Healing CLI\n\nCopilot analyzed the failure but did not produce any file changes.';
+        commentOnCommit({
+            sha: commitSha,
+            body
+        });
+        return {
+            fixed: false,
+            comment: body
+        };
+    }
+    logger.info(`Verifying fix with: ${verifyCommand}`);
+    const verifyResult = exec(verifyCommand);
+    if (verifyResult.ok) {
+        logger.success('Fix verified!');
+        commitAll('fix: auto-fix CI failure\n\nApplied by self-healing-cli via Copilot.');
+        push(fixBranch);
+        const prBody = buildPrBody({
+            baseBranch,
+            logSnippet: errorLog.slice(-2000)
+        });
+        const prUrl = createPullRequest({
+            title: `fix: auto-heal CI failure on ${baseBranch}`,
+            body: prBody,
+            base: baseBranch,
+            head: fixBranch
+        });
+        logger.success(`PR created: ${prUrl}`);
+        return {
+            fixed: true,
+            prUrl
+        };
+    }
+    logger.error('Fix did not pass verification');
+    const body = `## Self-Healing CLI\n\nCopilot suggested a fix but it did not pass verification (\`${verifyCommand}\`).\n\nPlease review manually.\n\n### Verification output\n\`\`\`\n${verifyResult.stdout + verifyResult.stderr}\n\`\`\``;
+    commentOnCommit({
+        sha: commitSha,
+        body
+    });
+    return {
+        fixed: false,
+        comment: body
+    };
+};
+const cli_args = process.argv.slice(2);
+const cli_command = cli_args[0];
+const getFlag = (name)=>{
+    const index = cli_args.indexOf(`--${name}`);
+    if (-1 === index || index + 1 >= cli_args.length) return;
+    return cli_args[index + 1];
+};
+const printHelp = ()=>{
+    console.log(`
+self-healing-cli
+
+Usage:
+  self-healing collect --command <cmd> --output <file>
+  self-healing heal --log <file> --verify <cmd> [--model <model>] [--tail <lines>]
+
+Commands:
+  collect   Run a command and save output to a log file
+  heal      Feed log to Copilot CLI, verify fix, create PR or comment
+
+Options:
+  --command   Command to run (collect)
+  --output    Output log file path (collect)
+  --log       Input log file path (heal)
+  --verify    Verification command (heal)
+  --model     Copilot model to use (heal, optional)
+  --tail      Number of log lines to send (heal, default: 100)
+  --help      Show this help message
+`);
+};
+if (!cli_command || '--help' === cli_command || '-h' === cli_command) {
+    printHelp();
+    process.exit(0);
+}
+if ('collect' === cli_command) {
+    const cmd = getFlag('command');
+    const output = getFlag('output');
+    if (!cmd || !output) {
+        logger.error('collect requires --command and --output');
+        process.exit(1);
+    }
+    const result = collect({
+        command: cmd,
+        outputFile: output
+    });
+    process.exit(result.exitCode);
+}
+if ('heal' === cli_command) {
+    const logFile = getFlag('log');
+    const verify = getFlag('verify');
+    if (!logFile || !verify) {
+        logger.error('heal requires --log and --verify');
+        process.exit(1);
+    }
+    const tailStr = getFlag('tail');
+    const result = heal({
+        logFile,
+        verifyCommand: verify,
+        model: getFlag('model'),
+        tailLines: tailStr ? Number(tailStr) : void 0
+    });
+    process.exit(result.fixed ? 0 : 1);
+}
+logger.error(`Unknown command: ${cli_command}`);
+printHelp();
+process.exit(1);

package/package.json

@@ -0,0 +1,31 @@
+{
+  "name": "self-healing-cli",
+  "version": "0.0.1",
+  "type": "module",
+  "bin": {
+    "self-healing": "./dist/cli.js"
+  },
+  "files": [
+    "dist"
+  ],
+  "devDependencies": {
+    "@biomejs/biome": "2.3.8",
+    "@rslib/core": "^0.19.5",
+    "@rstest/adapter-rslib": "^0.2.0",
+    "@rstest/core": "^0.8.1",
+    "@types/node": "^24.10.9",
+    "typescript": "^5.9.3"
+  },
+  "publishConfig": {
+    "access": "public",
+    "registry": "https://registry.npmjs.org/"
+  },
+  "scripts": {
+    "build": "rslib build",
+    "check": "biome check --write",
+    "dev": "rslib build --watch",
+    "format": "biome format --write",
+    "test": "rstest",
+    "test:watch": "rstest --watch"
+  }
+}