thatgfsj-code 0.6.0 → 0.7.1

package/src/skills/improve-architecture.ts

@@ -0,0 +1,38 @@
+import type { Skill } from './index.js';
+
+export const improveArchitectureSkill: Skill = {
+  id: 'improve-architecture',
+  name: 'Improve Architecture',
+  description: 'Systematically improve codebase structure and quality',
+  category: 'architecture',
+  autoActivate: ['重构', 'refactor', '架构', 'architecture', 'clean', 'improve'],
+  prompt: `## Architecture Improvement Protocol
+
+When improving code structure:
+
+### 1. Assess Current State
+- Read the code and identify pain points
+- Look for: god classes, circular dependencies, tight coupling, code duplication
+
+### 2. Identify Patterns
+- **Single Responsibility**: Does each module/class do ONE thing?
+- **Dependency Direction**: Do high-level modules depend on low-level ones?
+- **Abstraction Level**: Is each layer at the right abstraction?
+
+### 3. Plan Changes
+- Start with the highest-impact, lowest-risk change
+- Each change should be independently valuable
+- Never refactor everything at once
+
+### 4. Execute Safely
+- Make one change at a time
+- Verify after each change
+- Commit frequently
+
+### Red Flags to Fix
+- Files over 300 lines
+- Functions over 50 lines
+- More than 3 levels of nesting
+- Copy-pasted code blocks
+- Circular imports`,
+};

package/src/skills/index.ts

@@ -0,0 +1,136 @@
+/**
+ * Skills Registry - Built-in skills for development workflows
+ * Inspired by skills.sh (obra/superpowers, mattpocock/skills, anthropics/skills)
+ */
+
+export interface Skill {
+  id: string;
+  name: string;
+  description: string;
+  category: 'planning' | 'debugging' | 'testing' | 'architecture' | 'workflow' | 'browser' | 'review';
+  prompt: string;
+  autoActivate?: string[]; // Keywords that auto-activate this skill
+}
+
+// Import all skills
+import { writingPlansSkill } from './writing-plans.js';
+import { executingPlansSkill } from './executing-plans.js';
+import { systematicDebuggingSkill } from './systematic-debugging.js';
+import { brainstormingSkill } from './brainstorming.js';
+import { tddSkill } from './tdd.js';
+import { improveArchitectureSkill } from './improve-architecture.js';
+import { verificationSkill } from './verification.js';
+import { codeReviewSkill } from './code-review.js';
+import { prototypeSkill } from './prototype.js';
+import { triageSkill } from './triage.js';
+import { gitWorkflowSkill } from './git-workflow.js';
+import { subagentSkill } from './subagent.js';
+import { playwrightSkill } from './playwright.js';
+import { frontendDesignSkill } from './frontend-design.js';
+import { supabaseSkill } from './supabase.js';
+import { neuroweaveSkill } from './neuroweave.js';
+
+// All built-in skills (16 total)
+export const BUILTIN_SKILLS: Skill[] = [
+  writingPlansSkill,
+  executingPlansSkill,
+  systematicDebuggingSkill,
+  brainstormingSkill,
+  tddSkill,
+  improveArchitectureSkill,
+  verificationSkill,
+  codeReviewSkill,
+  prototypeSkill,
+  triageSkill,
+  gitWorkflowSkill,
+  subagentSkill,
+  playwrightSkill,
+  frontendDesignSkill,
+  supabaseSkill,
+  neuroweaveSkill,
+];
+
+// Skill registry
+export class SkillRegistry {
+  private skills: Map<string, Skill> = new Map();
+  private activeSkills: Set<string> = new Set();
+
+  constructor() {
+    for (const skill of BUILTIN_SKILLS) {
+      this.skills.set(skill.id, skill);
+    }
+    // Default active skills
+    this.activeSkills.add('writing-plans');
+    this.activeSkills.add('systematic-debugging');
+    this.activeSkills.add('verification');
+  }
+
+  get(id: string): Skill | undefined {
+    return this.skills.get(id);
+  }
+
+  list(): Skill[] {
+    return [...this.skills.values()];
+  }
+
+  listActive(): Skill[] {
+    return [...this.activeSkills].map(id => this.skills.get(id)!).filter(Boolean);
+  }
+
+  activate(id: string): boolean {
+    if (this.skills.has(id)) {
+      this.activeSkills.add(id);
+      return true;
+    }
+    return false;
+  }
+
+  deactivate(id: string): boolean {
+    return this.activeSkills.delete(id);
+  }
+
+  isActive(id: string): boolean {
+    return this.activeSkills.has(id);
+  }
+
+  /**
+   * Get all active skill prompts for system prompt injection
+   */
+  getActivePrompts(): string {
+    const active = this.listActive();
+    if (active.length === 0) return '';
+
+    return active.map(s => `### Skill: ${s.name}\n${s.prompt}`).join('\n\n');
+  }
+
+  /**
+   * Auto-activate skills based on user input
+   */
+  autoActivate(input: string): void {
+    const lower = input.toLowerCase();
+    for (const skill of this.skills.values()) {
+      if (skill.autoActivate?.some(kw => lower.includes(kw))) {
+        this.activeSkills.add(skill.id);
+      }
+    }
+  }
+}
+
+export {
+  writingPlansSkill,
+  executingPlansSkill,
+  systematicDebuggingSkill,
+  brainstormingSkill,
+  tddSkill,
+  improveArchitectureSkill,
+  verificationSkill,
+  codeReviewSkill,
+  prototypeSkill,
+  triageSkill,
+  gitWorkflowSkill,
+  subagentSkill,
+  playwrightSkill,
+  frontendDesignSkill,
+  supabaseSkill,
+  neuroweaveSkill,
+};

