@thanhvn14/csvibe 0.1.4 → 0.1.5

package/.github/skills/scout-validation/scripts/lib/broad-pattern-detector.cjs

@@ -0,0 +1,124 @@
+/**
+ * Broad Pattern Detector - Prevent context overflow from broad globs
+ * Ported from ClaudeKit scout-block/broad-pattern-detector.cjs
+ */
+
+// Patterns that recursively match everywhere when at root
+const BROAD_PATTERN_REGEXES = [
+  /^\*\*$/,           // ** - all files everywhere
+  /^\*$/,             // * - all files in root
+  /^\*\*\/\*$/,       // **/* - all files everywhere
+  /^\*\*\/\.\*$/,     // **/. - all dotfiles
+  /^\*\*\/\*\.\w+$/,  // **/*.ext - all with extension
+  /^\*\.\w+$/,        // *.ext at root
+];
+
+// Specific source directories (scoped patterns OK)
+const SPECIFIC_DIRS = [
+  'src', 'lib', 'app', 'apps', 'packages', 'components', 'pages',
+  'api', 'server', 'client', 'web', 'tests', '__tests__', 'spec'
+];
+
+/**
+ * Check if pattern is overly broad
+ */
+function isBroadPattern(pattern) {
+  if (!pattern || typeof pattern !== 'string') return false;
+  const normalized = pattern.trim();
+  return BROAD_PATTERN_REGEXES.some(regex => regex.test(normalized));
+}
+
+/**
+ * Check if pattern starts with specific directory (scoped = OK)
+ */
+function hasSpecificDirectory(pattern) {
+  if (!pattern) return false;
+
+  for (const dir of SPECIFIC_DIRS) {
+    if (pattern.startsWith(`${dir}/`) || pattern.startsWith(`./${dir}/`)) {
+      return true;
+    }
+  }
+
+  // Any non-glob directory prefix is OK
+  const firstSegment = pattern.split('/')[0];
+  if (firstSegment && !firstSegment.includes('*') && firstSegment !== '.') {
+    return true;
+  }
+
+  return false;
+}
+
+/**
+ * Generate suggestions for more specific patterns
+ */
+function suggestSpecificPatterns(pattern) {
+  const suggestions = [];
+  let ext = '';
+
+  const extMatch = pattern.match(/\*\.(\w+)$/);
+  if (extMatch) ext = extMatch[1];
+
+  const commonDirs = ['src', 'lib', 'app', 'components'];
+  for (const dir of commonDirs) {
+    if (ext) {
+      suggestions.push(`${dir}/**/*.${ext}`);
+    } else {
+      suggestions.push(`${dir}/**/*`);
+    }
+  }
+
+  return suggestions.slice(0, 4);
+}
+
+/**
+ * Detect broad pattern issues in scout data
+ * @param {Object} data - Scout output data containing patterns
+ * @returns {{ hasBroadPattern: boolean, patterns: Array, suggestions: string[] }}
+ */
+function detectBroadPatterns(data) {
+  const broadPatterns = [];
+  const allSuggestions = new Set();
+
+  // Check searchQuery if contains pattern-like strings
+  if (data.searchQuery) {
+    const potentialPatterns = data.searchQuery.match(/\*+[^\s]*/g) || [];
+    for (const pattern of potentialPatterns) {
+      if (isBroadPattern(pattern) && !hasSpecificDirectory(pattern)) {
+        broadPatterns.push(pattern);
+        suggestSpecificPatterns(pattern).forEach(s => allSuggestions.add(s));
+      }
+    }
+  }
+
+  // Check any pattern fields in findings
+  if (data.findings && Array.isArray(data.findings)) {
+    for (const finding of data.findings) {
+      if (finding.refs && Array.isArray(finding.refs)) {
+        for (const ref of finding.refs) {
+          if (typeof ref === 'string' && ref.includes('*')) {
+            if (isBroadPattern(ref) && !hasSpecificDirectory(ref)) {
+              broadPatterns.push(ref);
+              suggestSpecificPatterns(ref).forEach(s => allSuggestions.add(s));
+            }
+          }
+        }
+      }
+    }
+  }
+
+  return {
+    hasBroadPattern: broadPatterns.length > 0,
+    patterns: broadPatterns,
+    suggestions: Array.from(allSuggestions)
+  };
+}
+
+module.exports = {
+  isBroadPattern,
+  hasSpecificDirectory,
+  suggestSpecificPatterns,
+  detectBroadPatterns,
+  BROAD_PATTERN_REGEXES,
+  SPECIFIC_DIRS
+};

