context-mode 0.4.0

package/skills/context-mode/references/patterns-javascript.md

@@ -0,0 +1,298 @@
+# JavaScript / TypeScript Patterns for execute
+
+Practical patterns for using `execute` with `language: javascript`.
+All examples assume Node.js runtime with native fetch (Node 18+).
+
+---
+
+## API Response Processing
+
+### Fetch and summarize a REST API
+
+```javascript
+// execute: Analyze API health endpoint
+const resp = await fetch('https://api.example.com/health');
+const data = await resp.json();
+
+console.log('=== Service Health ===');
+console.log(`Status: ${data.status}`);
+console.log(`Uptime: ${data.uptime}`);
+console.log(`Timestamp: ${data.timestamp}`);
+
+if (data.services) {
+  console.log('\n=== Service Components ===');
+  for (const [name, info] of Object.entries(data.services)) {
+    console.log(`  ${name}: ${info.status} (latency: ${info.latency_ms}ms)`);
+  }
+}
+
+if (data.errors && data.errors.length > 0) {
+  console.log('\n=== Recent Errors ===');
+  data.errors.slice(0, 10).forEach(e => {
+    console.log(`  [${e.timestamp}] ${e.code}: ${e.message}`);
+  });
+}
+```
+> summary_prompt: "Report overall health, list any degraded services, and highlight errors"
+
+### Paginated API collection
+
+```javascript
+// execute: Fetch all open issues from GitHub API
+const owner = 'org';
+const repo = 'project';
+let page = 1;
+let allIssues = [];
+
+while (true) {
+  const resp = await fetch(
+    `https://api.github.com/repos/${owner}/${repo}/issues?state=open&per_page=100&page=${page}`,
+    { headers: { 'Accept': 'application/vnd.github.v3+json' } }
+  );
+  const issues = await resp.json();
+  if (issues.length === 0) break;
+  allIssues.push(...issues);
+  page++;
+}
+
+console.log(`Total open issues: ${allIssues.length}\n`);
+
+// Group by labels
+const byLabel = {};
+allIssues.forEach(issue => {
+  issue.labels.forEach(label => {
+    byLabel[label.name] = (byLabel[label.name] || 0) + 1;
+  });
+});
+
+console.log('=== Issues by Label ===');
+Object.entries(byLabel)
+  .sort((a, b) => b[1] - a[1])
+  .forEach(([label, count]) => console.log(`  ${label}: ${count}`));
+
+// Oldest issues
+console.log('\n=== 10 Oldest Issues ===');
+allIssues
+  .sort((a, b) => new Date(a.created_at) - new Date(b.created_at))
+  .slice(0, 10)
+  .forEach(i => console.log(`  #${i.number} (${i.created_at.slice(0,10)}): ${i.title}`));
+```
+> summary_prompt: "Summarize issue distribution by label, highlight stale issues, suggest priorities"
+> timeout_ms: 30000
+
+---
+
+## JSON Data Analysis
+
+### Analyze a large JSON config file
+
+```javascript
+const fs = require('fs');
+const data = JSON.parse(fs.readFileSync('tsconfig.json', 'utf8'));
+
+console.log('=== TSConfig Analysis ===');
+console.log(`Target: ${data.compilerOptions?.target}`);
+console.log(`Module: ${data.compilerOptions?.module}`);
+console.log(`Strict: ${data.compilerOptions?.strict}`);
+console.log(`Paths aliases: ${Object.keys(data.compilerOptions?.paths || {}).length}`);
+
+if (data.compilerOptions?.paths) {
+  console.log('\n=== Path Aliases ===');
+  for (const [alias, targets] of Object.entries(data.compilerOptions.paths)) {
+    console.log(`  ${alias} -> ${targets.join(', ')}`);
+  }
+}
+
+if (data.include) console.log(`\nInclude: ${data.include.join(', ')}`);
+if (data.exclude) console.log(`Exclude: ${data.exclude.join(', ')}`);
+if (data.references) {
+  console.log(`\nProject References: ${data.references.length}`);
+  data.references.forEach(r => console.log(`  ${r.path}`));
+}
+```
+> summary_prompt: "Report compiler strictness, module system, and any unusual configuration"
+
+### Diff two JSON files
+
+```javascript
+const fs = require('fs');
+const a = JSON.parse(fs.readFileSync('config.prod.json', 'utf8'));
+const b = JSON.parse(fs.readFileSync('config.staging.json', 'utf8'));
+
+function diffObjects(obj1, obj2, path = '') {
+  const allKeys = new Set([...Object.keys(obj1 || {}), ...Object.keys(obj2 || {})]);
+  for (const key of allKeys) {
+    const fullPath = path ? `${path}.${key}` : key;
+    if (!(key in (obj1 || {}))) {
+      console.log(`+ ${fullPath}: ${JSON.stringify(obj2[key])}`);
+    } else if (!(key in (obj2 || {}))) {
+      console.log(`- ${fullPath}: ${JSON.stringify(obj1[key])}`);
+    } else if (typeof obj1[key] === 'object' && typeof obj2[key] === 'object') {
+      diffObjects(obj1[key], obj2[key], fullPath);
+    } else if (JSON.stringify(obj1[key]) !== JSON.stringify(obj2[key])) {
+      console.log(`~ ${fullPath}: ${JSON.stringify(obj1[key])} -> ${JSON.stringify(obj2[key])}`);
+    }
+  }
+}
+
+console.log('=== Config Diff: prod vs staging ===');
+diffObjects(a, b);
+```
+> summary_prompt: "List all configuration differences between prod and staging environments"
+
+---
+
+## Package.json / Lock File Analysis
+
+### Dependency audit
+
+```javascript
+const fs = require('fs');
+const pkg = JSON.parse(fs.readFileSync('package.json', 'utf8'));
+
+const deps = Object.entries(pkg.dependencies || {});
+const devDeps = Object.entries(pkg.devDependencies || {});
+
+console.log(`Package: ${pkg.name}@${pkg.version}`);
+console.log(`Dependencies: ${deps.length}`);
+console.log(`DevDependencies: ${devDeps.length}`);
+
+// Find non-pinned versions
+console.log('\n=== Non-Pinned Dependencies ===');
+[...deps, ...devDeps].forEach(([name, version]) => {
+  if (version.startsWith('^') || version.startsWith('~') || version === '*') {
+    console.log(`  ${name}: ${version}`);
+  }
+});
+
+// Find duplicated categories
+console.log('\n=== Scripts ===');
+Object.entries(pkg.scripts || {}).forEach(([name, cmd]) => {
+  console.log(`  ${name}: ${cmd}`);
+});
+
+// Workspace detection
+if (pkg.workspaces) {
+  console.log('\n=== Monorepo Workspaces ===');
+  const ws = Array.isArray(pkg.workspaces) ? pkg.workspaces : pkg.workspaces.packages || [];
+  ws.forEach(w => console.log(`  ${w}`));
+}
+```
+> summary_prompt: "Report dependency health: unpinned versions, total count, any security concerns from package names"
+
+### Lock file drift detection
+
+```javascript
+const fs = require('fs');
+const pkg = JSON.parse(fs.readFileSync('package.json', 'utf8'));
+
+let lockExists = { npm: false, yarn: false, pnpm: false };
+try { fs.accessSync('package-lock.json'); lockExists.npm = true; } catch {}
+try { fs.accessSync('yarn.lock'); lockExists.yarn = true; } catch {}
+try { fs.accessSync('pnpm-lock.yaml'); lockExists.pnpm = true; } catch {}
+
+console.log('=== Lock File Status ===');
+Object.entries(lockExists).forEach(([mgr, exists]) => {
+  console.log(`  ${mgr}: ${exists ? 'PRESENT' : 'missing'}`);
+});
+
+const activeLocks = Object.entries(lockExists).filter(([, v]) => v);
+if (activeLocks.length > 1) {
+  console.log('\nWARNING: Multiple lock files detected! This causes inconsistent installs.');
+}
+if (activeLocks.length === 0) {
+  console.log('\nWARNING: No lock file found! Dependencies are not reproducible.');
+}
+
+// Check engines
+if (pkg.engines) {
+  console.log('\n=== Required Engines ===');
+  Object.entries(pkg.engines).forEach(([e, v]) => console.log(`  ${e}: ${v}`));
+}
+```
+> summary_prompt: "Report lock file health and any warnings about package management"
+
+---
+
+## File Content Parsing
+
+### Parse and summarize a large markdown file
+
+```javascript
+const fs = require('fs');
+const content = fs.readFileSync('CHANGELOG.md', 'utf8');
+const lines = content.split('\n');
+
+const sections = [];
+let currentSection = null;
+
+for (const line of lines) {
+  if (line.startsWith('## ')) {
+    if (currentSection) sections.push(currentSection);
+    currentSection = { title: line.replace('## ', ''), items: 0, breaking: 0 };
+  } else if (currentSection && line.startsWith('- ')) {
+    currentSection.items++;
+    if (line.toLowerCase().includes('breaking') || line.toLowerCase().includes('BREAKING')) {
+      currentSection.breaking++;
+    }
+  }
+}
+if (currentSection) sections.push(currentSection);
+
+console.log(`Total versions: ${sections.length}\n`);
+console.log('=== Recent Versions ===');
+sections.slice(0, 10).forEach(s => {
+  const warn = s.breaking > 0 ? ` [${s.breaking} BREAKING]` : '';
+  console.log(`  ${s.title}: ${s.items} changes${warn}`);
+});
+
+const totalBreaking = sections.reduce((sum, s) => sum + s.breaking, 0);
+if (totalBreaking > 0) {
+  console.log(`\nTotal breaking changes across all versions: ${totalBreaking}`);
+}
+```
+> summary_prompt: "Summarize recent releases, highlight breaking changes, report release cadence"
+
+---
+
+## Test Output Parsing
+
+### Run tests and extract failures
+
+```javascript
+const { execSync } = require('child_process');
+
+let output;
+try {
+  output = execSync('npx jest --json 2>/dev/null', { encoding: 'utf8', maxBuffer: 50 * 1024 * 1024 });
+} catch (e) {
+  output = e.stdout || '';
+}
+
+try {
+  const results = JSON.parse(output);
+  console.log(`=== Test Results ===`);
+  console.log(`Suites: ${results.numPassedTestSuites} passed, ${results.numFailedTestSuites} failed`);
+  console.log(`Tests:  ${results.numPassedTests} passed, ${results.numFailedTests} failed`);
+  console.log(`Time:   ${(results.testResults || []).reduce((s, t) => s + (t.endTime - t.startTime), 0)}ms`);
+
+  const failures = (results.testResults || []).filter(t => t.status === 'failed');
+  if (failures.length > 0) {
+    console.log('\n=== Failed Tests ===');
+    failures.forEach(suite => {
+      console.log(`\nSuite: ${suite.name}`);
+      (suite.assertionResults || [])
+        .filter(a => a.status === 'failed')
+        .forEach(a => {
+          console.log(`  FAIL: ${a.ancestorTitles.join(' > ')} > ${a.title}`);
+          console.log(`    ${(a.failureMessages || []).join('\n    ').slice(0, 200)}`);
+        });
+    });
+  }
+} catch {
+  console.log('Could not parse JSON output. Raw output:');
+  console.log(output.slice(0, 5000));
+}
+```
+> summary_prompt: "Report test pass/fail counts, list each failing test with its error message"
+> timeout_ms: 60000

package/skills/context-mode/references/patterns-python.md

@@ -0,0 +1,304 @@
+# Python Patterns for execute
+
+Practical patterns for using `execute` with `language: python`.
+All examples use Python standard library only (no pip installs required).
+
+---
+
+## Data Processing with json Module
+
+### Analyze a large JSON dataset
+
+```python
+import json
+
+with open('data/users.json') as f:
+    users = json.load(f)
+
+print(f"Total users: {len(users)}")
+
+# Group by status
+from collections import Counter
+statuses = Counter(u.get('status', 'unknown') for u in users)
+print("\n=== Users by Status ===")
+for status, count in statuses.most_common():
+    print(f"  {status}: {count}")
+
+# Find anomalies
+inactive_with_recent = [
+    u for u in users
+    if u.get('status') == 'inactive' and u.get('last_login', '') > '2025-01-01'
+]
+if inactive_with_recent:
+    print(f"\n=== Anomaly: {len(inactive_with_recent)} inactive users with recent logins ===")
+    for u in inactive_with_recent[:10]:
+        print(f"  {u['email']} - last login: {u['last_login']}")
+
+# Field completeness
+fields = ['name', 'email', 'phone', 'address']
+print("\n=== Field Completeness ===")
+for field in fields:
+    filled = sum(1 for u in users if u.get(field))
+    pct = (filled / len(users)) * 100 if users else 0
+    print(f"  {field}: {filled}/{len(users)} ({pct:.1f}%)")
+```
+> summary_prompt: "Report user distribution, data quality issues, and any anomalies found"
+
+### Merge and compare two JSON configs
+
+```python
+import json
+
+with open('config.default.json') as f:
+    defaults = json.load(f)
+with open('config.local.json') as f:
+    local = json.load(f)
+
+def compare(d1, d2, path=""):
+    diffs = []
+    all_keys = set(list(d1.keys()) + list(d2.keys()))
+    for key in sorted(all_keys):
+        full_path = f"{path}.{key}" if path else key
+        if key not in d1:
+            diffs.append(f"  + {full_path} = {json.dumps(d2[key])}")
+        elif key not in d2:
+            diffs.append(f"  - {full_path} = {json.dumps(d1[key])}")
+        elif isinstance(d1[key], dict) and isinstance(d2[key], dict):
+            diffs.extend(compare(d1[key], d2[key], full_path))
+        elif d1[key] != d2[key]:
+            diffs.append(f"  ~ {full_path}: {json.dumps(d1[key])} -> {json.dumps(d2[key])}")
+    return diffs
+
+diffs = compare(defaults, local)
+print(f"Config differences: {len(diffs)}")
+if diffs:
+    print("\n=== Changes (local overrides) ===")
+    for d in diffs:
+        print(d)
+else:
+    print("No differences found — local matches defaults.")
+```
+> summary_prompt: "List all local config overrides and flag any potentially dangerous changes"
+
+---
+
+## CSV / Log File Analysis
+
+### Analyze a CSV file
+
+```python
+import csv
+from collections import Counter, defaultdict
+from datetime import datetime
+
+with open('data/transactions.csv') as f:
+    reader = csv.DictReader(f)
+    rows = list(reader)
+
+print(f"Total records: {len(rows)}")
+print(f"Columns: {', '.join(rows[0].keys()) if rows else 'none'}")
+
+# Summary statistics for numeric column
+amounts = [float(r['amount']) for r in rows if r.get('amount')]
+if amounts:
+    print(f"\n=== Amount Statistics ===")
+    print(f"  Min:    ${min(amounts):,.2f}")
+    print(f"  Max:    ${max(amounts):,.2f}")
+    print(f"  Mean:   ${sum(amounts)/len(amounts):,.2f}")
+    print(f"  Median: ${sorted(amounts)[len(amounts)//2]:,.2f}")
+    print(f"  Total:  ${sum(amounts):,.2f}")
+
+# Group by category
+if 'category' in rows[0]:
+    by_cat = defaultdict(list)
+    for r in rows:
+        by_cat[r['category']].append(float(r.get('amount', 0)))
+    print("\n=== By Category ===")
+    for cat, vals in sorted(by_cat.items(), key=lambda x: -sum(x[1])):
+        print(f"  {cat}: {len(vals)} txns, total ${sum(vals):,.2f}")
+```
+> summary_prompt: "Summarize transaction patterns, highlight outliers, report category distribution"
+
+### Parse application logs
+
+```python
+import re
+from collections import Counter
+from datetime import datetime
+
+error_pattern = re.compile(r'\[(\d{4}-\d{2}-\d{2} \d{2}:\d{2}:\d{2})\] (\w+): (.+)')
+
+levels = Counter()
+errors_by_type = Counter()
+hourly = Counter()
+
+with open('app.log') as f:
+    for line in f:
+        match = error_pattern.match(line.strip())
+        if match:
+            timestamp, level, message = match.groups()
+            levels[level] += 1
+            hour = timestamp[:13]
+            hourly[hour] += 1
+            if level in ('ERROR', 'FATAL'):
+                # Extract error class
+                err_type = message.split(':')[0].strip()
+                errors_by_type[err_type] += 1
+
+print("=== Log Level Distribution ===")
+for level, count in levels.most_common():
+    print(f"  {level}: {count}")
+
+print("\n=== Top Error Types ===")
+for err, count in errors_by_type.most_common(10):
+    print(f"  {err}: {count}")
+
+print("\n=== Hourly Activity (last 24h) ===")
+for hour, count in sorted(hourly.items())[-24:]:
+    bar = '#' * min(count // 10, 50)
+    print(f"  {hour}: {count:>5} {bar}")
+```
+> summary_prompt: "Report error rates, identify the most common failures, and note any traffic spikes"
+
+---
+
+## Text Extraction and Summarization
+
+### Extract TODOs and FIXMEs from codebase
+
+```python
+import os
+import re
+
+pattern = re.compile(r'(TODO|FIXME|HACK|XXX|WARN)[:\s](.+)', re.IGNORECASE)
+results = []
+
+for root, dirs, files in os.walk('src'):
+    # Skip node_modules and hidden dirs
+    dirs[:] = [d for d in dirs if not d.startswith('.') and d != 'node_modules']
+    for fname in files:
+        if fname.endswith(('.ts', '.tsx', '.js', '.jsx', '.py')):
+            filepath = os.path.join(root, fname)
+            with open(filepath) as f:
+                for i, line in enumerate(f, 1):
+                    match = pattern.search(line)
+                    if match:
+                        results.append({
+                            'file': filepath,
+                            'line': i,
+                            'type': match.group(1).upper(),
+                            'text': match.group(2).strip()
+                        })
+
+from collections import Counter
+by_type = Counter(r['type'] for r in results)
+
+print(f"Total annotations found: {len(results)}\n")
+print("=== By Type ===")
+for t, c in by_type.most_common():
+    print(f"  {t}: {c}")
+
+print("\n=== All Items ===")
+for r in results:
+    print(f"  [{r['type']}] {r['file']}:{r['line']} — {r['text'][:100]}")
+```
+> summary_prompt: "Categorize TODOs by urgency, group by file area, suggest which to address first"
+
+### Summarize a large text/markdown file
+
+```python
+with open('ARCHITECTURE.md') as f:
+    content = f.read()
+
+lines = content.split('\n')
+print(f"Total lines: {len(lines)}")
+print(f"Total words: {len(content.split())}")
+
+# Extract structure
+headings = [(i+1, line) for i, line in enumerate(lines) if line.startswith('#')]
+print(f"Sections: {len(headings)}\n")
+
+print("=== Document Structure ===")
+for line_num, heading in headings:
+    level = len(heading) - len(heading.lstrip('#'))
+    indent = '  ' * (level - 1)
+    print(f"  {indent}{heading.strip()} (line {line_num})")
+
+# Extract code blocks
+import re
+code_blocks = re.findall(r'```(\w+)?', content)
+if code_blocks:
+    from collections import Counter
+    langs = Counter(b for b in code_blocks if b)
+    print(f"\n=== Code Blocks: {len(code_blocks)} total ===")
+    for lang, count in langs.most_common():
+        print(f"  {lang}: {count}")
+
+# Print first 50 lines for content preview
+print("\n=== Content Preview (first 50 lines) ===")
+for line in lines[:50]:
+    print(line)
+```
+> summary_prompt: "Summarize the document structure, key architectural decisions, and main components described"
+
+---
+
+## File Comparison
+
+### Compare two source files
+
+```python
+import difflib
+
+with open('src/auth/login.ts') as f:
+    old_lines = f.readlines()
+with open('src/auth/login.new.ts') as f:
+    new_lines = f.readlines()
+
+diff = list(difflib.unified_diff(old_lines, new_lines, fromfile='login.ts', tofile='login.new.ts', lineterm=''))
+
+additions = sum(1 for l in diff if l.startswith('+') and not l.startswith('+++'))
+deletions = sum(1 for l in diff if l.startswith('-') and not l.startswith('---'))
+
+print(f"Changes: +{additions} -{deletions}\n")
+
+if diff:
+    print("=== Diff ===")
+    for line in diff:
+        print(line)
+else:
+    print("Files are identical.")
+```
+> summary_prompt: "Describe the functional changes between the old and new versions"
+
+### Find duplicate content across files
+
+```python
+import os
+import hashlib
+from collections import defaultdict
+
+file_hashes = defaultdict(list)
+
+for root, dirs, files in os.walk('src'):
+    dirs[:] = [d for d in dirs if not d.startswith('.') and d != 'node_modules']
+    for fname in files:
+        if fname.endswith(('.ts', '.tsx', '.js', '.jsx')):
+            filepath = os.path.join(root, fname)
+            with open(filepath, 'rb') as f:
+                content_hash = hashlib.md5(f.read()).hexdigest()
+            file_hashes[content_hash].append(filepath)
+
+duplicates = {h: files for h, files in file_hashes.items() if len(files) > 1}
+
+if duplicates:
+    print(f"Found {len(duplicates)} sets of duplicate files:\n")
+    for h, files in duplicates.items():
+        print(f"  Hash: {h[:8]}...")
+        for f in files:
+            print(f"    {f}")
+        print()
+else:
+    print("No duplicate files found.")
+```
+> summary_prompt: "List all duplicate files and suggest which copies to remove"