package/src/skills/neuroweave.ts

@@ -0,0 +1,47 @@
+import type { Skill } from './index.js';
+
+export const neuroweaveSkill: Skill = {
+  id: 'neuroweave',
+  name: 'NeuroWeave Timeline',
+  description: 'Project evolution memory - track decisions, changes, and milestones',
+  category: 'workflow',
+  autoActivate: ['timeline', 'history', 'what changed', 'why was', 'track'],
+  prompt: `## NeuroWeave Timeline (NWT)
+
+You have access to the NWT tool for tracking project evolution. Use it to:
+
+### When to Log Events
+- **After significant changes**: New features, refactors, bug fixes
+- **When making decisions**: Architecture choices, library selection, design patterns
+- **At milestones**: Feature complete, tests passing, deployment ready
+
+### How to Log
+\`\`\`
+nwt log
+  task: "Add user authentication"
+  summary: "Implemented JWT-based auth with login/register endpoints"
+  reason: "Need user accounts for personalized features"
+  files: "src/auth.ts, src/routes/auth.ts"
+  tags: "feature, auth, api"
+\`\`\`
+
+### Tags Convention
+- \`feature\` - New functionality
+- \`fix\` - Bug fixes
+- \`refactor\` - Code restructuring
+- \`decision\` - Architecture/design decisions
+- \`milestone\` - Project milestones
+- \`config\` - Configuration changes
+- \`docs\` - Documentation updates
+
+### Auto-log Rule
+After completing a multi-step task, automatically log it to NWT with:
+- task: What was done (imperative)
+- summary: How it was done
+- reason: Why it was done
+- files: What files changed
+- tags: Category labels
+
+### Archives
+Events older than 30 days are automatically archived. Use \`nwt story\` to see the full project narrative.`,
+};

package/src/skills/playwright.ts