package/.github/skills/scout-validation/scripts/lib/path-checker.cjs

@@ -0,0 +1,66 @@
+/**
+ * Path Checker - Verify artifact paths match allowed patterns
+ */
+
+// Scout agent allowed path patterns
+const SCOUT_PATH_PATTERNS = [
+  /^plans\/reports\/scout-.*$/,
+  /^\.csvibe\/state\/scout-.*$/
+];
+
+/**
+ * Check if path is allowed for scout agent
+ * @param {string} filePath - Artifact path to check
+ * @returns {{ allowed: boolean, pattern?: string }}
+ */
+function isPathAllowed(filePath) {
+  if (!filePath || typeof filePath !== 'string') {
+    return { allowed: false, pattern: 'empty path' };
+  }
+
+  // Normalize path separators
+  const normalized = filePath.replace(/\\/g, '/');
+
+  for (const pattern of SCOUT_PATH_PATTERNS) {
+    if (pattern.test(normalized)) {
+      return { allowed: true };
+    }
+  }
+
+  return {
+    allowed: false,
+    pattern: `Must match: plans/reports/scout-* OR .csvibe/state/scout-*`
+  };
+}
+
+/**
+ * Check all artifact paths in output
+ * @param {Object} output - Scout output with artifacts array
+ * @returns {{ valid: boolean, violations: Array<{ path: string, reason: string }> }}
+ */
+function checkArtifactPaths(output) {
+  const violations = [];
+
+  if (!output.artifacts || !Array.isArray(output.artifacts)) {
+    return { valid: true, violations: [] };
+  }
+
+  for (const artifact of output.artifacts) {
+    if (artifact.path) {
+      const result = isPathAllowed(artifact.path);
+      if (!result.allowed) {
+        violations.push({
+          path: artifact.path,
+          reason: result.pattern
+        });
+      }
+    }
+  }
+
+  return {
+    valid: violations.length === 0,
+    violations
+  };
+}
+
+module.exports = { isPathAllowed, checkArtifactPaths, SCOUT_PATH_PATTERNS };

package/.github/skills/scout-validation/scripts/lib/schema-validator.cjs

@@ -0,0 +1,45 @@
+/**
+ * Schema Validator - Ajv-based JSON schema validation
+ */
+
+const path = require('path');
+const fs = require('fs');
+
+// Resolve ajv from agents scripts (shared dependency)
+const Ajv = require(path.resolve(__dirname, '../../../../agents/scripts/node_modules/ajv'));
+
+/**
+ * Validate scout output against schema
+ * @param {Object} output - Parsed JSON output
+ * @param {string} schemasDir - Path to schemas directory
+ * @returns {{ valid: boolean, errors?: any[] }}
+ */
+function validateSchema(output, schemasDir) {
+  // Load schemas
+  const baseSchemaPath = path.join(schemasDir, 'base-output.schema.json');
+  const scoutSchemaPath = path.join(schemasDir, 'scout-output.schema.json');
+
+  const baseSchema = JSON.parse(fs.readFileSync(baseSchemaPath, 'utf8'));
+  const scoutSchema = JSON.parse(fs.readFileSync(scoutSchemaPath, 'utf8'));
+
+  // Create Ajv instance
+  const ajv = new Ajv.default({
+    strict: false,
+    validateSchema: false,
+    allowUnionTypes: true
+  });
+
+  // Add base schema
+  ajv.addSchema(baseSchema);
+
+  // Compile scout schema
+  const validate = ajv.compile(scoutSchema);
+
+  if (validate(output)) {
+    return { valid: true };
+  }
+
+  return { valid: false, errors: validate.errors };
+}
+
+module.exports = { validateSchema };

package/.github/skills/scout-validation/scripts/package.json

@@ -0,0 +1,11 @@
+{
+  "name": "scout-validation",
+  "version": "1.0.0",
+  "description": "Scout agent output validation for VS Code Copilot",
+  "type": "commonjs",
+  "main": "validate-scout-output.cjs",
+  "scripts": {
+    "validate": "node validate-scout-output.cjs"
+  },
+  "dependencies": {}
+}

package/.github/skills/scout-validation/scripts/validate-scout-output.cjs

