@fermindi/pwn-cli 0.1.0

package/cli/status.js

@@ -0,0 +1,91 @@
+#!/usr/bin/env node
+import { getWorkspaceInfo } from '../src/core/workspace.js';
+import { validate } from '../src/core/validate.js';
+
+export default async function statusCommand() {
+  const info = getWorkspaceInfo();
+
+  if (!info.exists) {
+    console.log('❌ No PWN workspace found\n');
+    console.log('   Run: pwn inject');
+    process.exit(1);
+  }
+
+  // Validate workspace
+  const validation = validate();
+
+  console.log('📊 PWN Workspace Status\n');
+
+  // Developer info
+  if (info.state) {
+    console.log(`👤 Developer: ${info.state.developer}`);
+    console.log(`📅 Session:   ${formatDate(info.state.session_started)}`);
+    if (info.state.current_task) {
+      console.log(`🎯 Task:      ${info.state.current_task}`);
+    }
+    console.log();
+  }
+
+  // Tasks summary
+  console.log('📋 Tasks');
+  console.log(`   Active:    ${info.tasks.active.pending} pending, ${info.tasks.active.completed} completed`);
+  console.log(`   Backlog:   ${info.tasks.backlog.total} items`);
+  console.log();
+
+  // Memory summary
+  console.log('🧠 Memory');
+  console.log(`   Decisions: ${info.memory.decisions}`);
+  console.log(`   Patterns:  ${info.memory.patterns}`);
+  console.log(`   Dead-ends: ${info.memory.deadends}`);
+  console.log();
+
+  // Patterns summary
+  console.log('🎨 Patterns');
+  console.log(`   Triggers:  ${info.patterns.triggers}`);
+  console.log(`   Categories: ${info.patterns.categories.join(', ') || 'none'}`);
+  console.log();
+
+  // Validation status
+  if (validation.valid) {
+    console.log('✅ Workspace structure valid');
+  } else {
+    console.log('⚠️  Workspace has issues:');
+    for (const issue of validation.issues) {
+      console.log(`   - ${issue}`);
+    }
+  }
+
+  if (validation.warnings.length > 0) {
+    console.log('\n⚠️  Warnings:');
+    for (const warning of validation.warnings) {
+      console.log(`   - ${warning}`);
+    }
+  }
+}
+
+/**
+ * Format ISO date to human readable
+ * @param {string} isoDate - ISO date string
+ * @returns {string} Formatted date
+ */
+function formatDate(isoDate) {
+  if (!isoDate) return 'unknown';
+
+  try {
+    const date = new Date(isoDate);
+    const now = new Date();
+    const diffMs = now - date;
+    const diffMins = Math.floor(diffMs / 60000);
+    const diffHours = Math.floor(diffMs / 3600000);
+    const diffDays = Math.floor(diffMs / 86400000);
+
+    if (diffMins < 1) return 'just now';
+    if (diffMins < 60) return `${diffMins}m ago`;
+    if (diffHours < 24) return `${diffHours}h ago`;
+    if (diffDays < 7) return `${diffDays}d ago`;
+
+    return date.toLocaleDateString();
+  } catch {
+    return isoDate;
+  }
+}

package/cli/validate.js