@@ -0,0 +1,72 @@
+import type { Skill } from './index.js';
+
+export const playwrightSkill: Skill = {
+  id: 'playwright',
+  name: 'Playwright Browser Automation',
+  description: 'Automate browser tasks: testing, scraping, screenshots',
+  category: 'browser',
+  autoActivate: ['browser', 'screenshot', 'scrape', 'web', '网页', '浏览器', 'playwright', 'e2e'],
+  prompt: `## Playwright Browser Automation
+
+You can use the shell tool to run Playwright commands for browser automation.
+
+### Setup
+\`\`\`bash
+npm install playwright
+npx playwright install chromium
+\`\`\`
+
+### Common Tasks
+
+**Take a screenshot:**
+\`\`\`bash
+npx playwright screenshot https://example.com screenshot.png
+\`\`\`
+
+**Scrape page content:**
+\`\`\`javascript
+// save as scrape.js
+const { chromium } = require('playwright');
+(async () => {
+  const browser = await chromium.launch();
+  const page = await browser.newPage();
+  await page.goto('https://example.com');
+  const title = await page.title();
+  const text = await page.textContent('body');
+  console.log('Title:', title);
+  console.log('Content:', text.slice(0, 500));
+  await browser.close();
+})();
+\`\`\`
+
+**Fill and submit forms:**
+\`\`\`javascript
+await page.fill('#username', 'user');
+await page.fill('#password', 'pass');
+await page.click('button[type="submit"]');
+\`\`\`
+
+**Wait for dynamic content:**
+\`\`\`javascript
+await page.waitForSelector('.results');
+await page.waitForLoadState('networkidle');
+\`\`\`
+
+**E2E Testing:**
+\`\`\`javascript
+const { test, expect } = require('@playwright/test');
+test('login flow', async ({ page }) => {
+  await page.goto('/login');
+  await page.fill('#email', 'test@example.com');
+  await page.fill('#password', 'password');
+  await page.click('button[type="submit"]');
+  await expect(page).toHaveURL('/dashboard');
+});
+\`\`\`
+
+### Best Practices
+- Use \`waitForSelector\` before interacting with elements
+- Use \`page.locator()\` for reliable element selection
+- Take screenshots for visual verification
+- Use \`--headed\` flag to watch: \`npx playwright test --headed\``,
+};

package/src/skills/prototype.ts

@@ -0,0 +1,30 @@
+import type { Skill } from './index.js';
+
+export const prototypeSkill: Skill = {
+  id: 'prototype',
+  name: 'Rapid Prototyping',
+  description: 'Quick working prototypes before production code',
+  category: 'workflow',
+  autoActivate: ['prototype', '原型', '快速实现', 'quick', 'demo'],
+  prompt: `## Rapid Prototyping Mode
+
+When the user wants to quickly try something:
+
+### Principles
+- **Working > Perfect** - Get something running first
+- **Skip boilerplate** - Use minimal setup
+- **Hardcode first** - Constants before config
+- **Single file** - Don't split until needed
+
+### Workflow
+1. Create a single file with everything
+2. Make it work end-to-end
+3. Show the result
+4. Ask: "Want me to refactor this into proper code?"
+
+### When to Use
+- Exploring a new API or library
+- Testing a design idea
+- Creating a quick demo
+- Validating an approach`,
+};

package/src/skills/subagent.ts

@@ -0,0 +1,28 @@
+import type { Skill } from './index.js';
+
+export const subagentSkill: Skill = {
+  id: 'subagent',
+  name: 'Subagent Delegation',
+  description: 'Break complex tasks into parallel subtasks',
+  category: 'workflow',
+  prompt: `## Task Decomposition
+
+For complex tasks, think about what can be done in parallel:
+
+### Parallel-izable Tasks
+- Reading multiple independent files
+- Running multiple independent commands
+- Creating multiple independent files
+- Testing multiple independent features
+
+### Sequential Tasks (must be done in order)
+- Build → Test → Deploy
+- Read → Analyze → Write
+- Design → Implement → Verify
+
+### When Task is Complex
+1. Identify independent subtasks
+2. Execute them (in parallel if possible)
+3. Combine results
+4. Verify the whole`,
+};

package/src/skills/supabase.ts

@@ -0,0 +1,44 @@
+import type { Skill } from './index.js';
+
+export const supabaseSkill: Skill = {
+  id: 'supabase',
+  name: 'Supabase Best Practices',
+  description: 'PostgreSQL and Supabase patterns for backend development',
+  category: 'architecture',
+  autoActivate: ['supabase', 'postgres', 'database', 'sql', '数据库'],
+  prompt: `## Supabase / PostgreSQL Best Practices
+
+### Schema Design
+- Use UUIDs for primary keys (\`gen_random_uuid()\`)
+- Always add \`created_at\` and \`updated_at\` timestamps
+- Use enums for fixed sets of values
+- Normalize first, denormalize for performance
+
+### Row Level Security (RLS)
+- Always enable RLS on tables
+- Write policies for each operation (SELECT, INSERT, UPDATE, DELETE)
+- Use \`auth.uid()\` for user-specific access
+- Test policies thoroughly
+
+### Queries
+- Use \`select()\` with specific columns, not \`select('*')\`
+- Use \`maybeSingle()\` instead of \`single()\` when 0 rows is valid
+- Use \`range()\` for pagination
+- Index columns used in WHERE and JOIN
+
+### Common Patterns
+\`\`\`typescript
+// Insert with returning
+const { data, error } = await supabase
+  .from('posts')
+  .insert({ title, content, user_id: user.id })
+  .select()
+  .single();
+
+// Realtime subscriptions
+const channel = supabase
+  .channel('changes')
+  .on('postgres_changes', { event: '*', schema: 'public', table: 'messages' }, handleChange)
+  .subscribe();
+\`\`\``,
+};