@@ -0,0 +1,219 @@
+#!/usr/bin/env node
+/**
+ * Scout Output Validator
+ *
+ * Validates scout agent JSON output against:
+ * 1. JSON schema (scout-output.schema.json)
+ * 2. Path permissions (plans/reports/scout-*, .csvibe/state/scout-*)
+ * 3. Broad pattern detection
+ *
+ * Usage:
+ *   echo '{"agent":"scout",...}' | node validate-scout-output.cjs
+ *   node validate-scout-output.cjs --input .csvibe/state/scout-context.json
+ *   node validate-scout-output.cjs --input output.json --verbose --json
+ *
+ * Exit codes:
+ *   0 - Validation passed
+ *   1 - Validation failed (schema or path violation)
+ *   2 - Broad pattern warning (non-fatal unless --strict)
+ */
+
+const fs = require('fs');
+const path = require('path');
+const { validateSchema } = require('./lib/schema-validator.cjs');
+const { checkArtifactPaths } = require('./lib/path-checker.cjs');
+const { detectBroadPatterns } = require('./lib/broad-pattern-detector.cjs');
+
+// Parse CLI arguments
+function parseArgs(args) {
+  const parsed = {
+    input: null,
+    verbose: false,
+    json: false,
+    strict: false
+  };
+
+  for (let i = 0; i < args.length; i++) {
+    if (args[i] === '--input' && args[i + 1]) {
+      parsed.input = args[i + 1];
+      i++;
+    } else if (args[i] === '--verbose') {
+      parsed.verbose = true;
+    } else if (args[i] === '--json') {
+      parsed.json = true;
+    } else if (args[i] === '--strict') {
+      parsed.strict = true;
+    }
+  }
+
+  return parsed;
+}
+
+// Read from stdin
+function readStdin() {
+  return new Promise((resolve, reject) => {
+    let data = '';
+    process.stdin.setEncoding('utf8');
+    process.stdin.on('data', chunk => data += chunk);
+    process.stdin.on('end', () => resolve(data));
+    process.stdin.on('error', reject);
+
+    // Timeout for stdin
+    setTimeout(() => {
+      if (!data) resolve('');
+    }, 100);
+  });
+}
+
+async function main() {
+  const args = parseArgs(process.argv.slice(2));
+  const schemasDir = path.resolve(__dirname, '../../../agents/schemas');
+
+  const result = {
+    valid: true,
+    agent: null,
+    checks: {
+      schema: { passed: false },
+      paths: { passed: false, checked: 0 },
+      patterns: { passed: false }
+    },
+    errors: [],
+    warnings: []
+  };
+
+  try {
+    // Read input
+    let input;
+    if (args.input) {
+      // Handle glob pattern for input
+      const inputPath = args.input.includes('*')
+        ? fs.readdirSync(path.dirname(args.input) || '.')
+            .filter(f => f.match(path.basename(args.input).replace('*', '.*')))
+            .map(f => path.join(path.dirname(args.input) || '.', f))[0]
+        : args.input;
+
+      if (!inputPath || !fs.existsSync(inputPath)) {
+        throw new Error(`Input file not found: ${args.input}`);
+      }
+      input = fs.readFileSync(inputPath, 'utf8');
+    } else {
+      input = await readStdin();
+    }
+
+    if (!input || !input.trim()) {
+      throw new Error('No input provided');
+    }
+
+    // Parse JSON
+    let output;
+    try {
+      output = JSON.parse(input);
+    } catch (err) {
+      throw new Error(`Invalid JSON: ${err.message}`);
+    }
+
+    result.agent = output.agent;
+
+    // Check 1: Schema validation
+    const schemaResult = validateSchema(output, schemasDir);
+    result.checks.schema.passed = schemaResult.valid;
+    if (!schemaResult.valid) {
+      result.valid = false;
+      result.errors.push({
+        type: 'schema',
+        message: 'Schema validation failed',
+        details: schemaResult.errors
+      });
+    }
+
+    // Check 2: Path permissions
+    const pathResult = checkArtifactPaths(output);
+    result.checks.paths.passed = pathResult.valid;
+    result.checks.paths.checked = output.artifacts?.length || 0;
+    if (!pathResult.valid) {
+      result.valid = false;
+      result.errors.push({
+        type: 'path',
+        message: 'Path permission violations',
+        details: pathResult.violations
+      });
+    }
+
+    // Check 3: Broad patterns
+    const patternResult = detectBroadPatterns(output.data || {});
+    result.checks.patterns.passed = !patternResult.hasBroadPattern;
+    if (patternResult.hasBroadPattern) {
+      result.warnings.push({
+        type: 'broad-pattern',
+        message: 'Broad glob patterns detected',
+        patterns: patternResult.patterns,
+        suggestions: patternResult.suggestions
+      });
+      if (args.strict) {
+        result.valid = false;
+      }
+    }
+
+    // Output result
+    if (args.json) {
+      console.log(JSON.stringify(result, null, 2));
+    } else {
+      if (result.valid) {
+        console.log('✅ Validation passed');
+      } else {
+        console.log('❌ Validation failed');
+      }
+
+      if (args.verbose || !result.valid) {
+        console.log(`\nAgent: ${result.agent}`);
+        console.log(`Schema: ${result.checks.schema.passed ? '✓' : '✗'}`);
+        console.log(`Paths: ${result.checks.paths.passed ? '✓' : '✗'} (${result.checks.paths.checked} checked)`);
+        console.log(`Patterns: ${result.checks.patterns.passed ? '✓' : '⚠'}`);
+
+        if (result.errors.length > 0) {
+          console.log('\nErrors:');
+          for (const err of result.errors) {
+            console.log(`  - [${err.type}] ${err.message}`);
+            if (args.verbose && err.details) {
+              console.log(`    ${JSON.stringify(err.details, null, 2).replace(/\n/g, '\n    ')}`);
+            }
+          }
+        }
+
+        if (result.warnings.length > 0) {
+          console.log('\nWarnings:');
+          for (const warn of result.warnings) {
+            console.log(`  - [${warn.type}] ${warn.message}`);
+            if (warn.patterns) {
+              console.log(`    Patterns: ${warn.patterns.join(', ')}`);
+            }
+            if (warn.suggestions) {
+              console.log(`    Suggestions: ${warn.suggestions.join(', ')}`);
+            }
+          }
+        }
+      }
+    }
+
+    // Exit code
+    if (!result.valid) {
+      process.exit(1);
+    } else if (result.warnings.length > 0) {
+      process.exit(args.strict ? 1 : 0);
+    } else {
+      process.exit(0);
+    }
+
+  } catch (err) {
+    if (args.json) {
+      result.valid = false;
+      result.errors.push({ type: 'fatal', message: err.message });
+      console.log(JSON.stringify(result, null, 2));
+    } else {
+      console.error(`Error: ${err.message}`);
+    }
+    process.exit(1);
+  }
+}
+
+main();