@@ -0,0 +1,61 @@
+#!/usr/bin/env node
+import { validate, getStructureReport } from '../src/core/validate.js';
+
+export default async function validateCommand(args = []) {
+  const verbose = args.includes('--verbose') || args.includes('-v');
+
+  console.log('🔍 Validating PWN workspace...\n');
+
+  const result = validate();
+
+  if (verbose) {
+    const report = getStructureReport();
+    console.log('📁 Structure Report:\n');
+
+    console.log('   Directories:');
+    for (const [dir, exists] of Object.entries(report.directories)) {
+      const icon = exists ? '✓' : '✗';
+      console.log(`     ${icon} .ai/${dir}/`);
+    }
+
+    console.log('\n   Files:');
+    for (const [file, exists] of Object.entries(report.files)) {
+      const icon = exists ? '✓' : '✗';
+      console.log(`     ${icon} .ai/${file}`);
+    }
+    console.log();
+  }
+
+  if (result.valid) {
+    console.log('✅ Workspace is valid\n');
+
+    if (result.warnings.length > 0) {
+      console.log('⚠️  Warnings:');
+      for (const warning of result.warnings) {
+        console.log(`   - ${warning}`);
+      }
+      console.log();
+    }
+
+    process.exit(0);
+  } else {
+    console.log('❌ Workspace has issues:\n');
+
+    for (const issue of result.issues) {
+      console.log(`   ✗ ${issue}`);
+    }
+
+    if (result.warnings.length > 0) {
+      console.log('\n⚠️  Warnings:');
+      for (const warning of result.warnings) {
+        console.log(`   - ${warning}`);
+      }
+    }
+
+    console.log('\n💡 To fix, try:');
+    console.log('   pwn inject --force  (recreate workspace)');
+    console.log();
+
+    process.exit(1);
+  }
+}

package/package.json

@@ -0,0 +1,70 @@
+{
+  "name": "@fermindi/pwn-cli",
+  "version": "0.1.0",
+  "description": "Professional AI Workspace - Inject structured memory and automation into any project for AI-powered development",
+  "type": "module",
+  "bin": {
+    "pwn": "./cli/index.js"
+  },
+  "main": "./src/index.js",
+  "exports": {
+    ".": "./src/index.js",
+    "./core/state": "./src/core/state.js",
+    "./core/inject": "./src/core/inject.js",
+    "./core/validate": "./src/core/validate.js",
+    "./core/workspace": "./src/core/workspace.js",
+    "./services/batch": "./src/services/batch-service.js",
+    "./services/notifications": "./src/services/notification-service.js",
+    "./patterns/registry": "./src/patterns/registry.js",
+    "./patterns/triggers": "./src/patterns/triggers.js",
+    "./knowledge/lifecycle": "./src/knowledge/lifecycle.js",
+    "./knowledge/references": "./src/knowledge/references.js",
+    "./knowledge/gc": "./src/knowledge/gc.js",
+    "./knowledge/promote": "./src/knowledge/promote.js"
+  },
+  "files": [
+    "cli/",
+    "src/",
+    "templates/",
+    "README.md",
+    "LICENSE"
+  ],
+  "scripts": {
+    "start": "node cli/index.js",
+    "dev": "node --watch cli/index.js",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "test:coverage": "vitest run --coverage",
+    "prepublishOnly": "npm test"
+  },
+  "keywords": [
+    "ai",
+    "cli",
+    "workspace",
+    "automation",
+    "claude",
+    "patterns",
+    "memory",
+    "decisions",
+    "batch",
+    "codespaces",
+    "developer-tools",
+    "productivity"
+  ],
+  "author": "Diego Fernandes",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/fermindi/pwn.git"
+  },
+  "bugs": {
+    "url": "https://github.com/fermindi/pwn/issues"
+  },
+  "homepage": "https://github.com/fermindi/pwn#readme",
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "devDependencies": {
+    "vitest": "^2.0.0"
+  }
+}

package/src/core/inject.js