package/src/skills/systematic-debugging.ts

@@ -0,0 +1,44 @@
+import type { Skill } from './index.js';
+
+export const systematicDebuggingSkill: Skill = {
+  id: 'systematic-debugging',
+  name: 'Systematic Debugging',
+  description: 'Structured approach to finding and fixing bugs',
+  category: 'debugging',
+  autoActivate: ['bug', 'error', 'fix', 'debug', '不工作', '报错', '出错', '问题'],
+  prompt: `## Debugging Protocol
+
+When debugging an issue, follow this systematic approach:
+
+### 1. Understand the Problem
+- What is the expected behavior?
+- What is the actual behavior?
+- When does it happen? (always, sometimes, specific conditions)
+- What changed recently?
+
+### 2. Gather Evidence
+- Read error messages carefully - they often tell you exactly what's wrong
+- Check logs, console output, stack traces
+- Reproduce the issue reliably before attempting fixes
+
+### 3. Form Hypotheses
+- List 2-3 possible causes, ranked by likelihood
+- For each hypothesis: "If X is the cause, then Y should be true"
+
+### 4. Test Hypotheses
+- Test the most likely hypothesis first
+- Use minimal changes to isolate the issue
+- Add debug logging if needed
+
+### 5. Fix and Verify
+- Apply the minimal fix that addresses the root cause
+- Verify the fix works
+- Check for regressions
+- Explain WHY the fix works
+
+### Anti-patterns to Avoid
+- Don't make random changes hoping something works
+- Don't change multiple things at once
+- Don't skip the "understand" phase
+- Don't fix symptoms instead of root causes`,
+};

package/src/skills/tdd.ts

@@ -0,0 +1,39 @@
+import type { Skill } from './index.js';
+
+export const tddSkill: Skill = {
+  id: 'tdd',
+  name: 'Test-Driven Development',
+  description: 'Write tests first, then implement to pass them',
+  category: 'testing',
+  autoActivate: ['test', '测试', 'tdd', '写测试', '单元测试'],
+  prompt: `## TDD Workflow
+
+When implementing new features, follow the Red-Green-Refactor cycle:
+
+### 1. Red - Write a Failing Test
+- Write the test FIRST
+- Run it and confirm it FAILS
+- This proves the test is actually testing something
+
+### 2. Green - Make It Pass
+- Write the MINIMUM code to make the test pass
+- Don't over-engineer
+- Run the test and confirm it PASSES
+
+### 3. Refactor - Clean Up
+- Now that tests protect you, improve the code
+- Run tests after each change to ensure nothing broke
+
+### Test Naming
+\`\`\`
+describe('FeatureName', () => {
+  it('should do X when Y', () => { ... });
+  it('should handle edge case Z', () => { ... });
+});
+\`\`\`
+
+### Always Test
+- Happy path (normal usage)
+- Edge cases (empty input, null, boundary values)
+- Error cases (invalid input, missing data)`,
+};

package/src/skills/triage.ts

