awesome-slash 2.4.2

package/plugins/next-task/lib/platform/verify-tools.js

@@ -0,0 +1,235 @@
+#!/usr/bin/env node
+/**
+ * Tool Verification System
+ * Checks availability and versions of development tools for graceful degradation
+ *
+ * Usage: node lib/platform/verify-tools.js
+ * Output: JSON with tool availability and versions
+ *
+ * @author Avi Fenesh
+ * @license MIT
+ */
+
+const { execFileSync, spawnSync, spawn } = require('child_process');
+
+// Detect Windows platform
+const isWindows = process.platform === 'win32';
+
+/**
+ * Checks if a tool is available and returns its version (sync)
+ * Uses safe execution methods to avoid shell injection vulnerabilities
+ * @param {string} command - Command to check (e.g., 'git', 'node')
+ * @param {string} versionFlag - Flag to get version (default: '--version')
+ * @returns {Object} { available: boolean, version: string|null }
+ */
+function checkTool(command, versionFlag = '--version') {
+  // Validate command contains only safe characters (alphanumeric, underscore, hyphen)
+  if (!/^[a-zA-Z0-9_-]+$/.test(command)) {
+    return { available: false, version: null };
+  }
+  // Validate versionFlag contains only safe characters
+  if (!/^[a-zA-Z0-9_-]+$/.test(versionFlag)) {
+    return { available: false, version: null };
+  }
+
+  try {
+    let output;
+
+    if (isWindows) {
+      // On Windows, use spawnSync with shell to handle .cmd/.bat scripts
+      // Input is validated above so this is safe
+      const result = spawnSync(command, [versionFlag], {
+        encoding: 'utf8',
+        stdio: ['pipe', 'pipe', 'ignore'],
+        timeout: 5000,
+        windowsHide: true,
+        shell: true
+      });
+      if (result.error || result.status !== 0) {
+        return { available: false, version: null };
+      }
+      output = (result.stdout || '').trim();
+    } else {
+      // On Unix, use execFileSync (more secure, no shell)
+      output = execFileSync(command, [versionFlag], {
+        encoding: 'utf8',
+        stdio: ['pipe', 'pipe', 'ignore'],
+        timeout: 5000
+      }).trim();
+    }
+
+    // Extract version from first line
+    const version = output.split('\n')[0];
+    return { available: true, version };
+  } catch {
+    return { available: false, version: null };
+  }
+}
+
+/**
+ * Checks if a tool is available and returns its version (async)
+ * Uses safe execution methods to avoid shell injection vulnerabilities
+ * @param {string} command - Command to check (e.g., 'git', 'node')
+ * @param {string} versionFlag - Flag to get version (default: '--version')
+ * @returns {Promise<Object>} { available: boolean, version: string|null }
+ */
+function checkToolAsync(command, versionFlag = '--version') {
+  return new Promise((resolve) => {
+    // Validate command contains only safe characters (alphanumeric, underscore, hyphen)
+    if (!/^[a-zA-Z0-9_-]+$/.test(command)) {
+      return resolve({ available: false, version: null });
+    }
+    // Validate versionFlag contains only safe characters
+    if (!/^[a-zA-Z0-9_-]+$/.test(versionFlag)) {
+      return resolve({ available: false, version: null });
+    }
+
+    let child;
+
+    if (isWindows) {
+      // On Windows, spawn shell directly with command as single argument to avoid deprecation warning
+      // Input is validated above so this is safe
+      child = spawn('cmd.exe', ['/c', command, versionFlag], {
+        stdio: ['pipe', 'pipe', 'ignore'],
+        windowsHide: true
+      });
+    } else {
+      // On Unix, spawn directly without shell
+      child = spawn(command, [versionFlag], {
+        stdio: ['pipe', 'pipe', 'ignore']
+      });
+    }
+
+    let stdout = '';
+
+    // Set timeout
+    const timeout = setTimeout(() => {
+      child.kill();
+      resolve({ available: false, version: null });
+    }, 5000);
+
+    child.stdout.on('data', (data) => {
+      stdout += data.toString();
+    });
+
+    child.on('error', () => {
+      clearTimeout(timeout);
+      resolve({ available: false, version: null });
+    });
+
+    child.on('close', (code) => {
+      clearTimeout(timeout);
+      if (code !== 0) {
+        return resolve({ available: false, version: null });
+      }
+      const version = stdout.trim().split('\n')[0];
+      resolve({ available: true, version });
+    });
+  });
+}
+
+/**
+ * Tool definitions with their version flags
+ */
+const TOOL_DEFINITIONS = [
+  // Version control
+  { name: 'git', flag: '--version' },
+  { name: 'gh', flag: '--version' },
+
+  // Node.js ecosystem
+  { name: 'node', flag: '--version' },
+  { name: 'npm', flag: '--version' },
+  { name: 'pnpm', flag: '--version' },
+  { name: 'yarn', flag: '--version' },
+  { name: 'bun', flag: '--version' },
+
+  // Python ecosystem
+  { name: 'python', flag: '--version' },
+  { name: 'python3', flag: '--version' },
+  { name: 'pip', flag: '--version' },
+  { name: 'pip3', flag: '--version' },
+  { name: 'poetry', flag: '--version' },
+
+  // Rust ecosystem
+  { name: 'cargo', flag: '--version' },
+  { name: 'rustc', flag: '--version' },
+  { name: 'rustup', flag: '--version' },
+
+  // Go ecosystem
+  { name: 'go', flag: 'version' },
+
+  // Java ecosystem
+  { name: 'java', flag: '--version' },
+  { name: 'javac', flag: '--version' },
+  { name: 'mvn', flag: '--version' },
+  { name: 'gradle', flag: '--version' },
+
+  // Containerization
+  { name: 'docker', flag: '--version' },
+
+  // Deployment platforms
+  { name: 'railway', flag: '--version' },
+  { name: 'vercel', flag: '--version' },
+  { name: 'netlify', flag: '--version' },
+  { name: 'flyctl', flag: 'version' },
+
+  // CI/CD tools
+  { name: 'circleci', flag: 'version' }
+];
+
+/**
+ * Verifies all development tools (sync)
+ * @returns {Object} Tool availability map
+ */
+function verifyTools() {
+  const result = {};
+  for (const tool of TOOL_DEFINITIONS) {
+    result[tool.name] = checkTool(tool.name, tool.flag);
+  }
+  return result;
+}
+
+/**
+ * Verifies all development tools (async, parallel)
+ * Runs all tool checks in parallel for ~10x faster execution
+ * @returns {Promise<Object>} Tool availability map
+ */
+async function verifyToolsAsync() {
+  // Run all checks in parallel
+  const results = await Promise.all(
+    TOOL_DEFINITIONS.map(tool => checkToolAsync(tool.name, tool.flag))
+  );
+
+  // Build result object
+  const toolMap = {};
+  TOOL_DEFINITIONS.forEach((tool, index) => {
+    toolMap[tool.name] = results[index];
+  });
+
+  return toolMap;
+}
+
+// When run directly, output JSON (uses async for better performance)
+if (require.main === module) {
+  (async () => {
+    try {
+      const result = await verifyToolsAsync();
+      console.log(JSON.stringify(result, null, 2));
+    } catch (error) {
+      console.error(JSON.stringify({
+        error: error.message,
+        timestamp: new Date().toISOString()
+      }, null, 2));
+      process.exit(1);
+    }
+  })();
+}
+
+// Export for use as module
+module.exports = {
+  verifyTools,
+  verifyToolsAsync,
+  checkTool,
+  checkToolAsync,
+  TOOL_DEFINITIONS
+};