@@ -0,0 +1,128 @@
+import { existsSync, cpSync, renameSync, readFileSync, appendFileSync, writeFileSync } from 'fs';
+import { join, dirname } from 'path';
+import { fileURLToPath } from 'url';
+import { randomUUID } from 'crypto';
+import { initState } from './state.js';
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+
+/**
+ * Get the path to the workspace template
+ * @returns {string} Path to template directory
+ */
+export function getTemplatePath() {
+  return join(__dirname, '../../templates/workspace/.ai');
+}
+
+/**
+ * Inject PWN workspace into a project
+ * @param {object} options - Injection options
+ * @param {string} options.cwd - Target directory (defaults to process.cwd())
+ * @param {boolean} options.force - Force overwrite existing .ai/ directory
+ * @param {boolean} options.silent - Suppress console output
+ * @returns {object} Result with success status and message
+ */
+export async function inject(options = {}) {
+  const {
+    cwd = process.cwd(),
+    force = false,
+    silent = false
+  } = options;
+
+  const templateDir = getTemplatePath();
+  const targetDir = join(cwd, '.ai');
+
+  const log = silent ? () => {} : console.log;
+
+  // Check if .ai/ already exists
+  if (existsSync(targetDir) && !force) {
+    return {
+      success: false,
+      error: 'ALREADY_EXISTS',
+      message: '.ai/ directory already exists. Use --force to overwrite.'
+    };
+  }
+
+  try {
+    // Copy workspace template
+    log('📦 Copying workspace template...');
+    cpSync(templateDir, targetDir, { recursive: true });
+
+    // Rename state.template.json → state.json
+    const templateState = join(targetDir, 'state.template.json');
+    const stateFile = join(targetDir, 'state.json');
+
+    if (existsSync(templateState)) {
+      renameSync(templateState, stateFile);
+    }
+
+    // Rename notifications.template.json → notifications.json and generate unique topic
+    const templateNotify = join(targetDir, 'config', 'notifications.template.json');
+    const notifyFile = join(targetDir, 'config', 'notifications.json');
+
+    if (existsSync(templateNotify)) {
+      renameSync(templateNotify, notifyFile);
+      initNotifications(notifyFile);
+    }
+
+    // Initialize state.json with current user
+    initState(cwd);
+
+    // Update .gitignore
+    updateGitignore(cwd, silent);
+
+    return {
+      success: true,
+      message: 'PWN workspace injected successfully',
+      path: targetDir
+    };
+
+  } catch (error) {
+    return {
+      success: false,
+      error: 'INJECTION_FAILED',
+      message: error.message
+    };
+  }
+}
+
+/**
+ * Initialize notifications.json with unique topic
+ * @param {string} notifyFile - Path to notifications.json
+ */
+function initNotifications(notifyFile) {
+  try {
+    const content = readFileSync(notifyFile, 'utf8');
+    const config = JSON.parse(content);
+
+    // Generate unique topic ID
+    const uniqueId = randomUUID().split('-')[0]; // First segment: 8 chars
+    config.channels.ntfy.topic = `pwn-${uniqueId}`;
+
+    writeFileSync(notifyFile, JSON.stringify(config, null, 2));
+  } catch {
+    // Ignore errors - notifications will use defaults
+  }
+}
+
+/**
+ * Update .gitignore to exclude PWN personal files
+ * @param {string} cwd - Working directory
+ * @param {boolean} silent - Suppress output
+ */
+function updateGitignore(cwd, silent = false) {
+  const gitignorePath = join(cwd, '.gitignore');
+  let gitignoreContent = '';
+
+  if (existsSync(gitignorePath)) {
+    gitignoreContent = readFileSync(gitignorePath, 'utf8');
+  }
+
+  if (!gitignoreContent.includes('.ai/state.json')) {
+    const pwnSection = '\n# PWN\n.ai/state.json\n.ai/config/notifications.json\n';
+    appendFileSync(gitignorePath, pwnSection);
+    if (!silent) {
+      console.log('📝 Updated .gitignore');
+    }
+  }
+}

package/src/core/state.js

