@thanhvn14/csvibe 0.1.3 → 0.1.5

package/.github/agents/schemas/base-output.schema.json

@@ -0,0 +1,88 @@
+{
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "$id": "base-output.schema.json",
+  "title": "Base Agent Output Schema",
+  "description": "Common output structure for all CSVibe agents",
+  "type": "object",
+  "required": ["agent", "status", "summary"],
+  "properties": {
+    "agent": {
+      "type": "string",
+      "description": "Name of the agent that produced this output"
+    },
+    "status": {
+      "type": "string",
+      "enum": ["ok", "blocked", "error"],
+      "description": "Execution status of the agent"
+    },
+    "summary": {
+      "type": "string",
+      "description": "Human-readable summary of what the agent accomplished or why it was blocked/failed"
+    },
+    "data": {
+      "type": "object",
+      "description": "Agent-specific structured data (schema defined per agent)",
+      "additionalProperties": true
+    },
+    "artifacts": {
+      "type": "array",
+      "description": "Files or content produced by the agent",
+      "items": {
+        "type": "object",
+        "required": ["kind", "path"],
+        "properties": {
+          "kind": {
+            "type": "string",
+            "description": "Type of artifact (report, state, config, etc.)"
+          },
+          "path": {
+            "type": "string",
+            "description": "File path where artifact should be written (validated by agent-specific pattern)"
+          },
+          "content": {
+            "type": "string",
+            "description": "Content to write (required for kind=file, optional for kind=reference)"
+          }
+        }
+      }
+    },
+    "handoff": {
+      "type": "object",
+      "description": "Instructions for handing off to next agent in workflow",
+      "required": ["nextAgent", "inputFile"],
+      "properties": {
+        "nextAgent": {
+          "type": "string",
+          "description": "Name of the next agent to invoke"
+        },
+        "inputFile": {
+          "type": "string",
+          "description": "Path to file that next agent should read"
+        }
+      }
+    },
+    "errors": {
+      "type": "array",
+      "description": "List of errors encountered during execution",
+      "items": {
+        "type": "object",
+        "required": ["message"],
+        "properties": {
+          "message": {
+            "type": "string",
+            "description": "Error message"
+          },
+          "code": {
+            "type": "string",
+            "description": "Error code"
+          },
+          "context": {
+            "type": "object",
+            "description": "Additional error context",
+            "additionalProperties": true
+          }
+        }
+      }
+    }
+  }
+}

package/.github/agents/schemas/brainstorm-output.schema.json

@@ -0,0 +1,88 @@
+{
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "$id": "brainstorm-output.schema.json",
+  "title": "Brainstorm Agent Output Schema",
+  "description": "Output schema for brainstorm agent with path-based write permissions",
+  "allOf": [
+    {
+      "$ref": "base-output.schema.json"
+    },
+    {
+      "type": "object",
+      "properties": {
+        "agent": {
+          "const": "brainstorm",
+          "description": "Agent name must be 'brainstorm'"
+        },
+        "artifacts": {
+          "type": "array",
+          "items": {
+            "type": "object",
+            "properties": {
+              "path": {
+                "type": "string",
+                "pattern": "^(plans/reports/brainstorm-.*|.csvibe/state/approaches.*)$",
+                "description": "Brainstorm can only write to plans/reports/brainstorm-* and .csvibe/state/approaches*"
+              }
+            }
+          }
+        },
+        "data": {
+          "type": "object",
+          "description": "Brainstorm-specific data structure",
+          "properties": {
+            "approaches": {
+              "type": "array",
+              "description": "List of proposed approaches",
+              "items": {
+                "type": "object",
+                "required": ["id", "title", "pros", "cons"],
+                "properties": {
+                  "id": {
+                    "type": "string",
+                    "description": "Unique identifier for the approach"
+                  },
+                  "title": {
+                    "type": "string",
+                    "description": "Short title for the approach"
+                  },
+                  "description": {
+                    "type": "string",
+                    "description": "Detailed description of the approach"
+                  },
+                  "pros": {
+                    "type": "array",
+                    "description": "Advantages of this approach",
+                    "items": {
+                      "type": "string"
+                    }
+                  },
+                  "cons": {
+                    "type": "array",
+                    "description": "Disadvantages of this approach",
+                    "items": {
+                      "type": "string"
+                    }
+                  },
+                  "complexity": {
+                    "type": "string",
+                    "enum": ["low", "medium", "high"],
+                    "description": "Implementation complexity"
+                  },
+                  "recommended": {
+                    "type": "boolean",
+                    "description": "Whether this is the recommended approach"
+                  }
+                }
+              }
+            },
+            "context": {
+              "type": "string",
+              "description": "Context and background for the brainstorming session"
+            }
+          }
+        }
+      }
+    }
+  ]
+}

package/.github/agents/schemas/scout-output.schema.json