@@ -0,0 +1,35 @@
+import type { Skill } from './index.js';
+
+export const triageSkill: Skill = {
+  id: 'triage',
+  name: 'Issue Triage',
+  description: 'Quickly diagnose and prioritize issues',
+  category: 'debugging',
+  autoActivate: ['issue', 'problem', 'not working', 'broken', '不工作', '挂了'],
+  prompt: `## Issue Triage
+
+When something is broken, quickly assess:
+
+### Severity Classification
+- **P0 Critical**: System down, data loss, security breach
+- **P1 High**: Major feature broken, no workaround
+- **P2 Medium**: Feature degraded, workaround exists
+- **P3 Low**: Minor issue, cosmetic, nice-to-have
+
+### Quick Diagnosis
+1. **What changed?** - Recent commits, deployments, config changes
+2. **Who is affected?** - All users, some users, specific environment
+3. **When did it start?** - Timeline of first occurrence
+4. **What's the impact?** - Data loss, functionality, UX
+
+### Triage Output
+\`\`\`
+## Triage: [Issue Title]
+
+**Severity**: P1 High
+**Impact**: [who/what is affected]
+**Root Cause**: [best guess based on evidence]
+**Suggested Fix**: [minimal fix approach]
+**Workaround**: [if any]
+\`\`\``,
+};

package/src/skills/verification.ts

@@ -0,0 +1,31 @@
+import type { Skill } from './index.js';
+
+export const verificationSkill: Skill = {
+  id: 'verification',
+  name: 'Verification Before Completion',
+  description: 'Always verify work before marking as done',
+  category: 'workflow',
+  prompt: `## Verification Protocol
+
+Before saying "done", always verify:
+
+### For Code Changes
+1. **Read the file** - Confirm the change was actually saved
+2. **Check syntax** - Make sure there are no syntax errors
+3. **Run tests** - If tests exist, run them
+4. **Check imports** - Verify all imports resolve
+
+### For File Operations
+1. **Verify file exists** - Check the file was created/modified
+2. **Read it back** - Confirm the content is correct
+3. **Check permissions** - Ensure the file is accessible
+
+### For Commands
+1. **Check exit code** - Was it 0?
+2. **Read output** - Look for warnings or errors
+3. **Verify side effects** - Did the command do what was expected?
+
+### Never Say "Done" Without
+- Seeing actual output confirming success
+- Or running a verification command`,
+};

package/src/skills/writing-plans.ts

@@ -0,0 +1,42 @@
+import type { Skill } from './index.js';
+
+export const writingPlansSkill: Skill = {
+  id: 'writing-plans',
+  name: 'Writing Plans',
+  description: 'Break down complex tasks into step-by-step execution plans',
+  category: 'planning',
+  autoActivate: ['plan', '怎么实现', '如何做', '方案', '设计', '架构'],
+  prompt: `## Planning Mode
+
+When the user asks you to plan something or the task is complex:
+
+1. **Understand the goal** - Clarify what the user wants to achieve
+2. **Explore the codebase** - Read relevant files to understand context
+3. **Break it down** - Create a numbered list of concrete steps
+4. **Identify risks** - Note potential issues or blockers
+5. **Estimate complexity** - Mark steps as simple/medium/complex
+
+### Plan Format
+\`\`\`
+## Plan: [Task Description]
+
+### Context
+- What we know about the current state
+- Files/modules involved
+
+### Steps
+1. [Step description] (simple/medium/complex)
+2. [Step description]
+   - Sub-step if needed
+3. [Step description]
+
+### Risks
+- [Potential issue and mitigation]
+
+### Files to modify
+- path/to/file1.ts - [what changes]
+- path/to/file2.ts - [what changes]
+\`\`\`
+
+Always present the plan to the user before executing. Ask: "Should I proceed with this plan?"`,
+};

package/src/tools/index.ts

@@ -8,6 +8,7 @@ import { FileTool } from './file.js';
 import { ShellTool } from './shell.js';
 import { GitTool } from './git.js';
 import { SearchTool } from './search.js';
+import { NwtTool } from './nwt.js';
 
 export class ToolRegistry {
   private tools: Map<string, Tool> = new Map();
@@ -25,6 +26,7 @@ export class ToolRegistry {
     this.register(new ShellTool());
     this.register(new GitTool());
     this.register(new SearchTool());
+    this.register(new NwtTool());
   }
 
   setContext(ctx: Partial<ToolContext>): void {
@@ -106,3 +108,4 @@ export { FileTool } from './file.js';
 export { ShellTool } from './shell.js';
 export { GitTool } from './git.js';
 export { SearchTool } from './search.js';
+export { NwtTool } from './nwt.js';