@matyah00/openpi 0.1.5 → 0.2.0

package/prompts/perf.md

@@ -0,0 +1,52 @@
+---
+description: Performance audit with bottleneck identification and improvement prioritization
+category: quality
+aliases:
+  - performance
+---
+
+Run a performance audit for:
+
+$ARGUMENTS
+
+Process:
+
+1. Use `env_scan` to identify the stack and build tooling.
+2. Use `project_tree` to understand project structure and identify hot paths.
+3. Use `code_search_batch` for known performance anti-patterns:
+   - N+1 queries, missing indexes, synchronous I/O in async code
+   - Large bundle imports, missing tree-shaking, barrel re-exports
+   - Missing memoization, inline closures in render, unstable keys
+   - O(n²) loops, repeated serialization, missing caching
+4. Use `spawn_agents` with `perf-auditor` for in-depth analysis when useful.
+5. Categorize findings by impact and effort.
+
+Output:
+
+```text
+Performance Audit: {scope}
+
+Risk Level: low | medium | high | critical
+
+Quick Wins (< 1 hour):
+1. file:line - issue - estimated improvement
+
+Medium Effort (1-4 hours):
+1. file:line - issue - estimated improvement
+
+Architecture Changes:
+1. description - estimated improvement - effort
+
+Bundle Analysis:
+- Total: ...
+- Largest deps: ...
+
+Query Analysis:
+- Hot paths: ...
+- N+1 patterns: ...
+
+Recommendations:
+1. ...
+```
+
+Do not optimize prematurely. Focus on measured or evidenced bottlenecks.

package/prompts/refactor.md

@@ -0,0 +1,53 @@
+---
+description: Structured refactoring workflow with smell detection, test verification, and safe execution
+category: quality
+aliases:
+  - cleanup
+---
+
+Refactor the following:
+
+$ARGUMENTS
+
+Do not change behavior. The output of the code before and after must be identical for all inputs.
+
+Process:
+
+1. Use `code_search_batch` and `project_tree` to map the scope.
+2. Identify the code smell or structural problem. Name it:
+   - duplicate code, long method, large class, feature envy, data clump,
+   - shotgun surgery, divergent change, primitive obsession, dead code,
+   - inappropriate intimacy, message chain, speculative generality.
+3. Check for existing tests covering the target code. If tests exist, run them before refactoring.
+4. If no tests exist and the change is risky, write a characterization test first.
+5. Plan the refactoring as a series of small, independently verifiable steps.
+6. Execute one step at a time. Re-run tests after each step.
+7. If any test fails after a step, revert that step and investigate.
+8. Use `spawn_agents` with `reviewer` to verify the refactoring preserves behavior.
+
+Output:
+
+```text
+Refactoring: {smell} in {scope}
+
+Before:
+- Structure: ...
+- Issues: ...
+
+Steps:
+1. {step} - verified by {test or check}
+2. ...
+
+After:
+- Structure: ...
+- Behavior change: NONE
+
+Test results:
+- Before: ...
+- After: ...
+
+Remaining smells:
+- ...
+```
+
+Do not combine refactoring with feature work. Refactoring is behavior-preserving only.

package/scripts/validate-package.mjs

@@ -88,11 +88,38 @@ for (const [chainName, chain] of Object.entries(chains)) {
       continue;
     }
     if (!agentNames.has(step.agent)) fail(`agents/agent-chain.yaml: ${chainName} references unknown agent ${step.agent}`);
-    if (typeof step.prompt !== "string" || !step.prompt.trim()) fail(`agents/agent-chain.yaml: ${chainName} step ${index + 1} missing prompt`);
+    if (typeof step.prompt !== "string" || !step.prompt.trim()) {
+      fail(`agents/agent-chain.yaml: ${chainName} step ${index + 1} missing prompt`);
+    } else if (!step.prompt.includes("$INPUT") && !step.prompt.includes("$ORIGINAL") && !/\$STEP_\d+/.test(step.prompt)) {
+      fail(`agents/agent-chain.yaml: ${chainName} step ${index + 1} prompt must contain either $INPUT, $ORIGINAL or $STEP_N`);
+    }
+  }
+}
+
+// 2. Validate skill directories
+const skillsAbsolute = join(root, "skills");
+if (existsSync(skillsAbsolute)) {
+  for (const entry of readdirSync(skillsAbsolute, { withFileTypes: true })) {
+    if (entry.isDirectory()) {
+      const skillFile = join(skillsAbsolute, entry.name, "SKILL.md");
+      if (!existsSync(skillFile)) {
+        fail(`skills/${entry.name}: missing SKILL.md`);
+      }
+    }
+  }
+}
+
+// 3. Validate theme JSON files
+for (const file of walk("themes", (name) => name.endsWith(".json"))) {
+  try {
+    JSON.parse(read(file));
+  } catch (err) {
+    fail(`${file}: invalid JSON theme file: ${err.message}`);
   }
 }
 
 if (failures.length) {
+
   console.error(failures.map((item) => `- ${item}`).join("\n"));
   process.exit(1);
 }

