workflow-agent-vscode 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Workflow Agent Team
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,172 @@
+# Workflow Agent - VS Code Extension
+
+Real-time workflow validation and enforcement for VS Code.
+
+## Features
+
+### 🔍 Real-Time Validation
+
+- **Commit Message Validation**: Validates conventional commit format as you type
+- **Branch Name Validation**: Checks branch naming patterns against your workflow config
+- **Scope Validation**: Ensures scopes match your project's defined scopes
+
+### 📊 Status Bar Integration
+
+- Shows current branch name and enforcement mode
+- Visual indicators for validation state (green = valid, yellow = warning, red = error)
+- Click to view full configuration
+
+### ⌨️ Command Palette
+
+Access all Workflow Agent features from the command palette:
+
+- `Workflow: Initialize` - Set up workflow configuration
+- `Workflow: Validate Branch` - Validate current branch name (Ctrl+Shift+W / Cmd+Shift+W)
+- `Workflow: Suggest Improvement` - Submit a suggestion to the improvement tracker
+- `Workflow: Run Doctor` - Check for configuration issues
+- `Workflow: Show Configuration` - View current workflow configuration
+
+### 💡 IntelliSense
+
+- Autocomplete for commit scopes
+- Hover tooltips for validation errors
+- Quick fixes for common issues
+
+## Installation
+
+### From VSIX
+
+1. Download the latest `.vsix` file from releases
+2. Open VS Code
+3. Go to Extensions view (Ctrl+Shift+X)
+4. Click the `...` menu → "Install from VSIX..."
+5. Select the downloaded file
+
+### From Marketplace
+
+```bash
+code --install-extension workflow-agent
+```
+
+## Configuration
+
+### Extension Settings
+
+Configure the extension through VS Code settings:
+
+```json
+{
+  "workflowAgent.enabled": true,
+  "workflowAgent.validateOnType": true,
+  "workflowAgent.showStatusBar": true,
+  "workflowAgent.autoSuggest": false,
+  "workflowAgent.strictMode": false
+}
+```
+
+### Workspace Configuration
+
+Initialize workflow configuration in your workspace:
+
+1. Open command palette (Ctrl+Shift+P / Cmd+Shift+P)
+2. Run `Workflow: Initialize`
+3. Select a preset or create custom configuration
+
+Or use the CLI:
+
+```bash
+workflow init --preset library --name my-project
+```
+
+## Usage
+
+### Validating Commits
+
+The extension automatically validates commit messages as you type in:
+
+- Git commit input boxes
+- `.git/COMMIT_EDITMSG` files
+- SCM view commit message field
+
+Invalid messages will show:
+
+- Red squiggly underlines in the editor
+- Diagnostic messages in the Problems panel
+- Error icons in the status bar
+
+### Validating Branches
+
+Press `Ctrl+Shift+W` (or `Cmd+Shift+W` on Mac) to validate the current branch name.
+
+Valid branch format:
+
+```
+<type>/<scope>/<description>
+```
+
+Examples:
+
+- ✅ `feature/auth/add-oauth`
+- ✅ `bugfix/api/fix-rate-limit`
+- ✅ `docs/readme/update-installation`
+- ❌ `fix-bug`
+- ❌ `feature_new_thing`
+
+### Suggesting Improvements
+
+1. Open command palette
+2. Run `Workflow: Suggest Improvement`
+3. Enter your suggestion
+4. Select a category (feature, bug, documentation, etc.)
+5. Suggestion is submitted to the improvement tracker
+
+## Troubleshooting
+
+### Extension Not Working
+
+1. Check if workflow is initialized: Look for `workflow.config.json` in workspace root
+2. Run `Workflow: Run Doctor` to diagnose issues
+3. Check Output panel → "Workflow Agent" for errors
+
+### Validation Not Triggering
+
+1. Ensure `workflowAgent.enabled` is `true`
+2. Check if you're in a git repository
+3. Verify `workflow.config.json` exists and is valid
+
+### Status Bar Not Showing
+
+1. Ensure `workflowAgent.showStatusBar` is `true`
+2. Check if you're in a git repository
+3. Try reloading the window (Ctrl+R)
+
+## Development
+
+### Building
+
+```bash
+pnpm install
+pnpm build
+```
+
+### Testing
+
+```bash
+# Launch extension development host
+pnpm dev
+
+# Run in VS Code
+# Press F5 to open Extension Development Host
+```
+
+### Packaging
+
+```bash
+pnpm package
+```
+
+Creates a `.vsix` file in the root directory.
+
+## License
+
+MIT - see [LICENSE](../../LICENSE)