@@ -0,0 +1,60 @@
+{
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "$id": "scout-output.schema.json",
+  "title": "Scout Agent Output Schema",
+  "description": "Output schema for scout agent with path-based write permissions",
+  "allOf": [
+    {
+      "$ref": "base-output.schema.json"
+    },
+    {
+      "type": "object",
+      "properties": {
+        "agent": {
+          "const": "scout",
+          "description": "Agent name must be 'scout'"
+        },
+        "artifacts": {
+          "type": "array",
+          "items": {
+            "type": "object",
+            "properties": {
+              "path": {
+                "type": "string",
+                "pattern": "^(plans/reports/scout-.*|.csvibe/state/scout-.*)$",
+                "description": "Scout can only write to plans/reports/scout-* and .csvibe/state/scout-*"
+              }
+            }
+          }
+        },
+        "data": {
+          "type": "object",
+          "description": "Scout-specific data structure",
+          "properties": {
+            "filesFound": {
+              "type": "array",
+              "description": "List of file paths discovered",
+              "items": {
+                "type": "string"
+              }
+            },
+            "searchQuery": {
+              "type": "string",
+              "description": "The search query used"
+            },
+            "searchMethod": {
+              "type": "string",
+              "enum": ["glob", "grep", "combined"],
+              "description": "Method used for file discovery"
+            },
+            "totalFiles": {
+              "type": "integer",
+              "description": "Total number of files found",
+              "minimum": 0
+            }
+          }
+        }
+      }
+    }
+  ]
+}

package/.github/agents/scripts/fetch-copilot-tools.js

