@arungeorgesaji/assembly 0.1.0

package/src/validation.js

@@ -0,0 +1,33 @@
+import { validateAgentProfiles } from "./agent-profiles.js";
+import { validateScope } from "./scope.js";
+
+export function validatePlan(plan) {
+  const errors = [];
+  const taskIds = new Set(plan.tasks.map((task) => task.id));
+
+  if (plan.tasks.length === 0) {
+    errors.push("plan must include at least one task");
+  }
+
+  for (const task of plan.tasks) {
+    if (!task.id) {
+      errors.push("task id cannot be empty");
+    }
+    if (!task.owner) {
+      errors.push(`task ${task.id} must have an owner`);
+    }
+    if (task.acceptanceCriteria.length === 0) {
+      errors.push(`task ${task.id} must include acceptance criteria`);
+    }
+    errors.push(...validateScope(task.scope, task.id));
+    for (const dependency of task.dependencies) {
+      if (!taskIds.has(dependency)) {
+        errors.push(`task ${task.id} depends on unknown task ${dependency}`);
+      }
+    }
+  }
+
+  errors.push(...validateAgentProfiles(plan));
+
+  return errors;
+}

package/src/verification-runner.js

@@ -0,0 +1,51 @@
+import { spawn } from "node:child_process";
+
+export async function runVerificationCommands(commands, rootDir = process.cwd()) {
+  const results = [];
+
+  for (const command of commands) {
+    const result = await runCommand(command, rootDir);
+    results.push(result);
+    if (result.exitCode !== 0) {
+      break;
+    }
+  }
+
+  return results;
+}
+
+function runCommand(command, rootDir) {
+  return new Promise((resolve) => {
+    const child = spawn(command, {
+      cwd: rootDir,
+      shell: true,
+      env: process.env,
+    });
+    let stdout = "";
+    let stderr = "";
+
+    child.stdout.on("data", (chunk) => {
+      stdout += chunk;
+    });
+    child.stderr.on("data", (chunk) => {
+      stderr += chunk;
+    });
+    child.on("error", (error) => {
+      resolve({
+        command,
+        exitCode: 1,
+        stdout,
+        stderr: error.message,
+      });
+    });
+    child.on("close", (exitCode) => {
+      resolve({
+        command,
+        exitCode,
+        stdout,
+        stderr,
+      });
+    });
+  });
+}
+

package/src/webhook-server.js

@@ -0,0 +1,64 @@
+import http from "node:http";
+
+import { loadEnv } from "./config.js";
+import { handleGitHubWebhook } from "./github-webhooks.js";
+import { processJob } from "./job-worker.js";
+import { handleSlackWebhook } from "./slack-webhooks.js";
+
+export function startWebhookServer({ port = 3000, host = "127.0.0.1", rootDir = process.cwd(), processJobs = true } = {}) {
+  const server = http.createServer(async (request, response) => {
+    await loadEnv(rootDir);
+
+    if (request.method !== "POST" || !["/github/webhook", "/slack/events"].includes(request.url)) {
+      response.writeHead(404, { "Content-Type": "application/json" });
+      response.end(JSON.stringify({ error: "not found" }));
+      return;
+    }
+
+    const rawBody = await readRequestBody(request);
+    const result = await routeWebhook(request, rawBody, rootDir).catch((error) => {
+      console.error(`webhook error: ${error.stack ?? error.message}`);
+      return { status: 500, body: { error: error.message } };
+    });
+
+    response.writeHead(result.status, { "Content-Type": "application/json" });
+    response.end(JSON.stringify(result.body));
+
+    if (processJobs && result.body?.queued && result.body.jobId) {
+      setImmediate(() => {
+        processJob(result.body.jobId, { rootDir }).catch((error) => {
+          console.error(`job ${result.body.jobId} failed: ${error.stack ?? error.message}`);
+        });
+      });
+    }
+  });
+
+  server.listen(port, host);
+  return server;
+}
+
+function routeWebhook(request, rawBody, rootDir) {
+  if (request.url === "/github/webhook") {
+    return handleGitHubWebhook({
+      event: request.headers["x-github-event"],
+      delivery: request.headers["x-github-delivery"],
+      signature: request.headers["x-hub-signature-256"],
+      rawBody,
+    }, rootDir);
+  }
+
+  return handleSlackWebhook({
+    signature: request.headers["x-slack-signature"],
+    timestamp: request.headers["x-slack-request-timestamp"],
+    rawBody,
+  }, rootDir);
+}
+
+function readRequestBody(request) {
+  return new Promise((resolve, reject) => {
+    const chunks = [];
+    request.on("data", (chunk) => chunks.push(chunk));
+    request.on("error", reject);
+    request.on("end", () => resolve(Buffer.concat(chunks).toString("utf8")));
+  });
+}