package/dist/extension.js

@@ -0,0 +1,486 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/extension.ts
+var extension_exports = {};
+__export(extension_exports, {
+  activate: () => activate,
+  deactivate: () => deactivate
+});
+module.exports = __toCommonJS(extension_exports);
+var vscode5 = __toESM(require("vscode"));
+
+// src/statusBar.ts
+var vscode = __toESM(require("vscode"));
+var StatusBarManager = class {
+  statusBarItem;
+  constructor() {
+    this.statusBarItem = vscode.window.createStatusBarItem(
+      vscode.StatusBarAlignment.Left,
+      100
+    );
+    this.statusBarItem.command = "workflow-agent.showConfig";
+  }
+  show() {
+    this.statusBarItem.show();
+    this.update();
+  }
+  hide() {
+    this.statusBarItem.hide();
+  }
+  update(config) {
+    if (!config) {
+      this.statusBarItem.text = "$(workflow) Workflow";
+      this.statusBarItem.tooltip = "Workflow Agent - Not configured";
+      return;
+    }
+    const branch = config.getCurrentBranch();
+    const hasConfig = config.hasConfig();
+    if (!hasConfig) {
+      this.statusBarItem.text = "$(workflow) Workflow: Not initialized";
+      this.statusBarItem.tooltip = "Click to initialize Workflow Agent";
+      this.statusBarItem.command = "workflow-agent.init";
+      this.statusBarItem.backgroundColor = new vscode.ThemeColor(
+        "statusBarItem.warningBackground"
+      );
+      return;
+    }
+    const enforcement = config.getEnforcement();
+    const icon = enforcement === "strict" ? "$(shield)" : "$(check)";
+    this.statusBarItem.text = `${icon} Workflow: ${branch || "Unknown"}`;
+    this.statusBarItem.tooltip = `Workflow Agent
+Branch: ${branch}
+Enforcement: ${enforcement}
+Click for details`;
+    this.statusBarItem.backgroundColor = void 0;
+  }
+  updateStatus(valid, message) {
+    if (valid) {
+      this.statusBarItem.backgroundColor = void 0;
+      if (message) {
+        this.statusBarItem.tooltip = message;
+      }
+    } else {
+      this.statusBarItem.backgroundColor = new vscode.ThemeColor(
+        "statusBarItem.errorBackground"
+      );
+      if (message) {
+        this.statusBarItem.tooltip = `\u26A0 ${message}`;
+      }
+    }
+  }
+  dispose() {
+    this.statusBarItem.dispose();
+  }
+};
+
+// src/validation.ts
+var vscode2 = __toESM(require("vscode"));
+var ValidationProvider = class {
+  constructor(configManager) {
+    this.configManager = configManager;
+    this.diagnosticCollection = vscode2.languages.createDiagnosticCollection("workflow-agent");
+  }
+  diagnosticCollection;
+  activate(context) {
+    context.subscriptions.push(this.diagnosticCollection);
+    vscode2.workspace.onDidOpenTextDocument((doc) => {
+      if (doc.fileName.includes(".git/COMMIT_EDITMSG")) {
+        this.validateCommitMessage(doc);
+      }
+    });
+    vscode2.workspace.onDidChangeTextDocument((e) => {
+      if (this.configManager.shouldValidateOnType() && e.document.fileName.includes(".git/COMMIT_EDITMSG")) {
+        this.validateCommitMessage(e.document);
+      }
+    });
+  }
+  validateCommitMessage(document) {
+    const text = document.getText();
+    const firstLine = text.split("\n")[0];
+    if (!firstLine || firstLine.startsWith("#")) {
+      return;
+    }
+    const diagnostics = [];
+    const commitPattern = /^(feat|fix|refactor|chore|docs|test|perf|style|ci|build|revert)\(([a-z0-9-]+)\): .{10,}/;
+    if (!commitPattern.test(firstLine)) {
+      const diagnostic = new vscode2.Diagnostic(
+        new vscode2.Range(0, 0, 0, firstLine.length),
+        "Commit message must follow format: type(scope): description",
+        vscode2.DiagnosticSeverity.Error
+      );
+      diagnostic.code = "workflow-commit-format";
+      diagnostic.source = "workflow-agent";
+      diagnostics.push(diagnostic);
+    } else {
+      const match = firstLine.match(/\(([a-z0-9-]+)\)/);
+      if (match) {
+        const scope = match[1];
+        const validScopes = this.configManager.getScopes();
+        if (validScopes.length > 0 && !validScopes.includes(scope)) {
+          const diagnostic = new vscode2.Diagnostic(
+            new vscode2.Range(
+              0,
+              firstLine.indexOf(scope),
+              0,
+              firstLine.indexOf(scope) + scope.length
+            ),
+            `Invalid scope '${scope}'. Valid scopes: ${validScopes.join(", ")}`,
+            vscode2.DiagnosticSeverity.Warning
+          );
+          diagnostic.code = "workflow-invalid-scope";
+          diagnostic.source = "workflow-agent";
+          diagnostics.push(diagnostic);
+        }
+      }
+    }
+    this.diagnosticCollection.set(document.uri, diagnostics);
+  }
+  validateBranch(branchName) {
+    const branchPattern = /^(feature|bugfix|hotfix|chore|refactor|docs|test)\/([a-z0-9-]+)\/[a-z0-9-]+$/;
+    if (!branchPattern.test(branchName)) {
+      return {
+        valid: false,
+        message: "Branch name must follow: <type>/<scope>/<description>"
+      };
+    }
+    const parts = branchName.split("/");
+    if (parts.length >= 2) {
+      const scope = parts[1];
+      const validScopes = this.configManager.getScopes();
+      if (validScopes.length > 0 && !validScopes.includes(scope)) {
+        return {
+          valid: false,
+          message: `Invalid scope '${scope}'. Valid: ${validScopes.join(", ")}`
+        };
+      }
+    }
+    return { valid: true };
+  }
+  dispose() {
+    this.diagnosticCollection.dispose();
+  }
+};
+
+// src/config.ts
+var vscode3 = __toESM(require("vscode"));
+var import_child_process = require("child_process");
+var import_path = require("path");
+var import_fs = require("fs");
+var ConfigManager = class {
+  workspaceConfig = null;
+  workspaceRoot;
+  constructor() {
+    this.workspaceRoot = vscode3.workspace.workspaceFolders?.[0]?.uri.fsPath;
+    this.reload();
+  }
+  reload() {
+    if (!this.workspaceRoot) {
+      this.workspaceConfig = null;
+      return;
+    }
+    const configPath = (0, import_path.join)(this.workspaceRoot, "workflow.config.json");
+    if ((0, import_fs.existsSync)(configPath)) {
+      try {
+        delete require.cache[require.resolve(configPath)];
+        this.workspaceConfig = require(configPath);
+      } catch (error) {
+        console.error("Failed to load workflow config:", error);
+        this.workspaceConfig = null;
+      }
+    } else {
+      this.workspaceConfig = null;
+    }
+  }
+  hasConfig() {
+    return this.workspaceConfig !== null;
+  }
+  getScopes() {
+    if (!this.workspaceConfig?.scopes) {
+      return [];
+    }
+    return this.workspaceConfig.scopes.map((s) => s.name);
+  }
+  getProjectName() {
+    return this.workspaceConfig?.projectName;
+  }
+  getEnforcement() {
+    return this.workspaceConfig?.enforcement || "advisory";
+  }
+  isEnabled() {
+    const config = vscode3.workspace.getConfiguration("workflow-agent");
+    return config.get("enabled", true);
+  }
+  shouldValidateOnType() {
+    const config = vscode3.workspace.getConfiguration("workflow-agent");
+    return config.get("validateOnType", true);
+  }
+  shouldShowStatusBar() {
+    const config = vscode3.workspace.getConfiguration("workflow-agent");
+    return config.get("showStatusBar", true);
+  }
+  isStrictMode() {
+    const config = vscode3.workspace.getConfiguration("workflow-agent");
+    return config.get("strictMode", false);
+  }
+  getCurrentBranch() {
+    if (!this.workspaceRoot) return null;
+    try {
+      const branch = (0, import_child_process.execSync)("git rev-parse --abbrev-ref HEAD", {
+        cwd: this.workspaceRoot,
+        encoding: "utf-8"
+      }).trim();
+      return branch;
+    } catch {
+      return null;
+    }
+  }
+};
+
+// src/commands.ts
+var vscode4 = __toESM(require("vscode"));
+var CommandRegistry = class {
+  constructor(configManager, statusBar, validation) {
+    this.configManager = configManager;
+    this.statusBar = statusBar;
+    this.validation = validation;
+  }
+  registerAll(context) {
+    context.subscriptions.push(
+      vscode4.commands.registerCommand(
+        "workflow-agent.init",
+        () => this.initCommand()
+      )
+    );
+    context.subscriptions.push(
+      vscode4.commands.registerCommand(
+        "workflow-agent.validate",
+        () => this.validateCommand()
+      )
+    );
+    context.subscriptions.push(
+      vscode4.commands.registerCommand(
+        "workflow-agent.suggest",
+        () => this.suggestCommand()
+      )
+    );
+    context.subscriptions.push(
+      vscode4.commands.registerCommand(
+        "workflow-agent.doctor",
+        () => this.doctorCommand()
+      )
+    );
+    context.subscriptions.push(
+      vscode4.commands.registerCommand(
+        "workflow-agent.showConfig",
+        () => this.showConfigCommand()
+      )
+    );
+  }
+  async initCommand() {
+    const terminal = vscode4.window.createTerminal("Workflow Agent");
+    terminal.show();
+    terminal.sendText("workflow init");
+  }
+  async validateCommand() {
+    const branch = this.configManager.getCurrentBranch();
+    if (!branch) {
+      vscode4.window.showErrorMessage("Not in a git repository");
+      return;
+    }
+    const result = this.validation.validateBranch(branch);
+    if (result.valid) {
+      vscode4.window.showInformationMessage(`\u2713 Branch '${branch}' is valid`);
+      this.statusBar.updateStatus(true, "Branch is valid");
+    } else {
+      vscode4.window.showErrorMessage(`\u2717 Invalid branch: ${result.message}`);
+      this.statusBar.updateStatus(false, result.message);
+    }
+  }
+  async suggestCommand() {
+    const feedback = await vscode4.window.showInputBox({
+      prompt: "Enter your improvement suggestion",
+      placeHolder: "e.g., Add support for GitLab repositories",
+      validateInput: (value) => {
+        if (value.length < 10) {
+          return "Suggestion must be at least 10 characters";
+        }
+        if (value.length > 1e3) {
+          return "Suggestion must be less than 1000 characters";
+        }
+        return null;
+      }
+    });
+    if (!feedback) {
+      return;
+    }
+    const category = await vscode4.window.showQuickPick(
+      [
+        { label: "\u2728 Feature Request", value: "feature" },
+        { label: "\u{1F41B} Bug Report", value: "bug" },
+        { label: "\u{1F4DA} Documentation", value: "documentation" },
+        { label: "\u26A1 Performance", value: "performance" },
+        { label: "\u{1F4A1} Other", value: "other" }
+      ],
+      {
+        placeHolder: "Select suggestion category"
+      }
+    );
+    if (!category) {
+      return;
+    }
+    const terminal = vscode4.window.createTerminal("Workflow Agent");
+    terminal.show();
+    terminal.sendText(
+      `workflow suggest "${feedback}" --category ${category.value}`
+    );
+  }
+  async doctorCommand() {
+    const terminal = vscode4.window.createTerminal("Workflow Agent");
+    terminal.show();
+    terminal.sendText("workflow doctor");
+  }
+  async showConfigCommand() {
+    if (!this.configManager.hasConfig()) {
+      const action = await vscode4.window.showInformationMessage(
+        "Workflow Agent is not initialized in this workspace",
+        "Initialize Now"
+      );
+      if (action === "Initialize Now") {
+        this.initCommand();
+      }
+      return;
+    }
+    const projectName = this.configManager.getProjectName();
+    const scopes = this.configManager.getScopes();
+    const enforcement = this.configManager.getEnforcement();
+    const branch = this.configManager.getCurrentBranch();
+    const info = [
+      `**Project:** ${projectName || "Unknown"}`,
+      `**Branch:** ${branch || "Unknown"}`,
+      `**Enforcement:** ${enforcement}`,
+      `**Scopes (${scopes.length}):** ${scopes.join(", ") || "None"}`
+    ].join("\n\n");
+    const panel = vscode4.window.createWebviewPanel(
+      "workflowConfig",
+      "Workflow Configuration",
+      vscode4.ViewColumn.One,
+      {}
+    );
+    panel.webview.html = `
+      <!DOCTYPE html>
+      <html>
+        <head>
+          <meta charset="UTF-8">
+          <style>
+            body {
+              padding: 20px;
+              font-family: var(--vscode-font-family);
+              color: var(--vscode-foreground);
+            }
+            h1 {
+              border-bottom: 1px solid var(--vscode-panel-border);
+              padding-bottom: 10px;
+            }
+            .info {
+              line-height: 1.8;
+            }
+            .scope-list {
+              margin-top: 10px;
+              display: flex;
+              flex-wrap: wrap;
+              gap: 8px;
+            }
+            .scope {
+              background: var(--vscode-badge-background);
+              color: var(--vscode-badge-foreground);
+              padding: 4px 12px;
+              border-radius: 12px;
+              font-size: 0.9em;
+            }
+          </style>
+        </head>
+        <body>
+          <h1>\u{1F680} Workflow Agent Configuration</h1>
+          <div class="info">
+            <p><strong>Project:</strong> ${projectName || "Unknown"}</p>
+            <p><strong>Current Branch:</strong> ${branch || "Unknown"}</p>
+            <p><strong>Enforcement Mode:</strong> ${enforcement}</p>
+            <p><strong>Available Scopes:</strong></p>
+            <div class="scope-list">
+              ${scopes.map((s) => `<span class="scope">${s}</span>`).join("")}
+            </div>
+          </div>
+        </body>
+      </html>
+    `;
+  }
+};
+
+// src/extension.ts
+function activate(context) {
+  console.log("Workflow Agent extension activating...");
+  const configManager = new ConfigManager();
+  const statusBar = new StatusBarManager();
+  const validationProvider = new ValidationProvider(configManager);
+  const commands2 = new CommandRegistry(
+    configManager,
+    statusBar,
+    validationProvider
+  );
+  commands2.registerAll(context);
+  statusBar.show();
+  context.subscriptions.push(statusBar);
+  validationProvider.activate(context);
+  context.subscriptions.push(
+    vscode5.workspace.onDidChangeConfiguration((e) => {
+      if (e.affectsConfiguration("workflow-agent")) {
+        configManager.reload();
+        statusBar.update();
+      }
+    })
+  );
+  context.subscriptions.push(
+    vscode5.workspace.onDidChangeTextDocument((e) => {
+      if (e.document.fileName.includes(".git/COMMIT_EDITMSG")) {
+        validationProvider.validateCommitMessage(e.document);
+      }
+    })
+  );
+  console.log("Workflow Agent extension activated!");
+}
+function deactivate() {
+  console.log("Workflow Agent extension deactivating...");
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  activate,
+  deactivate
+});
+//# sourceMappingURL=extension.js.map