opencode-code-simplifier 1.0.0 → 1.1.0

package/README.md

@@ -2,18 +2,18 @@
 
 Code simplifier plugin for [OpenCode](https://opencode.ai). Simplifies and refines code for clarity while preserving functionality.
 
-## Features
+## Install
 
-- Reduces nesting and complexity
-- Removes debug artifacts (unconditional console.log, debugger, commented code)
-- Removes obvious comments that describe what code does
-- Preserves conditional logging (logs behind `if (debug)`, `if (isDev)`, etc.)
-- Converts nested ternaries to if/else chains
-- Applies language-specific best practices
+```bash
+npm install opencode-code-simplifier --save-dev
+```
 
-## Install
+This will automatically:
+1. Copy `skills/code-simplifier/SKILL.md` to `.opencode/skills/`
+2. Copy `rules/code-simplifier.md` to `.opencode/rules/`
+3. Copy `commands/simplify.md` to `.opencode/commands/`
 
-Add to your `opencode.json`:
+Then add to your `opencode.json`:
 
 ```json
 {
@@ -21,27 +21,30 @@ Add to your `opencode.json`:
 }
 ```
 
-Or place the plugin file in:
-- `.opencode/plugins/` (project-level)
-- `~/.config/opencode/plugins/` (global)
-
-## Usage
+Restart OpenCode to activate.
 
-### Automatic
+## Features
 
-The plugin logs when code is modified. Run simplification manually or ask OpenCode to simplify.
+- Reduces nesting and complexity
+- Removes debug artifacts (unconditional console.log, debugger, commented code)
+- Removes obvious comments
+- Preserves conditional logging (if debug, if isDev, etc.)
+- Converts nested ternaries to if/else chains
+- Applies language-specific best practices
 
-### Manual
+## Usage
 
-Use the `simplify-code` tool:
+### Command
 
 ```
-/simplify-code file=path/to/file.js
+/simplify
 ```
 
-### Via Command
+### Manual Tool
 
-The plugin works with the `/simplify` command if you have a corresponding command file.
+```
+simplify-code file=path/to/file.js
+```
 
 ## What Gets Removed
 

package/commands/simplify.md

@@ -0,0 +1,19 @@
+---
+description: Simplify code for clarity while preserving functionality
+agent: code
+---
+
+Use code-simplifier skill to simplify recently modified code.
+
+Focus on:
+1. Reducing complexity and nesting
+2. Eliminating nested ternaries
+3. Improving readability with clear names
+4. Extracting reusable functions
+5. Removing debug artifacts (unconditional console.log, debugger, commented code)
+6. Removing obvious comments
+7. Preserving all functionality
+
+If no file specified, focus on recently modified code.
+
+User request: $ARGUMENTS

package/install.js

@@ -0,0 +1,67 @@
+#!/usr/bin/env node
+
+/**
+ * Postinstall script for opencode-code-simplifier
+ * Copies skills, rules, and commands to .opencode directory
+ */
+
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+
+// Source directory (inside node_modules)
+const sourceDir = __dirname;
+
+// Target directories
+const projectDir = path.join(process.cwd(), '.opencode');
+const globalDir = path.join(os.homedir(), '.config', 'opencode');
+
+function copyDir(src, dest) {
+  if (!fs.existsSync(dest)) {
+    fs.mkdirSync(dest, { recursive: true });
+  }
+
+  const entries = fs.readdirSync(src, { withFileTypes: true });
+
+  for (const entry of entries) {
+    const srcPath = path.join(src, entry.name);
+    const destPath = path.join(dest, entry.name);
+
+    if (entry.isDirectory()) {
+      copyDir(srcPath, destPath);
+    } else {
+      if (!fs.existsSync(destPath)) {
+        fs.copyFileSync(srcPath, destPath);
+        console.log(`  ✓ ${path.relative(process.cwd(), destPath)}`);
+      } else {
+        console.log(`  ⊘ ${path.relative(process.cwd(), destPath)} (exists, skipped)`);
+      }
+    }
+  }
+}
+
+function install(targetDir) {
+  const dirs = ['skills', 'rules', 'commands'];
+
+  console.log(`\n📦 Installing opencode-code-simplifier to ${targetDir}\n`);
+
+  for (const dir of dirs) {
+    const src = path.join(sourceDir, dir);
+    const dest = path.join(targetDir, dir);
+
+    if (fs.existsSync(src)) {
+      console.log(`${dir}/`);
+      copyDir(src, dest);
+    }
+  }
+
+  console.log('\n✅ Done! Restart OpenCode to use the plugin.\n');
+}
+
+// Install to project .opencode directory
+if (fs.existsSync(projectDir)) {
+  install(projectDir);
+} else {
+  console.log('\n⚠️  No .opencode directory found in current project.');
+  console.log('   Run this in your project root, or install globally.\n');
+}

package/package.json

@@ -1,15 +1,20 @@
 {
   "name": "opencode-code-simplifier",
-  "version": "1.0.0",
+  "version": "1.1.0",
   "description": "Code simplifier plugin for OpenCode - simplifies and refines code for clarity while preserving functionality",
   "main": "dist/plugin.js",
   "types": "dist/plugin.d.ts",
   "files": [
     "dist",
+    "skills",
+    "rules",
+    "commands",
+    "install.js",
     "README.md"
   ],
   "scripts": {
     "build": "bun build plugin.ts --outfile=dist/plugin.js --target=node",
+    "postinstall": "node install.js",
     "prepublishOnly": "bun run build"
   },
   "keywords": [

package/rules/code-simplifier.md

@@ -0,0 +1,46 @@
+# Code Simplifier Rules
+
+Simplify code for clarity while preserving exact functionality.
+
+## Core Rules
+
+1. **Preserve Functionality** - Never change what code does, only how.
+
+2. **Enhance Clarity**:
+   - Reduce nesting and complexity
+   - Eliminate redundant code
+   - Improve variable/function names
+   - Consolidate related logic
+   - Remove obvious comments
+   - Use if/else or switch over nested ternaries
+   - Clarity over brevity
+
+3. **Remove Debug Artifacts**:
+   - DELETE: Unconditional console.log/debug, debugger, commented-out code, bare print() in Python
+   - KEEP: Logs behind guards (`if (debug)`, `if (process.env.DEBUG)`), logger calls with levels, console.error/warn
+
+4. **Maintain Balance** - Don't over-simplify into clever one-liners.
+
+## Language Guidelines
+
+**JavaScript/TypeScript:**
+- ES modules with proper imports
+- `function` keyword over arrow functions
+- Explicit return types for top-level functions
+- Avoid try/catch when possible
+
+**Python:**
+- Follow PEP 8
+- Use type hints
+- List comprehensions when clearer
+- Context managers for resources
+
+## When to Apply
+
+- After writing/modifying code
+- During code review
+- When explicitly asked
+
+Skip when:
+- User wants exact structure preserved
+- Code is already clean

package/skills/code-simplifier/SKILL.md

@@ -0,0 +1,56 @@
+---
+name: code-simplifier
+description: Simplifies and refines code for clarity, consistency, and maintainability while preserving all functionality.
+---
+
+You are a code simplification specialist. Refine recently modified code for clarity while preserving exact functionality. Prioritize readable, explicit code over overly compact solutions.
+
+## Core Rules
+
+1. **Preserve Functionality** - Never change what code does, only how it does it.
+
+2. **Apply Project Standards** (from AGENTS.md):
+   - ES modules with proper imports
+   - `function` keyword over arrow functions
+   - Explicit return types for top-level functions
+   - Proper React patterns with explicit Props types
+   - Avoid try/catch when possible
+   - Consistent naming conventions
+
+3. **Enhance Clarity**:
+   - Reduce nesting and complexity
+   - Eliminate redundant code
+   - Improve variable/function names
+   - Consolidate related logic
+   - Remove obvious comments
+   - Use if/else or switch over nested ternaries
+   - Clarity over brevity
+
+4. **Remove Debug Artifacts**:
+
+   DELETE:
+   - Unconditional console.log/console.debug
+   - debugger statements
+   - Commented-out code
+   - Obsolete TODO/FIXME
+   - Bare print() in Python
+   - Unused debug variables
+
+   KEEP:
+   - Logs behind guards: `if (debug)`, `if (isDev)`, `if (process.env.DEBUG)`
+   - Logger calls with levels: `logger.debug()`
+   - Python logging module with level checks
+   - console.error for error handling
+   - console.warn for legitimate warnings
+
+5. **Maintain Balance** - Don't over-simplify. Avoid clever one-liners that reduce readability.
+
+6. **Focus Scope** - Only refine recently modified code unless instructed otherwise.
+
+## Process
+
+1. Identify recently modified sections
+2. Apply standards and simplify structure
+3. Remove debug artifacts and obvious comments
+4. Verify functionality unchanged
+5. Confirm readability improved