package/.github/skills/scout-validation/test/broad-pattern-output.json

@@ -0,0 +1,18 @@
+{
+  "agent": "scout",
+  "status": "ok",
+  "summary": "Test with broad pattern",
+  "data": {
+    "filesFound": [],
+    "searchQuery": "**/*.ts",
+    "searchMethod": "glob",
+    "totalFiles": 0
+  },
+  "artifacts": [
+    {
+      "kind": "state",
+      "path": ".csvibe/state/scout-context.json",
+      "content": "{}"
+    }
+  ]
+}

package/.github/skills/scout-validation/test/invalid-path-output.json

@@ -0,0 +1,18 @@
+{
+  "agent": "scout",
+  "status": "ok",
+  "summary": "Test with invalid path",
+  "data": {
+    "filesFound": ["src/index.ts"],
+    "searchQuery": "src/**/*.ts",
+    "searchMethod": "glob",
+    "totalFiles": 1
+  },
+  "artifacts": [
+    {
+      "kind": "report",
+      "path": "src/invalid-path.md",
+      "content": "This should fail validation"
+    }
+  ]
+}

package/.github/skills/scout-validation/test/valid-scout-output.json

@@ -0,0 +1,26 @@
+{
+  "agent": "scout",
+  "status": "ok",
+  "summary": "Successfully analyzed codebase and found relevant files",
+  "data": {
+    "filesFound": [
+      "src/index.ts",
+      "src/app.ts"
+    ],
+    "searchQuery": "src/**/*.ts",
+    "searchMethod": "glob",
+    "totalFiles": 2
+  },
+  "artifacts": [
+    {
+      "kind": "report",
+      "path": "plans/reports/scout-analysis.md",
+      "content": "# Scout Analysis\n\nFound 2 files."
+    },
+    {
+      "kind": "state",
+      "path": ".csvibe/state/scout-context.json",
+      "content": "{\"files\": 2}"
+    }
+  ]
+}

package/.github/skills/sequential-thinking/.env.example

@@ -0,0 +1,8 @@
+# Sequential Thinking Configuration
+
+# Disable thought logging output (useful for automated processing)
+# Set to "true" to disable console logging
+DISABLE_THOUGHT_LOGGING=false
+
+# History file location (optional, defaults to scripts/.thought-history.json)
+# THOUGHT_HISTORY_FILE=/path/to/custom/history.json