package/plugins/next-task/lib/state/tasks-registry.schema.json

@@ -0,0 +1,85 @@
+{
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "$id": "tasks-registry.schema.json",
+  "title": "Tasks Registry",
+  "description": "Registry of claimed/in-progress tasks in the main repo. Used to prevent task collisions across parallel workflows.",
+  "type": "object",
+  "required": ["version", "tasks"],
+  "properties": {
+    "version": {
+      "type": "string",
+      "pattern": "^\\d+\\.\\d+\\.\\d+$",
+      "description": "Schema version",
+      "default": "1.0.0"
+    },
+    "tasks": {
+      "type": "array",
+      "description": "List of claimed tasks",
+      "items": {
+        "type": "object",
+        "required": ["id", "source", "branch", "worktreePath", "claimedAt"],
+        "properties": {
+          "id": {
+            "type": "string",
+            "description": "Task identifier (issue number, Linear ID, etc.)"
+          },
+          "source": {
+            "type": "string",
+            "enum": ["github", "linear", "tasks-md", "manual"],
+            "description": "Where the task came from"
+          },
+          "title": {
+            "type": "string",
+            "description": "Task title for display"
+          },
+          "branch": {
+            "type": "string",
+            "description": "Git branch name for this task"
+          },
+          "worktreePath": {
+            "type": "string",
+            "description": "Absolute path to the worktree"
+          },
+          "claimedAt": {
+            "type": "string",
+            "format": "date-time",
+            "description": "When the task was claimed"
+          },
+          "claimedBy": {
+            "type": "string",
+            "description": "Session/workflow ID that claimed this task"
+          },
+          "status": {
+            "type": "string",
+            "enum": ["claimed", "in-progress", "review", "shipping", "done"],
+            "default": "claimed",
+            "description": "High-level task status"
+          },
+          "lastActivityAt": {
+            "type": "string",
+            "format": "date-time",
+            "description": "Last activity timestamp for stale detection"
+          }
+        }
+      }
+    }
+  },
+  "examples": [
+    {
+      "version": "1.0.0",
+      "tasks": [
+        {
+          "id": "123",
+          "source": "github",
+          "title": "Add user authentication",
+          "branch": "feature/add-user-authentication-123",
+          "worktreePath": "/path/to/repo/../worktrees/add-user-authentication-123",
+          "claimedAt": "2024-01-15T10:30:00Z",
+          "claimedBy": "workflow-20240115-103000-abc123",
+          "status": "in-progress",
+          "lastActivityAt": "2024-01-15T11:45:00Z"
+        }
+      ]
+    }
+  ]
+}