@@ -0,0 +1,245 @@
+#!/usr/bin/env node
+/**
+ * Fetch Copilot Tools from VSCode Marketplace
+ *
+ * Downloads the latest GitHub Copilot Chat extension and extracts
+ * the available tools list from package.json.
+ *
+ * Usage:
+ *   node fetch-copilot-tools.js              # Output tools as JSON
+ *   node fetch-copilot-tools.js --update     # Update validate-agent-tools.js
+ *   node fetch-copilot-tools.js --verbose    # Show progress
+ *
+ * Source: VSCode Marketplace API
+ * https://marketplace.visualstudio.com/_apis/public/gallery/publishers/GitHub/vsextensions/copilot-chat/latest/vspackage
+ */
+
+import { createWriteStream, readFileSync, writeFileSync, unlinkSync, existsSync } from 'fs';
+import { join, dirname } from 'path';
+import { fileURLToPath } from 'url';
+import { createUnzip } from 'zlib';
+import https from 'https';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+
+// VSCode Marketplace URL for Copilot Chat extension
+const VSIX_URL = 'https://marketplace.visualstudio.com/_apis/public/gallery/publishers/GitHub/vsextensions/copilot-chat/latest/vspackage';
+const TEMP_FILE = join(__dirname, 'copilot-chat-temp.vsix');
+
+// Parse CLI arguments
+function parseArgs(args) {
+  return {
+    update: args.includes('--update'),
+    verbose: args.includes('--verbose'),
+    help: args.includes('--help') || args.includes('-h'),
+  };
+}
+
+// Download file with redirect following
+function downloadFile(url, destPath) {
+  return new Promise((resolve, reject) => {
+    const file = createWriteStream(destPath);
+
+    function makeRequest(requestUrl) {
+      https.get(requestUrl, (response) => {
+        // Handle redirects
+        if (response.statusCode === 301 || response.statusCode === 302) {
+          const redirectUrl = response.headers.location;
+          if (redirectUrl) {
+            makeRequest(redirectUrl);
+            return;
+          }
+        }
+
+        if (response.statusCode !== 200) {
+          reject(new Error(`HTTP ${response.statusCode}: ${response.statusMessage}`));
+          return;
+        }
+
+        response.pipe(file);
+        file.on('finish', () => {
+          file.close();
+          resolve();
+        });
+      }).on('error', (err) => {
+        unlinkSync(destPath);
+        reject(err);
+      });
+    }
+
+    makeRequest(url);
+  });
+}
+
+// Extract package.json from VSIX (gzipped ZIP file)
+async function extractPackageJson(vsixPath) {
+  const { gunzipSync } = await import('zlib');
+  const AdmZip = (await import('adm-zip')).default;
+
+  // Read the gzipped file
+  const gzippedData = readFileSync(vsixPath);
+
+  // Decompress gzip first
+  let zipData;
+  try {
+    zipData = gunzipSync(gzippedData);
+  } catch (e) {
+    // If not gzipped, assume it's already a ZIP
+    zipData = gzippedData;
+  }
+
+  // Now extract from ZIP
+  const zip = new AdmZip(zipData);
+  const entry = zip.getEntry('extension/package.json');
+
+  if (!entry) {
+    throw new Error('package.json not found in VSIX');
+  }
+
+  return JSON.parse(entry.getData().toString('utf8'));
+}
+
+// Extract tools from package.json
+function extractTools(packageJson) {
+  const languageModelTools = packageJson.contributes?.languageModelTools || [];
+
+  const tools = languageModelTools.map(tool => ({
+    name: tool.name,
+    referenceName: tool.toolReferenceName,
+    legacyNames: tool.legacyToolReferenceFullNames || [],
+    displayName: tool.displayName,
+    description: tool.modelDescription || tool.userDescription,
+    tags: tool.tags || [],
+  }));
+
+  // Extract just the reference names
+  const referenceNames = tools.map(t => t.referenceName).filter(Boolean);
+
+  // Build namespaced versions based on common patterns
+  const namespaced = [];
+  const editTools = ['createFile', 'createDirectory', 'editFiles', 'editNotebook', 'insertEdit', 'replaceString', 'multiReplaceString', 'applyPatch'];
+  const searchTools = ['fileSearch', 'textSearch', 'usages', 'codebase', 'symbols'];
+  const readTools = ['readFile', 'listDirectory'];
+  const webTools = ['fetch', 'githubRepo'];
+
+  editTools.forEach(t => { if (referenceNames.includes(t)) namespaced.push(`edit/${t}`); });
+  searchTools.forEach(t => { if (referenceNames.includes(t)) namespaced.push(`search/${t}`); });
+  readTools.forEach(t => { if (referenceNames.includes(t)) namespaced.push(`read/${t}`); });
+  webTools.forEach(t => { if (referenceNames.includes(t)) namespaced.push(`web/${t}`); });
+
+  return {
+    version: packageJson.version,
+    extracted: new Date().toISOString(),
+    toolSets: ['edit', 'search', 'read', 'web'],
+    namespaced,
+    standalone: referenceNames,
+    deprecated: {
+      glob: 'search/fileSearch',
+      grep: 'search/textSearch',
+    },
+    raw: tools,
+  };
+}
+
+// Update validate-agent-tools.js with new tools
+function updateValidationScript(tools) {
+  const validatorPath = join(__dirname, 'validate-agent-tools.js');
+
+  if (!existsSync(validatorPath)) {
+    throw new Error('validate-agent-tools.js not found');
+  }
+
+  let content = readFileSync(validatorPath, 'utf8');
+
+  // Build the new VALID_TOOLS object
+  const newToolsBlock = `// Valid VSCode Copilot Chat tools (as of ${tools.extracted.split('T')[0]})
+// Source: github.copilot-chat extension package.json (languageModelTools)
+// Auto-updated from github.copilot-chat-${tools.version}
+const VALID_TOOLS = {
+  // Tool sets (groups) - these expand to multiple tools
+  toolSets: ${JSON.stringify(tools.toolSets)},
+
+  // Namespaced tools (namespace/tool format)
+  namespaced: ${JSON.stringify(tools.namespaced, null, 4).replace(/\n/g, '\n  ')},
+
+  // Standalone tools (from package.json toolReferenceName)
+  standalone: ${JSON.stringify(tools.standalone, null, 4).replace(/\n/g, '\n  ')},
+
+  // Deprecated/renamed tools (for helpful error messages)
+  deprecated: ${JSON.stringify(tools.deprecated, null, 4).replace(/\n/g, '\n  ')}
+};`;
+
+  // Replace the VALID_TOOLS block
+  const regex = /\/\/ Valid VSCode Copilot Chat tools[\s\S]*?^};/m;
+  if (regex.test(content)) {
+    content = content.replace(regex, newToolsBlock);
+    writeFileSync(validatorPath, content);
+    return true;
+  }
+
+  return false;
+}
+
+// Main function
+async function main() {
+  const args = parseArgs(process.argv.slice(2));
+
+  if (args.help) {
+    console.log(`
+Fetch Copilot Tools from VSCode Marketplace
+
+Usage:
+  node fetch-copilot-tools.js              Output tools as JSON
+  node fetch-copilot-tools.js --update     Update validate-agent-tools.js
+  node fetch-copilot-tools.js --verbose    Show progress
+  node fetch-copilot-tools.js --help       Show this help
+
+Requires: npm install adm-zip
+`);
+    process.exit(0);
+  }
+
+  try {
+    // Download VSIX
+    if (args.verbose) console.log('Downloading Copilot Chat extension...');
+    await downloadFile(VSIX_URL, TEMP_FILE);
+
+    // Extract package.json
+    if (args.verbose) console.log('Extracting package.json...');
+    const packageJson = await extractPackageJson(TEMP_FILE);
+
+    // Extract tools
+    if (args.verbose) console.log('Parsing tools...');
+    const tools = extractTools(packageJson);
+
+    // Cleanup
+    if (existsSync(TEMP_FILE)) {
+      unlinkSync(TEMP_FILE);
+    }
+
+    if (args.update) {
+      // Update validation script
+      const updated = updateValidationScript(tools);
+      if (updated) {
+        console.log(`Updated validate-agent-tools.js with ${tools.standalone.length} tools from v${tools.version}`);
+      } else {
+        console.error('Failed to update validate-agent-tools.js - VALID_TOOLS block not found');
+        process.exit(1);
+      }
+    } else {
+      // Output as JSON
+      console.log(JSON.stringify(tools, null, 2));
+    }
+
+  } catch (err) {
+    console.error('Error:', err.message);
+    // Cleanup on error
+    if (existsSync(TEMP_FILE)) {
+      unlinkSync(TEMP_FILE);
+    }
+    process.exit(1);
+  }
+}
+
+main();