@fermindi/pwn-cli 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Diego Fernandes
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,251 @@
+# PWN - Professional AI Workspace
+
+**Inject structured memory and automation into any project for AI-powered development.**
+
+PWN gives AI agents like Claude Code persistent memory, auto-applied patterns, and batch execution capabilities.
+
+## Quick Start
+
+```bash
+# Install globally
+npm install -g pwn-cli
+
+# Inject into your project
+cd your-project
+pwn inject
+
+# Check status
+pwn status
+
+# Add Codespaces support (optional)
+pwn codespaces init
+```
+
+## What PWN Does
+
+| Without PWN | With PWN |
+|-------------|----------|
+| AI forgets decisions between sessions | Decisions persist in `.ai/memory/` |
+| Repeats failed approaches | Dead-ends documented and avoided |
+| No project-specific patterns | Auto-applies patterns by context |
+| Manual task tracking | Structured task management |
+| No learning consolidation | Knowledge promotes to patterns |
+
+## Commands
+
+```bash
+# Core
+pwn inject              # Inject .ai/ workspace
+pwn status              # Show workspace status
+pwn validate            # Validate structure
+
+# Notifications
+pwn notify test         # Test notification channels
+pwn notify send "msg"   # Send notification
+
+# Batch Execution
+pwn batch               # Execute next task
+pwn batch --count 5     # Execute 5 tasks
+pwn batch status        # Show progress
+
+# Patterns
+pwn patterns list       # List all patterns
+pwn patterns eval file  # Check triggers for file
+pwn patterns search q   # Search patterns
+
+# Knowledge Lifecycle
+pwn knowledge status    # Show knowledge stats
+pwn knowledge sync      # Sync with markdown
+pwn knowledge gc        # Garbage collection
+pwn knowledge promote   # Promote to pattern
+
+# Codespaces
+pwn codespaces init     # Add devcontainer
+pwn codespaces status   # Check config
+pwn codespaces open     # Open in Codespace
+```
+
+## Project Structure After Injection
+
+```
+your-project/
+├── .ai/
+│   ├── state.json           # Session state (git-ignored)
+│   ├── memory/
+│   │   ├── decisions.md     # Architectural decisions (DEC-XXX)
+│   │   ├── patterns.md      # Learned patterns
+│   │   └── deadends.md      # Failed approaches (DE-XXX)
+│   ├── tasks/
+│   │   ├── active.md        # Current work
+│   │   └── backlog.md       # Future work
+│   ├── patterns/
+│   │   ├── index.md         # Trigger mappings
+│   │   ├── frontend/        # React, Vue, etc.
+│   │   ├── backend/         # Express, FastAPI, etc.
+│   │   └── universal/       # Testing, TypeScript, etc.
+│   ├── workflows/
+│   │   └── batch-task.md    # Batch execution guide
+│   ├── agents/
+│   │   └── claude.md        # Claude Code bootstrap (600+ lines)
+│   └── config/              # Local config (git-ignored)
+└── ... your project files
+```
+
+## Features
+
+### Memory System
+
+Document decisions that AI agents will remember:
+
+```markdown
+## DEC-001: Use TypeScript Strict Mode
+**Date:** 2026-01-22
+**Status:** Active
+**Context:** Need better type safety
+**Decision:** Enable strict mode in tsconfig
+**Rationale:** Catches bugs at compile time
+```
+
+### Pattern Auto-Apply
+
+Triggers automatically load relevant patterns:
+
+```
+*.tsx           → frontend/react/
+*.test.ts       → universal/testing/
+routes/*.ts     → backend/express/
+prisma/schema   → backend/prisma/
+```
+
+### Knowledge Lifecycle
+
+Knowledge evolves based on usage:
+
+```
+CREATE → REFERENCE → EVOLVE → PROMOTE/GC
+   │         │          │         │
+   ▼         ▼          ▼         ▼
+decisions  tracking   patterns  cleanup
+```
+
+- **Promote:** Applied 3+ times in 2+ contexts → becomes pattern
+- **Archive:** No references for 30+ days
+- **GC:** Orphaned with no related code
+
+### Batch Execution
+
+Execute tasks autonomously:
+
+```bash
+pwn batch --count 5 --priority high
+```
+
+Features:
+- Quality gates (lint, test, typecheck)
+- Checkpoint-based pause/resume
+- Auto-commit after each task
+- Notifications on completion
+
+### Codespaces Integration
+
+Work from anywhere (including mobile):
+
+```bash
+pwn codespaces init
+git push
+# Open in GitHub Codespaces
+```
+
+Pre-configured with:
+- Node.js 22
+- VSCode extensions (ESLint, Prettier, GitLens, Copilot, Claude)
+- Bash aliases (`p`, `ps`, `pb`, `pk`)
+- Auto PWN setup
+
+## Usage with Claude Code
+
+After `pwn inject`, Claude Code will:
+
+1. Read `.ai/agents/claude.md` for bootstrap protocol
+2. Load memory (decisions, patterns, dead-ends)
+3. Check active tasks
+4. Auto-apply patterns based on context
+5. Reference decisions in responses
+
+## Installation
+
+```bash
+# npm
+npm install -g pwn-cli
+
+# Or run directly
+npx pwn-cli inject
+```
+
+Requirements:
+- Node.js 18+
+- Git (for username detection)
+
+## Configuration
+
+### Notifications
+
+Edit `.ai/config/notifications.json`:
+
+```json
+{
+  "channels": {
+    "ntfy": {
+      "enabled": true,
+      "topic": "pwn-abc123"
+    }
+  }
+}
+```
+
+### Quality Gates
+
+Configure in `.ai/workflows/batch-task.md`:
+
+```yaml
+gates:
+  typecheck: true
+  lint: true
+  test: true
+  build: false
+```
+
+## Development
+
+```bash
+git clone https://github.com/diegofornalha/pwn.git
+cd pwn
+pnpm install
+pnpm test
+npm link  # For local testing
+```
+
+## Roadmap
+
+- [x] Phase 0: Core workspace injection
+- [x] Phase 1: Multi-channel notifications
+- [x] Phase 2: GitHub Codespaces integration
+- [x] Phase 3: Autonomous batch execution
+- [x] Phase 4: Advanced pattern system
+- [x] Phase 5: Knowledge lifecycle
+- [x] Phase 6: npm publish
+- [ ] `pwn create` - Scaffold new projects
+- [ ] `pwn upgrade` - Update existing workspaces
+- [ ] Docker support
+
+## Contributing
+
+Contributions welcome! See [CONTRIBUTING.md](CONTRIBUTING.md).
+
+## License
+
+MIT - see [LICENSE](LICENSE)
+
+---
+
+**Version:** 0.1.0 | **Status:** Production Ready