@@ -0,0 +1,91 @@
+import { readFileSync, writeFileSync, existsSync } from 'fs';
+import { join } from 'path';
+import { execSync } from 'child_process';
+
+/**
+ * Get the path to state.json in a workspace
+ * @param {string} cwd - Working directory (defaults to process.cwd())
+ * @returns {string} Path to state.json
+ */
+export function getStatePath(cwd = process.cwd()) {
+  return join(cwd, '.ai', 'state.json');
+}
+
+/**
+ * Check if a PWN workspace exists in the given directory
+ * @param {string} cwd - Working directory
+ * @returns {boolean}
+ */
+export function hasWorkspace(cwd = process.cwd()) {
+  return existsSync(join(cwd, '.ai'));
+}
+
+/**
+ * Get the current git username
+ * @returns {string} Git username or 'unknown'
+ */
+export function getGitUser() {
+  try {
+    return execSync('git config user.name', { encoding: 'utf8' }).trim();
+  } catch {
+    return 'unknown';
+  }
+}
+
+/**
+ * Read the current state from state.json
+ * @param {string} cwd - Working directory
+ * @returns {object|null} State object or null if not found
+ */
+export function getState(cwd = process.cwd()) {
+  const statePath = getStatePath(cwd);
+
+  if (!existsSync(statePath)) {
+    return null;
+  }
+
+  try {
+    const content = readFileSync(statePath, 'utf8');
+    return JSON.parse(content);
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Update the state.json file
+ * @param {object} updates - Fields to update
+ * @param {string} cwd - Working directory
+ * @returns {object} Updated state
+ */
+export function updateState(updates, cwd = process.cwd()) {
+  const statePath = getStatePath(cwd);
+  const currentState = getState(cwd) || {};
+
+  const newState = {
+    ...currentState,
+    ...updates,
+    last_updated: new Date().toISOString()
+  };
+
+  writeFileSync(statePath, JSON.stringify(newState, null, 2));
+  return newState;
+}
+
+/**
+ * Initialize a new state.json file
+ * @param {string} cwd - Working directory
+ * @returns {object} Initial state
+ */
+export function initState(cwd = process.cwd()) {
+  const state = {
+    developer: getGitUser(),
+    session_started: new Date().toISOString(),
+    current_task: null,
+    context_loaded: []
+  };
+
+  const statePath = getStatePath(cwd);
+  writeFileSync(statePath, JSON.stringify(state, null, 2));
+  return state;
+}

package/src/core/validate.js

@@ -0,0 +1,202 @@
+import { existsSync, statSync, readFileSync } from 'fs';
+import { join } from 'path';
+
+/**
+ * Expected workspace structure
+ */
+const REQUIRED_STRUCTURE = {
+  files: [
+    'README.md',
+    'state.json'
+  ],
+  directories: [
+    'memory',
+    'tasks',
+    'patterns',
+    'workflows',
+    'agents',
+    'config'
+  ],
+  memoryFiles: [
+    'memory/decisions.md',
+    'memory/patterns.md',
+    'memory/deadends.md'
+  ],
+  taskFiles: [
+    'tasks/active.md',
+    'tasks/backlog.md'
+  ],
+  agentFiles: [
+    'agents/README.md',
+    'agents/claude.md'
+  ],
+  patternFiles: [
+    'patterns/index.md'
+  ]
+};
+
+/**
+ * Validate a PWN workspace structure
+ * @param {string} cwd - Working directory
+ * @returns {object} Validation result with issues array
+ */
+export function validate(cwd = process.cwd()) {
+  const aiDir = join(cwd, '.ai');
+  const issues = [];
+  const warnings = [];
+
+  // Check if .ai/ exists
+  if (!existsSync(aiDir)) {
+    return {
+      valid: false,
+      issues: ['No .ai/ directory found. Run: pwn inject'],
+      warnings: []
+    };
+  }
+
+  // Check required files
+  for (const file of REQUIRED_STRUCTURE.files) {
+    const filePath = join(aiDir, file);
+    if (!existsSync(filePath)) {
+      issues.push(`Missing file: .ai/${file}`);
+    }
+  }
+
+  // Check required directories
+  for (const dir of REQUIRED_STRUCTURE.directories) {
+    const dirPath = join(aiDir, dir);
+    if (!existsSync(dirPath)) {
+      issues.push(`Missing directory: .ai/${dir}/`);
+    } else if (!statSync(dirPath).isDirectory()) {
+      issues.push(`.ai/${dir} exists but is not a directory`);
+    }
+  }
+
+  // Check memory files
+  for (const file of REQUIRED_STRUCTURE.memoryFiles) {
+    const filePath = join(aiDir, file);
+    if (!existsSync(filePath)) {
+      warnings.push(`Missing memory file: .ai/${file}`);
+    }
+  }
+
+  // Check task files
+  for (const file of REQUIRED_STRUCTURE.taskFiles) {
+    const filePath = join(aiDir, file);
+    if (!existsSync(filePath)) {
+      warnings.push(`Missing task file: .ai/${file}`);
+    }
+  }
+
+  // Check agent files
+  for (const file of REQUIRED_STRUCTURE.agentFiles) {
+    const filePath = join(aiDir, file);
+    if (!existsSync(filePath)) {
+      warnings.push(`Missing agent file: .ai/${file}`);
+    }
+  }
+
+  // Check pattern files
+  for (const file of REQUIRED_STRUCTURE.patternFiles) {
+    const filePath = join(aiDir, file);
+    if (!existsSync(filePath)) {
+      warnings.push(`Missing pattern file: .ai/${file}`);
+    }
+  }
+
+  // Validate state.json format
+  const stateValidation = validateStateJson(aiDir);
+  if (!stateValidation.valid) {
+    issues.push(...stateValidation.issues);
+  }
+
+  return {
+    valid: issues.length === 0,
+    issues,
+    warnings
+  };
+}
+
+/**
+ * Validate state.json structure and content
+ * @param {string} aiDir - Path to .ai directory
+ * @returns {object} Validation result
+ */
+function validateStateJson(aiDir) {
+  const statePath = join(aiDir, 'state.json');
+  const issues = [];
+
+  if (!existsSync(statePath)) {
+    return { valid: false, issues: ['state.json not found'] };
+  }
+
+  try {
+    const content = readFileSync(statePath, 'utf8');
+    const state = JSON.parse(content);
+
+    // Check required fields
+    const requiredFields = ['developer', 'session_started'];
+    for (const field of requiredFields) {
+      if (!(field in state)) {
+        issues.push(`state.json missing required field: ${field}`);
+      }
+    }
+
+    // Validate date format
+    if (state.session_started && isNaN(Date.parse(state.session_started))) {
+      issues.push('state.json: session_started is not a valid date');
+    }
+
+  } catch (error) {
+    if (error instanceof SyntaxError) {
+      issues.push('state.json contains invalid JSON');
+    } else {
+      issues.push(`state.json read error: ${error.message}`);
+    }
+  }
+
+  return {
+    valid: issues.length === 0,
+    issues
+  };
+}
+
+/**
+ * Get a detailed report of workspace structure
+ * @param {string} cwd - Working directory
+ * @returns {object} Structure report
+ */
+export function getStructureReport(cwd = process.cwd()) {
+  const aiDir = join(cwd, '.ai');
+  const report = {
+    exists: existsSync(aiDir),
+    directories: {},
+    files: {}
+  };
+
+  if (!report.exists) {
+    return report;
+  }
+
+  // Check directories
+  for (const dir of REQUIRED_STRUCTURE.directories) {
+    const dirPath = join(aiDir, dir);
+    report.directories[dir] = existsSync(dirPath) && statSync(dirPath).isDirectory();
+  }
+
+  // Check all expected files
+  const allFiles = [
+    ...REQUIRED_STRUCTURE.files,
+    ...REQUIRED_STRUCTURE.memoryFiles,
+    ...REQUIRED_STRUCTURE.taskFiles,
+    ...REQUIRED_STRUCTURE.agentFiles,
+    ...REQUIRED_STRUCTURE.patternFiles
+  ];
+
+  for (const file of allFiles) {
+    const filePath = join(aiDir, file);
+    report.files[file] = existsSync(filePath);
+  }
+
+  return report;
+}