aggroot 1.5.0 → 1.5.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "aggroot",
-  "version": "1.5.0",
+  "version": "1.5.1",
   "description": "AggRoot - AI Assistant (Node.js/TypeScript Version)",
   "keywords": [
     "ai",

package/scripts/generate-example-skills.ts

@@ -0,0 +1,238 @@
+/**
+ * 生成示例 Skills 到桌面（带分类目录 + DESCRIPTION.md + 索引缓存）
+ *
+ * 运行: npx tsx scripts/generate-example-skills.ts
+ */
+
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import * as os from 'node:os';
+import { createSkillManageTool } from '../src/domain/skill/skill-manager-tool.js';
+import { createSkillRegistry, loadSkillsWithCache, invalidateIndexCache } from '../src/domain/skill/skill-loader.js';
+
+const outputDir = path.join(os.homedir(), 'Desktop', 'generated-skills');
+fs.mkdirSync(outputDir, { recursive: true });
+process.env.AGGROOT_HOME = outputDir;
+
+const registry = createSkillRegistry();
+const tool = createSkillManageTool(registry);
+
+const skills: Array<{ name: string; category?: string; content: string }> = [
+  // ---- devops 分类 ----
+  {
+    name: 'deploy-to-staging',
+    category: 'devops',
+    content: `---
+name: deploy-to-staging
+description: Deploy the project to staging environment using docker
+whenToUse: When you need to deploy the current project to the staging server
+---
+
+# Deploy to Staging
+
+1. Run tests: \`npm test\`
+2. Build Docker image: \`docker build -t myapp:staging .\`
+3. Push to registry: \`docker push registry.example.com/myapp:staging\`
+4. SSH to staging server: \`ssh deploy@staging.example.com\`
+5. Pull and restart: \`docker-compose pull && docker-compose up -d\`
+6. Verify: \`curl -f https://staging.example.com/health\`
+
+## Pitfalls
+- Always run tests before deploying
+- Check that .env.staging has the correct DATABASE_URL
+- If health check fails, rollback with \`docker-compose down && docker-compose up -d --no-pull\`
+`,
+  },
+  {
+    name: 'rollback',
+    category: 'devops',
+    content: `---
+name: rollback
+description: Rollback a deployment to the previous version
+whenToUse: When a deployment fails or causes issues in production
+---
+
+# Rollback Deployment
+
+1. Check current version: \`docker-compose ps\`
+2. Rollback to previous image: \`docker-compose down && docker-compose up -d --no-pull\`
+3. Verify health: \`curl -f https://staging.example.com/health\`
+4. Notify team in Slack
+
+## Pitfalls
+- Always verify the previous image is still available
+- Don't rollback if database migration already ran
+`,
+  },
+  // ---- debugging 分类 ----
+  {
+    name: 'debug-auth-401',
+    category: 'debugging',
+    content: `---
+name: debug-auth-401
+description: Debug and fix 401 authentication errors in test suites
+whenToUse: When auth tests fail with 401 status code
+---
+
+# Debug Auth 401 Errors
+
+1. Run the failing test with verbose output to identify which test and assertion failed
+2. Read the auth middleware source code to understand the token validation logic
+3. Check if the middleware correctly handles token formats (e.g., Bearer prefix stripping)
+4. Fix the middleware to properly extract the token
+5. Re-run tests to verify the fix
+
+## Common Causes
+- Middleware not stripping "Bearer " prefix from Authorization header
+- Missing or incorrect token extraction logic
+- Token not being passed in test fixtures
+`,
+  },
+  {
+    name: 'debug-memory-leak',
+    category: 'debugging',
+    content: `---
+name: debug-memory-leak
+description: Investigate and fix memory leaks in Node.js applications
+whenToUse: When the application shows increasing memory usage over time
+---
+
+# Debug Memory Leak
+
+1. Take heap snapshot: \`node --inspect app.js\` then Chrome DevTools → Memory → Take Snapshot
+2. Compare snapshots over time to find growing objects
+3. Check for common patterns: event listeners not removed, closures holding references, global caches
+4. Fix the leak and verify with load testing
+
+## Common Causes
+- Event listeners not removed on cleanup
+- Closures capturing large objects
+- Unbounded caches without TTL
+`,
+  },
+  // ---- git 分类 ----
+  {
+    name: 'smart-commit',
+    category: 'git',
+    content: `---
+name: smart-commit
+description: Create a well-structured git commit with proper message
+whenToUse: When you need to commit changes to git
+---
+
+# Smart Commit
+
+1. Run \`git status\` to see all changes
+2. Run \`git diff\` to understand what changed
+3. Stage appropriate files with \`git add\`
+4. Create commit with conventional commit format:
+   - feat: new feature
+   - fix: bug fix
+   - refactor: code refactoring
+
+## Pitfalls
+- Always review the diff before committing
+- Never commit .env files or secrets
+`,
+  },
+  // ---- 根级 skill（无分类）----
+  {
+    name: 'explain',
+    content: `---
+name: explain
+description: Explain code or concept in detail
+whenToUse: When you need to understand how something works
+---
+
+# Explain
+
+1. Read the relevant source files
+2. Trace the execution flow
+3. Summarize the key concepts
+4. Provide examples if helpful
+
+Provide explanation at the requested detail level.
+`,
+  },
+];
+
+console.log('Generating skills with category structure...\n');
+
+for (const skill of skills) {
+  const result = await tool.execute({
+    action: 'create',
+    name: skill.name,
+    content: skill.content,
+    category: skill.category,
+  });
+
+  if (result.success) {
+    console.log(`  ✓ ${skill.name}${skill.category ? ` (category: ${skill.category})` : ''}`);
+  } else {
+    console.log(`  ✗ ${skill.name}: ${result.stderr}`);
+  }
+}
+
+// 手动写 DESCRIPTION.md 文件到分类目录
+const skillsDir = path.join(outputDir, 'skills');
+const descriptions: Record<string, string> = {
+  devops: 'DevOps tools — deployment, rollback, and infrastructure management',
+  debugging: 'Debugging workflows — systematic approaches to finding and fixing bugs',
+  git: 'Git workflows — commit, branch, and version control best practices',
+};
+
+for (const [cat, desc] of Object.entries(descriptions)) {
+  const descPath = path.join(skillsDir, cat, 'DESCRIPTION.md');
+  if (fs.existsSync(path.join(skillsDir, cat))) {
+    fs.writeFileSync(descPath, `---\ndescription: ${desc}\n---\n`, 'utf-8');
+    console.log(`  ✓ ${cat}/DESCRIPTION.md`);
+  }
+}
+
+// 删除旧缓存并重新加载以生成 .index.json
+await invalidateIndexCache(skillsDir);
+
+console.log('\nLoading skills with cache...');
+const { skills: loadedSkills, categories } = await loadSkillsWithCache(skillsDir, 'user');
+
+console.log(`\nLoaded ${loadedSkills.length} skills, ${categories.size} categories:`);
+for (const [cat, desc] of categories) {
+  console.log(`  ${cat}: ${desc}`);
+}
+
+// 验证 .index.json
+const indexPath = path.join(skillsDir, '.index.json');
+if (fs.existsSync(indexPath)) {
+  const cache = JSON.parse(fs.readFileSync(indexPath, 'utf-8'));
+  console.log(`\n.index.json created:`);
+  console.log(`  version: ${cache.version}`);
+  console.log(`  skills: ${cache.skills.length}`);
+  console.log(`  categories: ${Object.keys(cache.categories).join(', ')}`);
+  console.log(`  manifest entries: ${Object.keys(cache.manifest).length}`);
+  for (const entry of cache.skills) {
+    console.log(`    - ${entry.name} (category: ${entry.category || 'none'}, path: ${entry.filePath})`);
+  }
+}
+
+// 列出生成的文件结构
+function listFiles(dir: string, prefix = ''): void {
+  for (const entry of fs.readdirSync(dir, { withFileTypes: true })) {
+    if (entry.name.startsWith('.') && entry.isFile()) {
+      // Show dot files (like .index.json) but with indicator
+      console.log(`${prefix}${entry.name} (cache)`);
+      continue;
+    }
+    if (entry.name.startsWith('.')) continue;
+    if (entry.isDirectory()) {
+      console.log(`${prefix}${entry.name}/`);
+      listFiles(path.join(dir, entry.name), `${prefix}  `);
+    } else {
+      console.log(`${prefix}${entry.name}`);
+    }
+  }
+}
+
+console.log('\nGenerated file structure:');
+listFiles(skillsDir);
+
+console.log(`\nOutput directory: ${outputDir}`);

package/scripts/test-bash-parser.ts

@@ -0,0 +1,37 @@
+import { parseSource } from '../src/shared/utils/bash-parser.ts';
+import { isSafeShellCommand } from '../src/domain/agent/services/approval.ts';
+import { getToolRiskLevel, ToolRiskLevel } from '../src/domain/agent/services/approval.ts';
+
+const commands = [
+  'cd /c/Users/zhuoz/Desktop/gui && ls -la build* 2>/dev/null || echo "No build directory found"',
+  'cd C:/Users/zhuoz/Desktop/gui && find build -name "libAutoJdv*" -o -name "AutoJdv.dll" 2>/dev/null | head -5',
+  'ls -la',
+  'echo hello',
+];
+
+for (const cmd of commands) {
+  console.log(`\n=== Testing: ${cmd.slice(0, 80)}... ===`);
+
+  const t0 = Date.now();
+  let astResult;
+  try {
+    astResult = parseSource(cmd);
+  } catch (e) {
+    console.log('parseSource THREW:', e);
+    continue;
+  }
+  const parseTime = Date.now() - t0;
+  console.log(`parseSource: type=${astResult?.type} children=${astResult?.children?.length} time=${parseTime}ms`);
+
+  const t1 = Date.now();
+  const safe = isSafeShellCommand(cmd);
+  const safeTime = Date.now() - t1;
+  console.log(`isSafeShellCommand: ${safe} time=${safeTime}ms`);
+
+  const t2 = Date.now();
+  const risk = getToolRiskLevel('Shell', { command: cmd });
+  const riskTime = Date.now() - t2;
+  console.log(`getToolRiskLevel: ${risk} time=${riskTime}ms`);
+}
+
+console.log('\nAll tests completed.');

package/scripts/test-parser2.ts

@@ -0,0 +1,24 @@
+import { parseSource } from '../src/shared/utils/bash-parser.ts';
+
+const cmd = 'cd /c/Users/zhuoz/Desktop/gui && ls -la build* 2>/dev/null || echo "No build directory found"';
+
+// Test 1: just parseSource with timeout guard
+console.log('Testing parseSource...');
+const start = Date.now();
+
+// Use a worker-like approach: run in a separate microtask with a hard timeout
+let result: any = 'TIMEOUT';
+let done = false;
+
+// We can't truly timeout sync code in JS, but let's at least see if it returns
+try {
+  result = parseSource(cmd);
+  done = true;
+} catch (e) {
+  result = 'ERROR: ' + e;
+  done = true;
+}
+
+const elapsed = Date.now() - start;
+console.log('parseSource returned:', done ? 'yes' : 'no', 'time:', elapsed, 'ms');
+console.log('result type:', result?.type, 'children:', result?.children?.length);

package/scripts/test-parser3.js

@@ -0,0 +1,4 @@
+// Test: find where the bash parser infinite loop is
+// by testing parseSource with a simpler version of the command
+
+const { parseSource } = require('../dist/shared/utils/bash-parser.cjs');

package/scripts/test-tokenizer.js

@@ -0,0 +1,148 @@
+// Test just the tokenizer - inline the key parts
+function makeLexer(src: string) {
+  return { src, len: src.length, i: 0 }
+}
+
+function peek(L: any, off = 0): string {
+  return L.i + off < L.len ? L.src[L.i + off] : ''
+}
+
+function advance(L: any): void {
+  L.i++
+}
+
+function skipBlanks(L: any): void {
+  while (L.i < L.len) {
+    const c = L.src[L.i]
+    if (c === ' ' || c === '\t' || c === '\r') {
+      advance(L)
+    } else if (c === '\\' && (L.src[L.i + 1] === '\n' || (L.src[L.i + 1] === '\r' && L.src[L.i + 2] === '\n'))) {
+      advance(L); advance(L)
+      if (L.src[L.i - 1] === '\r') advance(L)
+    } else {
+      break
+    }
+  }
+}
+
+function isWordChar(c: string): boolean {
+  return (
+    (c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z') ||
+    (c >= '0' && c <= '9') || c === '_' || c === '/' || c === '.' ||
+    c === '-' || c === '+' || c === ':' || c === '@' || c === '%' ||
+    c === ',' || c === '~' || c === '^' || c === '?' || c === '*' ||
+    c === '!' || c === '=' || c === '[' || c === ']'
+  )
+}
+
+function isWordStart(c: string): boolean {
+  return isWordChar(c) || c === '\\'
+}
+
+function nextToken(L: any, ctx: string = 'arg'): any {
+  skipBlanks(L)
+  const start = L.i
+  if (L.i >= L.len) return { type: 'EOF', value: '', start, end: start }
+
+  const c = L.src[L.i]
+  const c1 = peek(L, 1)
+  const c2 = peek(L, 2)
+
+  if (c === '\n') { advance(L); return { type: 'NEWLINE', value: '\n', start, end: L.i } }
+  if (c === '#') {
+    const si = L.i
+    while (L.i < L.len && L.src[L.i] !== '\n') advance(L)
+    return { type: 'COMMENT', value: L.src.slice(si, L.i), start, end: L.i }
+  }
+
+  // Multi-char operators (longest match first)
+  if (c === '&' && c1 === '&') { advance(L); advance(L); return { type: 'OP', value: '&&', start, end: L.i } }
+  if (c === '|' && c1 === '|') { advance(L); advance(L); return { type: 'OP', value: '||', start, end: L.i } }
+  if (c === '|' && c1 === '&') { advance(L); advance(L); return { type: 'OP', value: '|&', start, end: L.i } }
+  if (c === '>' && c1 === '>') { advance(L); advance(L); return { type: 'OP', value: '>>', start, end: L.i } }
+  if (c === '>' && c1 === '&') { advance(L); advance(L); return { type: 'OP', value: '>&', start, end: L.i } }
+  if (c === '>' && c1 === '|') { advance(L); advance(L); return { type: 'OP', value: '>|', start, end: L.i } }
+  if (c === '&' && c1 === '>' && c2 === '>') { advance(L); advance(L); advance(L); return { type: 'OP', value: '&>>', start, end: L.i } }
+  if (c === '&' && c1 === '>') { advance(L); advance(L); return { type: 'OP', value: '&>', start, end: L.i } }
+  if (c === '<' && c1 === '<' && c2 === '<') { advance(L); advance(L); advance(L); return { type: 'OP', value: '<<<', start, end: L.i } }
+  if (c === '<' && c1 === '<' && c2 === '-') { advance(L); advance(L); advance(L); return { type: 'OP', value: '<<-', start, end: L.i } }
+  if (c === '<' && c1 === '<') { advance(L); advance(L); return { type: 'OP', value: '<<', start, end: L.i } }
+  if (c === '<' && c1 === '&') { advance(L); advance(L); return { type: 'OP', value: '<&', start, end: L.i } }
+  if (c === '<' && c1 === '(') { advance(L); advance(L); return { type: 'LT_PAREN', value: '<(', start, end: L.i } }
+  if (c === '>' && c1 === '(') { advance(L); advance(L); return { type: 'GT_PAREN', value: '>(', start, end: L.i } }
+  if (c === '(' && c1 === '(') { advance(L); advance(L); return { type: 'OP', value: '((', start, end: L.i } }
+  if (c === ')' && c1 === ')') { advance(L); advance(L); return { type: 'OP', value: '))', start, end: L.i } }
+
+  if (c === '|' || c === '&' || c === ';' || c === '>' || c === '<') {
+    advance(L); return { type: 'OP', value: c, start, end: L.i }
+  }
+  if (c === '(' || c === ')') {
+    advance(L); return { type: 'OP', value: c, start, end: L.i }
+  }
+
+  // In cmd position, [ [[ { start test/group
+  if (ctx === 'cmd') {
+    if (c === '[' && c1 === '[') { advance(L); advance(L); return { type: 'OP', value: '[[', start, end: L.i } }
+    if (c === '[') { advance(L); return { type: 'OP', value: '[', start, end: L.i } }
+    if (c === '{' && (c1 === ' ' || c1 === '\t' || c1 === '\n')) { advance(L); return { type: 'OP', value: '{', start, end: L.i } }
+    if (c === '}') { advance(L); return { type: 'OP', value: '}', start, end: L.i } }
+    if (c === '!' && (c1 === ' ' || c1 === '\t')) { advance(L); return { type: 'OP', value: '!', start, end: L.i } }
+  }
+
+  // Quotes
+  if (c === '"') { advance(L); return { type: 'DQUOTE', value: '"', start, end: L.i } }
+  if (c === "'") {
+    const si = L.i; advance(L)
+    while (L.i < L.len && L.src[L.i] !== "'") advance(L)
+    if (L.i < L.len) advance(L)
+    return { type: 'SQUOTE', value: L.src.slice(si, L.i), start, end: L.i }
+  }
+  if (c === '$') {
+    if (c1 === '(' && c2 === '(') { advance(L); advance(L); advance(L); return { type: 'DOLLAR_DPAREN', value: '$((', start, end: L.i } }
+    if (c1 === '(') { advance(L); advance(L); return { type: 'DOLLAR_PAREN', value: '$(', start, end: L.i } }
+    if (c1 === '{') { advance(L); advance(L); return { type: 'DOLLAR_BRACE', value: '${', start, end: L.i } }
+    advance(L); return { type: 'DOLLAR', value: '$', start, end: L.i }
+  }
+  if (c === '`') {
+    const si = L.i; advance(L)
+    while (L.i < L.len && L.src[L.i] !== '`') advance(L)
+    if (L.i < L.len) advance(L)
+    return { type: 'BACKTICK', value: L.src.slice(si, L.i), start, end: L.i }
+  }
+
+  // Word
+  if (isWordStart(c)) {
+    const si = L.i
+    while (L.i < L.len && isWordChar(L.src[L.i]!)) advance(L)
+    return { type: 'WORD', value: L.src.slice(si, L.i), start, end: L.i }
+  }
+
+  // Fallback: single char as word
+  advance(L)
+  return { type: 'WORD', value: c, start, end: L.i }
+}
+
+// Test: tokenize the whole command
+const cmd = 'cd /c/Users/zhuoz/Desktop/gui && ls -la build* 2>/dev/null || echo "No build directory found"';
+const L = makeLexer(cmd);
+const tokens: any[] = [];
+let count = 0;
+const start = Date.now();
+
+while (true) {
+  const tok = nextToken(L);
+  tokens.push(tok);
+  count++;
+  if (tok.type === 'EOF' || count > 100) break;
+  if (Date.now() - start > 5000) {
+    console.log('TOKENIZER TIMEOUT at position', L.i, 'of', L.len);
+    console.log('Last token:', JSON.stringify(tok));
+    console.log('Remaining:', JSON.stringify(cmd.slice(L.i, L.i + 50)));
+    process.exit(1);
+  }
+}
+
+console.log('Tokenization complete:', count, 'tokens in', Date.now() - start, 'ms');
+for (const t of tokens) {
+  console.log(' ', t.type, JSON.stringify(t.value));
+}