package/cli/batch.js

@@ -0,0 +1,333 @@
+#!/usr/bin/env node
+import * as batch from '../src/services/batch-service.js';
+import { hasWorkspace } from '../src/core/state.js';
+
+export default async function batchCommand(args = []) {
+  // Check for help first (doesn't require workspace)
+  if (args.includes('--help') || args.includes('-h')) {
+    showHelp();
+    return;
+  }
+
+  // Check for workspace
+  if (!hasWorkspace()) {
+    console.log('❌ No PWN workspace found\n');
+    console.log('   Run: pwn inject');
+    process.exit(1);
+  }
+
+  const subcommand = args[0];
+
+  // Handle subcommands
+  if (subcommand === 'status' || args.includes('--status')) {
+    return showStatus();
+  }
+
+  if (subcommand === 'config' || args.includes('--config')) {
+    return showConfig();
+  }
+
+  // Parse options
+  const options = parseOptions(args);
+
+  // Handle actions
+  if (options.resume) {
+    return resumeBatch(options);
+  }
+
+  if (options.dryRun) {
+    return dryRun(options);
+  }
+
+  // Default: start batch
+  return startBatch(options);
+}
+
+/**
+ * Parse command line options
+ */
+function parseOptions(args) {
+  const options = {};
+
+  for (let i = 0; i < args.length; i++) {
+    const arg = args[i];
+
+    if (arg === '--count' || arg === '-n') {
+      options.count = parseInt(args[++i], 10);
+    } else if (arg === '--dry-run' || arg === '-d') {
+      options.dryRun = true;
+    } else if (arg === '--priority' || arg === '-p') {
+      options.priority = args[++i]?.toLowerCase();
+    } else if (arg === '--resume' || arg === '-r') {
+      options.resume = true;
+    } else if (arg === '--skip') {
+      options.skip = true;
+    } else if (arg === '--force' || arg === '-f') {
+      options.skipGates = true;
+    } else if (arg === '--continue') {
+      options.continueOnError = true;
+    } else if (arg === '--no-commit') {
+      options.skipCommit = true;
+    } else if (arg === '--no-branch') {
+      options.skipBranch = true;
+    } else if (arg === '--help' || arg === '-h') {
+      showHelp();
+      process.exit(0);
+    }
+  }
+
+  return options;
+}
+
+/**
+ * Show batch status
+ */
+function showStatus() {
+  const status = batch.getStatus();
+
+  if (!status.hasWorkspace) {
+    console.log('❌ No PWN workspace found');
+    process.exit(1);
+  }
+
+  console.log('📋 Batch Status\n');
+
+  // Running state
+  if (status.isRunning) {
+    console.log(`   Status: 🔄 Running`);
+    console.log(`   Current Task: ${status.currentTask || '(selecting)'}`);
+  } else if (status.isPaused) {
+    console.log(`   Status: ⏸️  Paused`);
+    console.log(`   Current Task: ${status.currentTask}`);
+    console.log(`   Reason: ${status.pauseReason}`);
+    console.log('\n   Resume with: pwn batch --resume');
+    console.log('   Skip task:   pwn batch --resume --skip');
+  } else {
+    console.log('   Status: ⏹️  Idle');
+  }
+
+  // Task counts
+  console.log('\n📝 Tasks\n');
+  console.log(`   Active: ${status.tasks.activePending} pending, ${status.tasks.activeCompleted} completed`);
+  console.log(`   Backlog: ${status.tasks.backlogTotal} total`);
+  if (status.tasks.backlogTotal > 0) {
+    console.log(`     - High: ${status.tasks.backlogHigh}`);
+    console.log(`     - Medium: ${status.tasks.backlogMedium}`);
+    console.log(`     - Low: ${status.tasks.backlogLow}`);
+  }
+
+  // Batch history
+  if (status.batchState?.completed?.length > 0) {
+    console.log('\n✅ Completed this batch\n');
+    for (const taskId of status.batchState.completed) {
+      console.log(`   - ${taskId}`);
+    }
+  }
+
+  // Next task preview
+  const nextTask = batch.selectNextTask();
+  if (nextTask) {
+    console.log('\n🎯 Next Task\n');
+    console.log(`   ${nextTask.id}: ${nextTask.title}`);
+    if (nextTask.priority) {
+      console.log(`   Priority: ${nextTask.priority}`);
+    }
+  } else {
+    console.log('\n   No tasks available in backlog');
+  }
+}
+
+/**
+ * Show batch configuration
+ */
+function showConfig() {
+  const config = batch.loadConfig();
+
+  console.log('⚙️  Batch Configuration\n');
+  console.log(`   Max Tasks: ${config.max_tasks}`);
+  console.log(`   Max Duration: ${config.max_duration_hours} hours`);
+  console.log(`   Selection: ${config.selection_strategy}`);
+  console.log(`\n   Quality Gates: ${config.quality_gates.join(', ') || '(none)'}`);
+  if (config.skip_gates.length > 0) {
+    console.log(`   Skip Gates: ${config.skip_gates.join(', ')}`);
+  }
+  console.log(`\n   Auto Commit: ${config.auto_commit ? 'Yes' : 'No'}`);
+  console.log(`   Auto Push: ${config.auto_push ? 'Yes' : 'No'}`);
+  console.log(`   Create PR: ${config.create_pr ? 'Yes' : 'No'}`);
+  console.log(`   Branch Format: ${config.branch_format}`);
+  console.log(`   Commit Format: ${config.commit_format}`);
+  console.log(`\n   Notify Complete: ${config.notify_on_complete ? 'Yes' : 'No'}`);
+  console.log(`   Notify Error: ${config.notify_on_error ? 'Yes' : 'No'}`);
+  console.log('\n📁 Config location: .ai/state.json (batch_config)');
+}
+
+/**
+ * Dry run - show what would execute
+ */
+async function dryRun(options) {
+  console.log('🔍 Dry Run - Preview batch execution\n');
+
+  const config = batch.loadConfig();
+  const count = options.count || config.max_tasks;
+
+  console.log(`   Would execute up to ${count} tasks\n`);
+
+  // Show tasks that would be selected
+  const tasks = [];
+  for (let i = 0; i < count; i++) {
+    // Note: This is a simplified preview - actual selection happens one at a time
+    const task = batch.selectNextTask(process.cwd(), { priority: options.priority });
+    if (!task) break;
+
+    // Skip already seen tasks for preview
+    if (tasks.find(t => t.id === task.id)) break;
+    tasks.push(task);
+  }
+
+  if (tasks.length === 0) {
+    console.log('   No tasks available in backlog');
+    return;
+  }
+
+  console.log('   Tasks to execute:\n');
+  for (let i = 0; i < tasks.length; i++) {
+    const task = tasks[i];
+    const priority = task.priority ? ` (${task.priority})` : '';
+    console.log(`   ${i + 1}. ${task.id}: ${task.title}${priority}`);
+  }
+
+  console.log('\n   Quality gates that would run:');
+  for (const gate of config.quality_gates) {
+    if (config.skip_gates.includes(gate)) {
+      console.log(`     ⏭️  ${gate} (skipped)`);
+    } else {
+      console.log(`     ✓ ${gate}`);
+    }
+  }
+
+  if (options.skipGates) {
+    console.log('\n   ⚠️  Gates would be skipped due to --force flag');
+  }
+
+  console.log('\n   Run without --dry-run to execute');
+}
+
+/**
+ * Start batch execution
+ */
+async function startBatch(options) {
+  const config = batch.loadConfig();
+  const count = options.count || config.max_tasks;
+
+  console.log('🚀 Starting batch execution\n');
+  console.log(`   Max tasks: ${count}`);
+  console.log(`   Quality gates: ${options.skipGates ? 'Skipped' : config.quality_gates.join(', ')}`);
+  console.log('');
+
+  const startTime = Date.now();
+
+  const result = await batch.startBatch({
+    count,
+    priority: options.priority,
+    skipGates: options.skipGates,
+    skipCommit: options.skipCommit,
+    skipBranch: options.skipBranch,
+    continueOnError: options.continueOnError
+  });
+
+  const duration = Math.round((Date.now() - startTime) / 1000);
+
+  console.log('');
+
+  if (result.completed.length > 0) {
+    console.log('✅ Completed tasks:\n');
+    for (const task of result.completed) {
+      console.log(`   - ${task.id}: ${task.title}`);
+    }
+  }
+
+  if (result.errors.length > 0) {
+    console.log('\n❌ Failed tasks:\n');
+    for (const error of result.errors) {
+      console.log(`   - ${error.id}: ${error.error}`);
+    }
+  }
+
+  console.log(`\n⏱️  Duration: ${duration}s`);
+  console.log(`📊 Summary: ${result.completed.length} completed, ${result.errors.length} failed`);
+
+  if (!result.success) {
+    console.log('\n💡 To resume: pwn batch --resume');
+    console.log('   To skip:   pwn batch --resume --skip');
+    process.exit(1);
+  }
+}
+
+/**
+ * Resume paused batch
+ */
+async function resumeBatch(options) {
+  const status = batch.getStatus();
+
+  if (!status.isPaused) {
+    console.log('❌ No paused batch to resume\n');
+    console.log('   Current status:', status.isRunning ? 'Running' : 'Idle');
+    process.exit(1);
+  }
+
+  console.log('▶️  Resuming batch execution\n');
+
+  if (options.skip) {
+    console.log(`   Skipping task: ${status.currentTask}`);
+  }
+
+  console.log('');
+
+  const result = await batch.resumeBatch({
+    skip: options.skip,
+    skipGates: options.skipGates
+  });
+
+  if (!result.success) {
+    console.log(`❌ ${result.message}`);
+    process.exit(1);
+  }
+
+  console.log(`\n✅ Batch resumed`);
+  console.log(`   Completed: ${result.completed?.length || 0} tasks`);
+}
+
+/**
+ * Show help
+ */
+function showHelp() {
+  console.log('🚀 PWN Batch Execution\n');
+  console.log('Usage: pwn batch [command] [options]\n');
+  console.log('Commands:');
+  console.log('  (default)              Execute next available task(s)');
+  console.log('  status                 Show batch status');
+  console.log('  config                 Show batch configuration\n');
+  console.log('Options:');
+  console.log('  --count, -n <num>      Execute specific number of tasks');
+  console.log('  --dry-run, -d          Preview what would execute');
+  console.log('  --priority, -p <level> Filter by priority (high, medium, low)');
+  console.log('  --resume, -r           Resume interrupted batch');
+  console.log('  --skip                 Skip current task when resuming');
+  console.log('  --force, -f            Skip quality gates');
+  console.log('  --continue             Continue on errors');
+  console.log('  --no-commit            Skip auto-commit');
+  console.log('  --no-branch            Skip branch creation');
+  console.log('  --help, -h             Show this help\n');
+  console.log('Examples:');
+  console.log('  pwn batch                    # Execute next task');
+  console.log('  pwn batch --count 5          # Execute 5 tasks');
+  console.log('  pwn batch --dry-run          # Preview execution');
+  console.log('  pwn batch --priority high    # Only high priority');
+  console.log('  pwn batch --resume           # Resume paused batch');
+  console.log('  pwn batch --resume --skip    # Resume, skip current');
+  console.log('  pwn batch status             # Show status');
+  console.log('  pwn batch config             # Show configuration\n');
+  console.log('Configuration:');
+  console.log('  Edit .ai/state.json and add batch_config object.');
+  console.log('  See .ai/workflows/batch-task.md for full documentation.');
+}