package/skills/perf-auditor/SKILL.md

@@ -0,0 +1,49 @@
+---
+name: perf-auditor
+description: Use when diagnosing performance issues, optimizing bundle size, fixing slow queries, reducing memory usage, or auditing hot paths.
+---
+
+# Performance Auditor
+
+Focus on measured or evidenced bottlenecks. Do not optimize prematurely.
+
+## Frontend Performance
+
+Check for:
+- Large bundle imports (`import _ from 'lodash'` instead of `import get from 'lodash/get'`)
+- Barrel file re-exports that prevent tree-shaking
+- Missing `React.memo`, `useMemo`, `useCallback` on expensive renders
+- Inline object/function props causing unnecessary re-renders
+- Unoptimized images, missing lazy loading
+- Blocking synchronous scripts in `<head>`
+- Layout thrashing from synchronous DOM read/write cycles
+
+## Backend Performance
+
+Check for:
+- N+1 query patterns in ORM usage (loop with `.find()` or `.get()`)
+- Missing database indexes on filtered/sorted columns
+- Synchronous file I/O in async request handlers
+- Unclosed database connections or missing connection pooling
+- CPU-bound work blocking the event loop
+- Unbounded in-memory caches
+- Missing pagination on list endpoints
+
+## General
+
+Check for:
+- O(n²) or worse algorithmic complexity in hot paths
+- Repeated JSON serialization/deserialization
+- Missing HTTP caching headers
+- Unnecessary network roundtrips
+- Cold start overhead from eager loading
+
+## Tools
+
+Use `code_search_batch` with patterns:
+- `\.find\(`, `\.findOne\(`, `\.get\(` inside loops for N+1
+- `import .* from ['"]lodash['"]` for barrel imports
+- `fs\.readFileSync`, `fs\.writeFileSync` for sync I/O
+- `JSON\.parse.*JSON\.stringify` for repeated serialization
+
+Report findings with `file:line`, estimated impact, and effort to fix.

package/skills/refactor-guide/SKILL.md

@@ -0,0 +1,39 @@
+---
+name: refactor-guide
+description: Use when refactoring code, cleaning up technical debt, removing code smells, extracting modules, or restructuring without changing behavior.
+---
+
+# Refactor Guide
+
+Refactoring preserves behavior. Never combine refactoring with feature work.
+
+## Before Refactoring
+
+1. Identify the code smell by name:
+   - Duplicate code, long method, large class, feature envy, data clump,
+   - shotgun surgery, divergent change, primitive obsession, dead code,
+   - inappropriate intimacy, message chain, speculative generality.
+2. Find existing tests covering the target. Run them. They must pass.
+3. If no tests exist and the change is risky, write a characterization test first.
+
+## During Refactoring
+
+1. Plan as a series of small, independently verifiable steps.
+2. Execute one step at a time.
+3. Re-run relevant tests after each step.
+4. If any test fails, revert that step and investigate.
+5. Do not refactor and add features in the same change.
+
+## After Refactoring
+
+1. Run the full relevant test suite.
+2. Use `ghost_test_scan` before trusting green tests.
+3. Verify no behavior change with concrete before/after evidence.
+4. Use `spawn_agents` with `reviewer` to validate the diff preserves behavior.
+
+## Anti-Patterns to Avoid
+
+- Refactoring without tests as a safety net.
+- "While I'm in here" feature additions.
+- Speculative abstraction (don't extract what you don't need yet).
+- Renaming for style without consensus.

package/tsconfig.json

@@ -6,7 +6,8 @@
     "allowImportingTsExtensions": true,
     "noEmit": true,
     "skipLibCheck": true,
-    "strict": false
+    "strict": true,
+    "noImplicitAny": false
   },
   "include": [
     "extensions/**/*.ts",