@slahon/lazykit 1.1.1 → 1.2.1

package/README.md

@@ -1,72 +1,132 @@
-# 🦥 LazyKit
-
-**Drop an issue, get a PR.**
-
-LazyKit wires Claude AI into your GitHub repo so that when you label an issue, Claude reads it, writes the code, and opens a pull request — while you do something else.
-
-## Quickstart
-
-```bash
-npx @slahon/lazykit@latest init
-```
-
-Run this inside your project folder. It will:
-- Create `.github/workflows/lazykit.yml`
-- Create `CLAUDE.md` with project context for Claude
-- Create the trigger label on GitHub
-- Print the one manual step (adding your Claude token)
-
-## Requirements
-
-- Node.js 18+
-- A GitHub repository
-- A Claude Pro or Max subscription ([claude.ai](https://claude.ai))
-- Claude Code installed locally (`npm install -g @anthropic-ai/claude-code`)
-- GitHub CLI (`gh`) — optional but recommended
-
-## How it works
-
-1. You open a GitHub issue describing what you want
-2. You apply the `lazykit` label (or whatever you named it)
-3. A GitHub Actions workflow fires and runs Claude Code
-4. Claude reads the issue, explores your codebase, writes the changes
-5. Claude opens a pull request with a title and description
-6. You review and merge
-
-## Authentication
-
-LazyKit uses your Claude Pro/Max subscription via an OAuth token — no pay-per-token API billing.
-
-After running `npx lazykit init`, you need to:
-
-1. Generate your token:
-   ```bash
-   claude setup-token
-   ```
-
-2. Add it to your repo as a secret named `CLAUDE_CODE_OAUTH_TOKEN`
-
-## CLAUDE.md
-
-LazyKit creates a `CLAUDE.md` file at your repo root. This is Claude's project guide — it tells Claude about your stack, conventions, and what commands to run before opening a PR. Edit it to match your actual project.
-
-## Options
-
-During `npx lazykit init` you will be asked:
-
-| Option | Default | Description |
-|--------|---------|-------------|
-| Label name | `lazykit` | The GitHub label that triggers Claude |
-| Stack | — | Your tech stack (goes into CLAUDE.md) |
-| Lint command | `npm run lint` | Run before every PR |
-| Test command | `npm test` | Run before every PR |
-
-## Tips
-
-- **Keep issues small and specific.** "Add a /health endpoint that returns `{ status: 'ok' }`" works great. "Rewrite the auth system" does not.
-- **Edit CLAUDE.md** to describe your folder structure, naming conventions, and any rules Claude must follow.
-- The `lazykit` label is your control switch — Claude only runs when you apply it, so you stay in charge.
-
-## License
-
-MIT
+# 🦥 LazyKit
+
+**Drop an issue, get a PR.**
+
+LazyKit wires Claude AI into your GitHub repo so that when you open an issue, Claude reads it, writes the code, and opens a pull request — while you do something else.
+
+## Quickstart
+
+```bash
+npx @slahon/lazykit@latest init
+```
+
+Run this inside your project folder. That's it. LazyKit handles everything else automatically.
+
+## Requirements
+
+- Node.js 18+
+- A GitHub repository with a remote set up
+- A Claude Pro or Max subscription ([claude.ai](https://claude.ai))
+- Claude Code installed locally (`npm install -g @anthropic-ai/claude-code`)
+- GitHub CLI (`gh`) — required for full automation (`brew install gh` / [cli.github.com](https://cli.github.com))
+
+## How it works
+
+1. You open a GitHub issue using the **LazyKit Task** template
+2. Claude starts working on it automatically (or when you apply the label — your choice)
+3. Claude reads the issue, explores your codebase, writes the changes
+4. Claude opens a pull request with a title and description
+5. You review and merge
+
+You can also mention `@claude` in any issue comment to give follow-up instructions or re-trigger Claude mid-thread.
+
+## What `init` does
+
+Running `npx @slahon/lazykit@latest init` fully sets up your repo — no manual steps required:
+
+| Step | What happens |
+|------|-------------|
+| Detects repo | Reads your `git remote` to find your GitHub repo |
+| Detects stack | Auto-detects your tech stack from `package.json`, `go.mod`, `Cargo.toml`, etc. |
+| Creates workflow | `.github/workflows/lazykit.yml` — the GitHub Actions automation |
+| Creates issue template | `.github/ISSUE_TEMPLATE/lazykit.md` — auto-applies the trigger label |
+| Creates CLAUDE.md | Project guide so Claude understands your codebase |
+| Creates label | Creates the trigger label on GitHub |
+| Enables PR creation | Grants Actions permission to open pull requests |
+| Sets token | Runs `claude setup-token` and stores it as `CLAUDE_CODE_OAUTH_TOKEN` in your repo secrets |
+| Commits and pushes | Commits all generated files and pushes to GitHub |
+
+## Commands
+
+```bash
+npx @slahon/lazykit@latest init      # Set up LazyKit in your repo
+npx @slahon/lazykit@latest status    # Check if everything is wired up correctly
+npx @slahon/lazykit@latest update    # Regenerate workflow and CLAUDE.md
+npx @slahon/lazykit@latest remove    # Remove LazyKit from your repo
+```
+
+### Flags
+
+```bash
+npx @slahon/lazykit@latest init --dry-run      # Preview what would happen without writing files
+npx @slahon/lazykit@latest update --dry-run    # Preview changes without applying them
+```
+
+### `lazykit status`
+
+Runs a health check and reports:
+
+- Workflow file present
+- Issue template present
+- CLAUDE.md present
+- `CLAUDE_CODE_OAUTH_TOKEN` secret exists (with age warning if over 6 months old)
+- Trigger label exists on GitHub
+- Actions PR creation permission is enabled
+- Branch protection status on `main`
+
+### `lazykit update`
+
+Re-generates `.github/workflows/lazykit.yml` (and optionally `CLAUDE.md`) without re-doing the full setup. Useful when you want to pull in changes to the workflow template. Reads your existing label name and trigger mode from the current workflow file.
+
+### `lazykit remove`
+
+Cleanly removes LazyKit from your repo:
+- Deletes the workflow file, issue template, and optionally CLAUDE.md
+- Deletes the trigger label from GitHub
+- Deletes the `CLAUDE_CODE_OAUTH_TOKEN` secret
+- Commits and pushes the removals
+
+## Init options
+
+During `npx @slahon/lazykit@latest init` you will be asked:
+
+| Option | Default | Description |
+|--------|---------|-------------|
+| Label name | `lazykit` | The GitHub label that triggers Claude |
+| Auto-trigger | Yes | Trigger Claude on every new issue, or only when you apply the label |
+| Generate CLAUDE.md | Yes | Create a project guide for Claude |
+
+## Trigger modes
+
+**Auto (default)** — Claude fires the moment a new issue is opened. No label needed.
+
+**Label-controlled** — Claude only runs when you apply the trigger label. Use this when you want to review issues before handing them to Claude.
+
+## Authentication
+
+LazyKit uses your Claude Pro/Max subscription via an OAuth token — no pay-per-token API billing.
+
+`init` handles this automatically: it runs `claude setup-token`, captures the token, and stores it as `CLAUDE_CODE_OAUTH_TOKEN` in your repo secrets via `gh secret set`.
+
+If the token can't be set automatically (Claude Code not installed or `gh` not available), you'll see step-by-step instructions to do it manually.
+
+**Token expiry:** OAuth tokens can expire. Run `lazykit status` to check the age of your token. If it's expired, re-run `npx @slahon/lazykit@latest init` to generate and store a fresh one.
+
+## CLAUDE.md
+
+LazyKit creates a `CLAUDE.md` file at your repo root. This is Claude's project guide — it tells Claude about your stack, coding conventions, and rules to follow. Edit it to match your actual project for best results.
+
+## Branch protection
+
+If your `main` branch has protection rules enabled, Claude's pull requests will be opened but **cannot be auto-merged** — they will require manual review and approval. LazyKit detects this during `init` and `status` and warns you.
+
+## Tips
+
+- **Keep issues small and specific.** "Add a `/health` endpoint that returns `{ status: 'ok' }`" works great. "Rewrite the auth system" does not.
+- **Edit CLAUDE.md** to describe your folder structure, naming conventions, and any rules Claude must follow.
+- **Use `@claude` in comments** to give Claude follow-up instructions or corrections without opening a new issue.
+- **Run `lazykit status`** if something stops working — it pinpoints exactly what's misconfigured.
+
+## License
+
+MIT

package/git.js

@@ -91,4 +91,13 @@ function detectStack() {
   return stack.length > 0 ? stack.join(' + ') : null;
 }
 
-module.exports = { getGitRemote, parseGitHubRepo, isGitRepo, isGhCliAvailable, isGhAuthenticated, detectStack };
+function hasBranchProtection({ owner, repo }) {
+  try {
+    execSync(`gh api repos/${owner}/${repo}/branches/main/protection`, { stdio: 'pipe' });
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+module.exports = { getGitRemote, parseGitHubRepo, isGitRepo, isGhCliAvailable, isGhAuthenticated, detectStack, hasBranchProtection };

package/index.js

@@ -3,14 +3,36 @@
 'use strict';
 
 const { init } = require('./init');
+const { update } = require('./update');
+const { status } = require('./status');
+const { remove } = require('./remove');
 
-const [,, command] = process.argv;
+const [,, command, ...args] = process.argv;
+const dryRun = args.includes('--dry-run');
 
 switch (command) {
   case 'init':
   case undefined:
-    init().catch(err => {
-      console.error('\n❌ Setup failed:', err.message);
+    init({ dryRun }).catch(err => {
+      console.error('\n  Setup failed:', err.message);
+      process.exit(1);
+    });
+    break;
+  case 'update':
+    update({ dryRun }).catch(err => {
+      console.error('\n  Update failed:', err.message);
+      process.exit(1);
+    });
+    break;
+  case 'status':
+    status().catch(err => {
+      console.error('\n  Status check failed:', err.message);
+      process.exit(1);
+    });
+    break;
+  case 'remove':
+    remove().catch(err => {
+      console.error('\n  Remove failed:', err.message);
       process.exit(1);
     });
     break;
@@ -19,6 +41,12 @@ switch (command) {
 🦥  LazyKit — Drop an issue, get a PR.
 
 Usage:
-  npx lazykit init     Set up LazyKit in your current GitHub repo
+  npx @slahon/lazykit@latest init          Set up LazyKit in your current GitHub repo
+  npx @slahon/lazykit@latest update        Regenerate workflow and CLAUDE.md
+  npx @slahon/lazykit@latest status        Check if everything is wired up correctly
+  npx @slahon/lazykit@latest remove        Remove LazyKit from your repo
+
+Flags:
+  --dry-run    Preview what would happen without writing files (init, update)
 `);
 }

package/init.js

@@ -7,28 +7,30 @@ const chalk = require('chalk');
 const ora = require('ora');
 
 const { log } = require('./logger');
-const { ask, confirm, select } = require('./prompt');
-const { isGitRepo, getGitRemote, parseGitHubRepo, isGhCliAvailable, isGhAuthenticated, detectStack } = require('./git');
+const { ask, confirm } = require('./prompt');
+const { isGitRepo, getGitRemote, parseGitHubRepo, isGhCliAvailable, isGhAuthenticated, detectStack, hasBranchProtection } = require('./git');
 const { generateWorkflow } = require('./workflow');
 const { generateClaudeMd } = require('./claude-md');
+const { generateIssueTemplate } = require('./issue-template');
+
+async function init({ dryRun = false } = {}) {
+  if (dryRun) console.log(chalk.yellow('\n  [dry-run] Preview mode — no files will be written or API calls made.\n'));
 
-async function init() {
   console.log(chalk.bold.white('\n🦥  LazyKit — Drop an issue, get a PR.\n'));
   console.log(chalk.gray('  This will set up AI-powered issue-to-PR automation in your repo.\n'));
 
-  // ─── Step 1: Verify git repo ─────────────────────────────────────────────
+  // ─── Step 1: Verify git repo ──────────────────────────────────────────────
   if (!isGitRepo()) {
     log.error('Not inside a git repository.');
     console.log(chalk.gray('\n  LazyKit needs a git repo with a GitHub remote. To set one up:\n'));
     console.log(chalk.cyan('    git init'));
     console.log(chalk.cyan('    git remote add origin https://github.com/<you>/<repo>'));
-    console.log(chalk.gray('\n  Then re-run: ') + chalk.cyan('npx @slahon/lazykit init\n'));
+    console.log(chalk.gray('\n  Then re-run: ') + chalk.cyan('npx @slahon/lazykit@latest init\n'));
     process.exit(1);
   }
 
   const remote = getGitRemote();
   const repoInfo = parseGitHubRepo(remote);
-
   const stack = detectStack();
 
   if (repoInfo) {
@@ -39,11 +41,11 @@ async function init() {
     console.log(chalk.gray('\n  LazyKit requires a GitHub repository with a remote set up.\n'));
     console.log(chalk.gray('  To fix this, connect your repo to GitHub first:\n'));
     console.log(chalk.cyan('    git remote add origin https://github.com/<you>/<repo>'));
-    console.log(chalk.gray('\n  Then re-run: ') + chalk.cyan('npx @slahon/lazykit init\n'));
+    console.log(chalk.gray('\n  Then re-run: ') + chalk.cyan('npx @slahon/lazykit@latest init\n'));
     process.exit(1);
   }
 
-  // ─── Step 2: Check gh CLI and auth ──────────────────────────────────────
+  // ─── Step 2: Check gh CLI and auth ───────────────────────────────────────
   const ghAvailable = isGhCliAvailable();
   let ghReady = false;
 
@@ -68,51 +70,66 @@ async function init() {
 
   log.blank();
 
-  // ─── Step 3: Ask questions ───────────────────────────────────────────────
+  // ─── Step 3: Ask questions ────────────────────────────────────────────────
   log.title('Configure LazyKit');
   log.blank();
 
   const label = await ask('Label name to trigger Claude', 'lazykit');
-
   const autoTrigger = await confirm('Trigger Claude on every new issue automatically? (no = only when you apply the label)', true);
-
   const wantClaudeMd = await confirm('Generate CLAUDE.md project guide?', true);
 
   log.blank();
 
-  // ─── Step 4: Create workflow file ────────────────────────────────────────
-  const spinner = ora({ text: 'Creating workflow file...', color: 'cyan' }).start();
-
+  // ─── Step 4: Create workflow file ─────────────────────────────────────────
   const workflowDir = path.join(process.cwd(), '.github', 'workflows');
-  fs.mkdirSync(workflowDir, { recursive: true });
-
   const workflowPath = path.join(workflowDir, 'lazykit.yml');
-  const workflowContent = generateWorkflow({ label, autoTrigger });
-  fs.writeFileSync(workflowPath, workflowContent);
 
-  spinner.succeed(chalk.green('Created .github/workflows/lazykit.yml'));
+  if (dryRun) {
+    log.info('[dry-run] Would create: .github/workflows/lazykit.yml');
+  } else {
+    const spinner = ora({ text: 'Creating workflow file...', color: 'cyan' }).start();
+    fs.mkdirSync(workflowDir, { recursive: true });
+    fs.writeFileSync(workflowPath, generateWorkflow({ label, autoTrigger }));
+    spinner.succeed(chalk.green('Created .github/workflows/lazykit.yml'));
+  }
+
+  // ─── Step 5: Create issue template ───────────────────────────────────────
+  const templateDir = path.join(process.cwd(), '.github', 'ISSUE_TEMPLATE');
+  const templatePath = path.join(templateDir, 'lazykit.md');
 
-  // ─── Step 5: Create CLAUDE.md ────────────────────────────────────────────
+  if (dryRun) {
+    log.info('[dry-run] Would create: .github/ISSUE_TEMPLATE/lazykit.md');
+  } else {
+    const spinner = ora({ text: 'Creating issue template...', color: 'cyan' }).start();
+    fs.mkdirSync(templateDir, { recursive: true });
+    fs.writeFileSync(templatePath, generateIssueTemplate({ label }));
+    spinner.succeed(chalk.green('Created .github/ISSUE_TEMPLATE/lazykit.md'));
+  }
+
+  // ─── Step 6: Create CLAUDE.md ─────────────────────────────────────────────
   if (wantClaudeMd) {
     const claudeMdPath = path.join(process.cwd(), 'CLAUDE.md');
-    const claudeMdContent = generateClaudeMd({ stack });
 
-    if (fs.existsSync(claudeMdPath)) {
+    if (dryRun) {
+      log.info('[dry-run] Would create: CLAUDE.md');
+    } else if (fs.existsSync(claudeMdPath)) {
       const overwrite = await confirm('CLAUDE.md already exists. Overwrite?', false);
       if (overwrite) {
-        fs.writeFileSync(claudeMdPath, claudeMdContent);
+        fs.writeFileSync(claudeMdPath, generateClaudeMd({ stack }));
         log.success('Updated CLAUDE.md');
       } else {
         log.warn('Skipped CLAUDE.md — keeping existing file.');
       }
     } else {
-      fs.writeFileSync(claudeMdPath, claudeMdContent);
+      fs.writeFileSync(claudeMdPath, generateClaudeMd({ stack }));
       log.success('Created CLAUDE.md');
     }
   }
 
-  // ─── Step 6: Create GitHub label ─────────────────────────────────────────
-  if (ghReady) {
+  // ─── Step 7: Create GitHub label ──────────────────────────────────────────
+  if (dryRun) {
+    log.info(`[dry-run] Would create GitHub label: '${label}'`);
+  } else if (ghReady) {
     const labelSpinner = ora({ text: `Creating '${label}' label on GitHub...`, color: 'cyan' }).start();
     try {
       execSync(
@@ -125,15 +142,17 @@ async function init() {
       if (msg.includes('already exists')) {
         labelSpinner.succeed(chalk.green(`Label '${label}' already exists — skipping`));
       } else {
-        labelSpinner.warn(chalk.yellow(`Could not create label automatically — you'll need to create it manually`));
+        labelSpinner.warn(chalk.yellow(`Could not create label — create it manually at https://github.com/${repoInfo.owner}/${repoInfo.repo}/labels`));
       }
     }
   } else {
     log.warn(`Create the '${label}' label manually at: ${chalk.cyan(`https://github.com/${repoInfo.owner}/${repoInfo.repo}/labels`)}`);
   }
 
-  // ─── Step 7: Enable Actions to create PRs ────────────────────────────────
-  if (ghReady) {
+  // ─── Step 8: Enable Actions PR creation ───────────────────────────────────
+  if (dryRun) {
+    log.info('[dry-run] Would enable Actions PR creation permission');
+  } else if (ghReady) {
     const prSpinner = ora({ text: 'Enabling Actions PR creation permission...', color: 'cyan' }).start();
     try {
       execSync(
@@ -154,89 +173,109 @@ async function init() {
     }
   }
 
-  // ─── Step 8: Generate and set Claude token ───────────────────────────────
-  console.log('\n' + chalk.bold.green('  ✨ Almost there — setting up your Claude token...\n'));
-
-  let tokenSet = false;
-
-  try {
-    log.info('Running claude setup-token (a browser window may open to authenticate)...');
-    console.log();
-
-    const result = spawnSync('claude', ['setup-token'], {
-      stdio: ['inherit', 'pipe', 'pipe'],
-      encoding: 'utf8',
-    });
-
-    if (result.stderr) process.stderr.write(result.stderr);
+  // ─── Step 9: Branch protection warning ────────────────────────────────────
+  if (!dryRun && ghReady && hasBranchProtection(repoInfo)) {
+    log.warn('Branch protection is enabled on main.');
+    console.log(chalk.gray("  Claude's PRs will be opened but cannot be auto-merged — they require manual review.\n"));
+  }
 
-    const output = (result.stdout || '') + (result.stderr || '');
-    const tokenMatch = output.match(/sk-ant-oat[^\s]+/);
+  // ─── Step 10: Generate and set Claude token ────────────────────────────────
+  if (dryRun) {
+    log.info('[dry-run] Would run claude setup-token and set CLAUDE_CODE_OAUTH_TOKEN secret');
+  } else {
+    console.log('\n' + chalk.bold.green('  ✨ Almost there — setting up your Claude token...\n'));
 
-    if (tokenMatch && ghReady) {
-      const token = tokenMatch[0];
-      const secretSpinner = ora({ text: 'Adding CLAUDE_CODE_OAUTH_TOKEN to GitHub secrets...', color: 'cyan' }).start();
-      execSync(
-        `gh secret set CLAUDE_CODE_OAUTH_TOKEN --body "${token}" --repo ${repoInfo.owner}/${repoInfo.repo}`,
-        { stdio: 'pipe' }
-      );
-      secretSpinner.succeed(chalk.green('CLAUDE_CODE_OAUTH_TOKEN added to GitHub secrets'));
-      tokenSet = true;
-    } else if (tokenMatch && !ghReady) {
-      log.warn('Token generated but gh CLI not found — add it manually:');
-      console.log(chalk.gray('       Name:  ') + chalk.cyan('CLAUDE_CODE_OAUTH_TOKEN'));
-      console.log(chalk.gray('       Value: ') + chalk.cyan(tokenMatch[0]));
-      console.log(chalk.cyan(`       https://github.com/${repoInfo.owner}/${repoInfo.repo}/settings/secrets/actions`));
-    } else {
-      throw new Error('Token not found in output');
-    }
-  } catch (err) {
-    const isNotFound = err.status === 'ENOENT' || (err.message || '').includes('ENOENT');
-    if (isNotFound) {
-      log.warn('Claude Code CLI not found — install it first:');
-      console.log(chalk.cyan('\n    npm install -g @anthropic-ai/claude-code'));
-    } else {
-      log.warn('Could not set token automatically.');
+    try {
+      log.info('Running claude setup-token (a browser window may open to authenticate)...');
+      console.log();
+
+      const result = spawnSync('claude', ['setup-token'], {
+        stdio: ['inherit', 'pipe', 'pipe'],
+        encoding: 'utf8',
+      });
+
+      if (result.stderr) process.stderr.write(result.stderr);
+
+      const output = (result.stdout || '') + (result.stderr || '');
+      const tokenMatch = output.match(/sk-ant-oat[^\s]+/);
+
+      if (tokenMatch && ghReady) {
+        const secretSpinner = ora({ text: 'Adding CLAUDE_CODE_OAUTH_TOKEN to GitHub secrets...', color: 'cyan' }).start();
+        execSync(
+          `gh secret set CLAUDE_CODE_OAUTH_TOKEN --body "${tokenMatch[0]}" --repo ${repoInfo.owner}/${repoInfo.repo}`,
+          { stdio: 'pipe' }
+        );
+        secretSpinner.succeed(chalk.green('CLAUDE_CODE_OAUTH_TOKEN added to GitHub secrets'));
+      } else if (tokenMatch && !ghReady) {
+        log.warn('Token generated but gh CLI not available — add it manually:');
+        console.log(chalk.gray('       Name:  ') + chalk.cyan('CLAUDE_CODE_OAUTH_TOKEN'));
+        console.log(chalk.gray('       Value: ') + chalk.cyan(tokenMatch[0]));
+        console.log(chalk.cyan(`       https://github.com/${repoInfo.owner}/${repoInfo.repo}/settings/secrets/actions`));
+      } else {
+        throw new Error('Token not found in output');
+      }
+    } catch (err) {
+      const isNotFound = (err.message || '').includes('ENOENT');
+      if (isNotFound) {
+        log.warn('Claude Code CLI not found — install it first:');
+        console.log(chalk.cyan('\n    npm install -g @anthropic-ai/claude-code'));
+      } else {
+        log.warn('Could not set token automatically.');
+      }
+      console.log(chalk.gray('\n  Add it manually:'));
+      console.log(chalk.gray('    1. Run:        ') + chalk.cyan('claude setup-token'));
+      console.log(chalk.gray('    2. Go to:      ') + chalk.cyan(`https://github.com/${repoInfo.owner}/${repoInfo.repo}/settings/secrets/actions`));
+      console.log(chalk.gray('    3. Add secret: ') + chalk.cyan('CLAUDE_CODE_OAUTH_TOKEN') + chalk.gray(' = the token you copied\n'));
     }
-    console.log(chalk.gray('\n  Add it manually:'));
-    console.log(chalk.gray('    1. Run:       ') + chalk.cyan('claude setup-token'));
-    console.log(chalk.gray('    2. Go to:     ') + chalk.cyan(`https://github.com/${repoInfo.owner}/${repoInfo.repo}/settings/secrets/actions`));
-    console.log(chalk.gray('    3. Add secret:') + chalk.cyan(' CLAUDE_CODE_OAUTH_TOKEN') + chalk.gray(' = the token you copied\n'));
   }
 
   log.divider();
 
-  // ─── Step 9: Commit and push ──────────────────────────────────────────────
-  const autoPush = await confirm('Commit and push the generated files now?', true);
-
-  if (autoPush) {
-    const pushSpinner = ora({ text: 'Committing and pushing...', color: 'cyan' }).start();
-    try {
-      const files = ['.github/workflows/lazykit.yml', ...(wantClaudeMd ? ['CLAUDE.md'] : [])].join(' ');
-      execSync(`git add ${files}`, { stdio: 'pipe' });
-      execSync(`git commit -m "Add LazyKit automation"`, { stdio: 'pipe' });
-      execSync(`git push`, { stdio: 'pipe' });
-      pushSpinner.succeed(chalk.green('Committed and pushed — workflow is live'));
-    } catch (err) {
-      pushSpinner.fail(chalk.red('Push failed.'));
-      console.log(chalk.gray('\n  Push it manually:\n'));
-      console.log(chalk.cyan('    git add .github/workflows/lazykit.yml' + (wantClaudeMd ? ' CLAUDE.md' : '')));
+  // ─── Step 11: Commit and push ──────────────────────────────────────────────
+  if (dryRun) {
+    log.info('[dry-run] Would commit and push generated files');
+    log.blank();
+  } else {
+    const autoPush = await confirm('Commit and push the generated files now?', true);
+
+    if (autoPush) {
+      const pushSpinner = ora({ text: 'Committing and pushing...', color: 'cyan' }).start();
+      try {
+        const files = [
+          '.github/workflows/lazykit.yml',
+          '.github/ISSUE_TEMPLATE/lazykit.md',
+          ...(wantClaudeMd ? ['CLAUDE.md'] : []),
+        ].join(' ');
+        execSync(`git add ${files}`, { stdio: 'pipe' });
+        execSync(`git commit -m "Add LazyKit automation"`, { stdio: 'pipe' });
+        execSync(`git push`, { stdio: 'pipe' });
+        pushSpinner.succeed(chalk.green('Committed and pushed — workflow is live'));
+      } catch {
+        pushSpinner.fail(chalk.red('Push failed.'));
+        console.log(chalk.gray('\n  Push it manually:\n'));
+        console.log(chalk.cyan(`    git add .github/workflows/lazykit.yml .github/ISSUE_TEMPLATE/lazykit.md${wantClaudeMd ? ' CLAUDE.md' : ''}`));
+        console.log(chalk.cyan('    git commit -m "Add LazyKit automation"'));
+        console.log(chalk.cyan('    git push\n'));
+      }
+    } else {
+      console.log(chalk.bold('\n  Push the files yourself when ready:\n'));
+      console.log(chalk.cyan(`    git add .github/workflows/lazykit.yml .github/ISSUE_TEMPLATE/lazykit.md${wantClaudeMd ? ' CLAUDE.md' : ''}`));
       console.log(chalk.cyan('    git commit -m "Add LazyKit automation"'));
-      console.log(chalk.cyan('    git push\n'));
+      console.log(chalk.cyan('    git push'));
     }
-  } else {
-    console.log(chalk.bold('\n  Push the files yourself when ready:\n'));
-    console.log(chalk.cyan('    git add .github/workflows/lazykit.yml' + (wantClaudeMd ? ' CLAUDE.md' : '')));
-    console.log(chalk.cyan('    git commit -m "Add LazyKit automation"'));
-    console.log(chalk.cyan('    git push'));
   }
 
   log.divider();
 
   console.log(chalk.bold('\n  Done! Here is how to use it:\n'));
-  console.log(`  ${chalk.gray('1.')} Open a GitHub issue describing what you want`);
-  console.log(`  ${chalk.gray('2.')} Apply the ${chalk.bold.magenta(label)} label`);
-  console.log(`  ${chalk.gray('3.')} Watch Claude open a PR with the changes\n`);
+  console.log(`  ${chalk.gray('1.')} Open a GitHub issue using the ${chalk.bold.magenta('LazyKit Task')} template`);
+  if (autoTrigger) {
+    console.log(`  ${chalk.gray('2.')} Claude starts working on it automatically`);
+  } else {
+    console.log(`  ${chalk.gray('2.')} Apply the ${chalk.bold.magenta(label)} label to trigger Claude`);
+  }
+  console.log(`  ${chalk.gray('3.')} Review and merge the pull request`);
+  console.log(`\n  ${chalk.gray('Tip:')} Mention ${chalk.bold.cyan('@claude')} in any issue comment to give follow-up instructions.\n`);
 
   console.log(chalk.bold.white('  🦥  LazyKit is ready. Go be lazy.\n'));
 }

package/issue-template.js

@@ -0,0 +1,24 @@
+'use strict';
+
+function generateIssueTemplate({ label }) {
+  return `---
+name: LazyKit Task
+about: Describe a task for Claude to implement
+labels: ${label}
+---
+
+## What to build
+
+<!-- Describe clearly and specifically what you want Claude to implement. Keep it small and focused. -->
+
+## Acceptance criteria
+
+<!-- Optional: what does "done" look like? -->
+
+## Notes
+
+<!-- Files to touch, things to avoid, constraints, or extra context for Claude. -->
+`;
+}
+
+module.exports = { generateIssueTemplate };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@slahon/lazykit",
-  "version": "1.1.1",
+  "version": "1.2.1",
   "description": "Drop an issue, get a PR. AI-powered issue-to-PR automation using Claude.",
   "bin": {
     "lazykit": "./index.js"

package/remove.js

@@ -0,0 +1,104 @@
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+const { execSync } = require('child_process');
+const chalk = require('chalk');
+const ora = require('ora');
+
+const { log } = require('./logger');
+const { confirm } = require('./prompt');
+const { isGitRepo, getGitRemote, parseGitHubRepo, isGhCliAvailable, isGhAuthenticated } = require('./git');
+
+async function remove() {
+  console.log(chalk.bold.white('\n🦥  LazyKit Remove\n'));
+
+  if (!isGitRepo()) {
+    log.error('Not inside a git repository.');
+    process.exit(1);
+  }
+
+  const repoInfo = parseGitHubRepo(getGitRemote());
+  if (!repoInfo) {
+    log.error('No GitHub remote detected.');
+    process.exit(1);
+  }
+
+  const confirmed = await confirm('This will remove LazyKit from your repo. Continue?', false);
+  if (!confirmed) {
+    console.log(chalk.gray('\n  Aborted.\n'));
+    process.exit(0);
+  }
+
+  const ghReady = isGhCliAvailable() && isGhAuthenticated();
+  const deleted = [];
+
+  // Read label name before deleting workflow
+  let labelName = 'lazykit';
+  const workflowPath = path.join(process.cwd(), '.github', 'workflows', 'lazykit.yml');
+  if (fs.existsSync(workflowPath)) {
+    const wf = fs.readFileSync(workflowPath, 'utf8');
+    const m = wf.match(/label_trigger:\s*(\S+)/);
+    if (m) labelName = m[1];
+    fs.unlinkSync(workflowPath);
+    deleted.push('.github/workflows/lazykit.yml');
+    log.success('Removed .github/workflows/lazykit.yml');
+  }
+
+  const templatePath = path.join(process.cwd(), '.github', 'ISSUE_TEMPLATE', 'lazykit.md');
+  if (fs.existsSync(templatePath)) {
+    fs.unlinkSync(templatePath);
+    deleted.push('.github/ISSUE_TEMPLATE/lazykit.md');
+    log.success('Removed .github/ISSUE_TEMPLATE/lazykit.md');
+  }
+
+  const claudeMdPath = path.join(process.cwd(), 'CLAUDE.md');
+  if (fs.existsSync(claudeMdPath)) {
+    const removeClaude = await confirm('Remove CLAUDE.md too?', false);
+    if (removeClaude) {
+      fs.unlinkSync(claudeMdPath);
+      deleted.push('CLAUDE.md');
+      log.success('Removed CLAUDE.md');
+    }
+  }
+
+  if (ghReady) {
+    const labelSpinner = ora({ text: `Deleting '${labelName}' label from GitHub...`, color: 'cyan' }).start();
+    try {
+      execSync(`gh label delete "${labelName}" --repo ${repoInfo.owner}/${repoInfo.repo} --yes`, { stdio: 'pipe' });
+      labelSpinner.succeed(chalk.green(`Deleted '${labelName}' label from GitHub`));
+    } catch {
+      labelSpinner.warn(`Could not delete label — remove manually at ${chalk.cyan(`https://github.com/${repoInfo.owner}/${repoInfo.repo}/labels`)}`);
+    }
+
+    const secretSpinner = ora({ text: 'Removing CLAUDE_CODE_OAUTH_TOKEN secret...', color: 'cyan' }).start();
+    try {
+      execSync(`gh secret delete CLAUDE_CODE_OAUTH_TOKEN --repo ${repoInfo.owner}/${repoInfo.repo}`, { stdio: 'pipe' });
+      secretSpinner.succeed(chalk.green('Removed CLAUDE_CODE_OAUTH_TOKEN secret'));
+    } catch {
+      secretSpinner.warn(`Could not remove secret — delete manually in repo Settings → Secrets`);
+    }
+  } else {
+    log.warn(`Remove the '${labelName}' label manually: ${chalk.cyan(`https://github.com/${repoInfo.owner}/${repoInfo.repo}/labels`)}`);
+    log.warn(`Remove the CLAUDE_CODE_OAUTH_TOKEN secret manually: ${chalk.cyan(`https://github.com/${repoInfo.owner}/${repoInfo.repo}/settings/secrets/actions`)}`);
+  }
+
+  if (deleted.length > 0) {
+    const autoPush = await confirm('Commit and push the removals?', true);
+    if (autoPush) {
+      const spinner = ora({ text: 'Committing and pushing...', color: 'cyan' }).start();
+      try {
+        execSync(`git add ${deleted.map(f => `"${f}"`).join(' ')}`, { stdio: 'pipe' });
+        execSync(`git commit -m "Remove LazyKit automation"`, { stdio: 'pipe' });
+        execSync(`git push`, { stdio: 'pipe' });
+        spinner.succeed(chalk.green('Committed and pushed'));
+      } catch {
+        spinner.fail('Push failed — commit and push manually');
+      }
+    }
+  }
+
+  console.log(chalk.bold.white('\n  LazyKit has been removed.\n'));
+}
+
+module.exports = { remove };

package/status.js

@@ -0,0 +1,113 @@
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+const { execSync } = require('child_process');
+const chalk = require('chalk');
+
+const { log } = require('./logger');
+const { isGitRepo, getGitRemote, parseGitHubRepo, isGhCliAvailable, isGhAuthenticated } = require('./git');
+
+async function status() {
+  console.log(chalk.bold.white('\n🦥  LazyKit Status\n'));
+
+  if (!isGitRepo()) {
+    log.error('Not inside a git repository.');
+    return;
+  }
+
+  const repoInfo = parseGitHubRepo(getGitRemote());
+  if (!repoInfo) {
+    log.error('No GitHub remote detected.');
+    return;
+  }
+
+  log.info(`Repo: ${chalk.cyan(`${repoInfo.owner}/${repoInfo.repo}`)}`);
+  log.blank();
+
+  // Local files
+  const workflowPath = path.join(process.cwd(), '.github', 'workflows', 'lazykit.yml');
+  const claudeMdPath = path.join(process.cwd(), 'CLAUDE.md');
+  const templatePath = path.join(process.cwd(), '.github', 'ISSUE_TEMPLATE', 'lazykit.md');
+
+  fs.existsSync(workflowPath)
+    ? log.success('Workflow file found')
+    : log.error('Workflow file missing — run npx @slahon/lazykit@latest init');
+
+  fs.existsSync(templatePath)
+    ? log.success('Issue template found')
+    : log.warn('Issue template missing — run npx @slahon/lazykit@latest init');
+
+  fs.existsSync(claudeMdPath)
+    ? log.success('CLAUDE.md found')
+    : log.warn('CLAUDE.md not found — Claude has no project context');
+
+  // Remote checks require gh
+  const ghReady = isGhCliAvailable() && isGhAuthenticated();
+  if (!ghReady) {
+    log.blank();
+    log.warn('gh CLI not available or not authenticated — skipping remote checks');
+    log.warn('Run: ' + chalk.cyan('gh auth login'));
+    console.log();
+    return;
+  }
+
+  log.blank();
+
+  // Secret
+  try {
+    const secrets = execSync(`gh secret list --repo ${repoInfo.owner}/${repoInfo.repo}`, { stdio: 'pipe' }).toString();
+    const match = secrets.match(/CLAUDE_CODE_OAUTH_TOKEN\s+(\S+)/);
+    if (match) {
+      const updated = new Date(match[1]);
+      const monthsOld = (Date.now() - updated.getTime()) / (1000 * 60 * 60 * 24 * 30);
+      log.success(`CLAUDE_CODE_OAUTH_TOKEN secret exists ${chalk.gray(`(updated ${match[1]})`)}`);
+      if (monthsOld > 6) log.warn('Token is over 6 months old — consider refreshing it with npx @slahon/lazykit@latest init');
+    } else {
+      log.error('CLAUDE_CODE_OAUTH_TOKEN secret not found — run npx @slahon/lazykit@latest init');
+    }
+  } catch {
+    log.warn('Could not check secrets — insufficient permissions');
+  }
+
+  // Label
+  try {
+    let labelName = 'lazykit';
+    if (fs.existsSync(workflowPath)) {
+      const wf = fs.readFileSync(workflowPath, 'utf8');
+      const m = wf.match(/label_trigger:\s*(\S+)/);
+      if (m) labelName = m[1];
+    }
+    const labels = execSync(`gh label list --repo ${repoInfo.owner}/${repoInfo.repo}`, { stdio: 'pipe' }).toString();
+    labels.includes(labelName)
+      ? log.success(`Label '${labelName}' exists on GitHub`)
+      : log.error(`Label '${labelName}' not found — run npx @slahon/lazykit@latest init`);
+  } catch {
+    log.warn('Could not check labels');
+  }
+
+  // PR creation permission
+  try {
+    const perms = JSON.parse(execSync(
+      `gh api repos/${repoInfo.owner}/${repoInfo.repo}/actions/permissions/workflow`,
+      { stdio: 'pipe' }
+    ).toString());
+    perms.can_approve_pull_request_reviews
+      ? log.success('Actions can create and approve pull requests')
+      : log.warn(`PR creation not enabled — ${chalk.cyan(`https://github.com/${repoInfo.owner}/${repoInfo.repo}/settings/actions`)}`);
+  } catch {
+    log.warn('Could not check Actions permissions');
+  }
+
+  // Branch protection
+  try {
+    execSync(`gh api repos/${repoInfo.owner}/${repoInfo.repo}/branches/main/protection`, { stdio: 'pipe' });
+    log.warn("Branch protection is on — Claude's PRs require manual review before merge");
+  } catch {
+    log.success("No branch protection on main — Claude's PRs can be merged directly");
+  }
+
+  console.log();
+}
+
+module.exports = { status };

package/update.js

@@ -0,0 +1,89 @@
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+const { execSync } = require('child_process');
+const chalk = require('chalk');
+const ora = require('ora');
+
+const { log } = require('./logger');
+const { confirm } = require('./prompt');
+const { isGitRepo, getGitRemote, parseGitHubRepo, detectStack } = require('./git');
+const { generateWorkflow } = require('./workflow');
+const { generateClaudeMd } = require('./claude-md');
+
+async function update({ dryRun = false } = {}) {
+  if (dryRun) console.log(chalk.yellow('\n  [dry-run] Preview mode — no files will be written.\n'));
+  console.log(chalk.bold.white('\n🦥  LazyKit Update\n'));
+
+  if (!isGitRepo()) {
+    log.error('Not inside a git repository.');
+    process.exit(1);
+  }
+
+  const repoInfo = parseGitHubRepo(getGitRemote());
+  if (!repoInfo) {
+    log.error('No GitHub remote detected.');
+    process.exit(1);
+  }
+
+  const workflowPath = path.join(process.cwd(), '.github', 'workflows', 'lazykit.yml');
+  const claudeMdPath = path.join(process.cwd(), 'CLAUDE.md');
+
+  // Read existing config from workflow file
+  let label = 'lazykit';
+  let autoTrigger = true;
+  if (fs.existsSync(workflowPath)) {
+    const wf = fs.readFileSync(workflowPath, 'utf8');
+    const m = wf.match(/label_trigger:\s*(\S+)/);
+    if (m) label = m[1];
+    autoTrigger = wf.includes("github.event.action == 'opened'");
+  }
+
+  const stack = detectStack();
+  const filesToPush = [];
+
+  // Regenerate workflow
+  if (dryRun) {
+    log.info('[dry-run] Would update: .github/workflows/lazykit.yml');
+  } else {
+    const spinner = ora({ text: 'Updating workflow file...', color: 'cyan' }).start();
+    fs.mkdirSync(path.dirname(workflowPath), { recursive: true });
+    fs.writeFileSync(workflowPath, generateWorkflow({ label, autoTrigger }));
+    spinner.succeed(chalk.green('Updated .github/workflows/lazykit.yml'));
+    filesToPush.push('.github/workflows/lazykit.yml');
+  }
+
+  // Regenerate CLAUDE.md if it exists
+  if (fs.existsSync(claudeMdPath)) {
+    const regen = await confirm('Regenerate CLAUDE.md?', true);
+    if (regen) {
+      if (dryRun) {
+        log.info('[dry-run] Would update: CLAUDE.md');
+      } else {
+        fs.writeFileSync(claudeMdPath, generateClaudeMd({ stack }));
+        log.success('Updated CLAUDE.md');
+        filesToPush.push('CLAUDE.md');
+      }
+    }
+  }
+
+  if (!dryRun && filesToPush.length > 0) {
+    const autoPush = await confirm('Commit and push?', true);
+    if (autoPush) {
+      const spinner = ora({ text: 'Committing and pushing...', color: 'cyan' }).start();
+      try {
+        execSync(`git add ${filesToPush.join(' ')}`, { stdio: 'pipe' });
+        execSync(`git commit -m "Update LazyKit configuration"`, { stdio: 'pipe' });
+        execSync(`git push`, { stdio: 'pipe' });
+        spinner.succeed(chalk.green('Committed and pushed'));
+      } catch {
+        spinner.fail('Push failed — commit and push manually');
+      }
+    }
+  }
+
+  console.log();
+}
+
+module.exports = { update };