@arungeorgesaji/assembly 0.1.0

package/src/doctor.js

@@ -0,0 +1,151 @@
+import { execFile } from "node:child_process";
+import { access } from "node:fs/promises";
+import path from "node:path";
+import { promisify } from "node:util";
+
+const VALID_AGENT_PROVIDERS = new Set(["stub", "openai"]);
+const VALID_APPROVAL_MODES = new Set(["auto", "manual", "never"]);
+const execFileAsync = promisify(execFile);
+
+export async function runDoctor({ rootDir = process.cwd(), env = process.env, exec = execFileAsync } = {}) {
+  const checks = [];
+  const envPath = path.join(rootDir, ".env");
+
+  checks.push(await checkTargetRepository(rootDir, exec));
+  checks.push(await checkEnvFile(envPath));
+  checks.push(checkAgentProvider(env));
+  checks.push(checkOpenAI(env));
+  checks.push(checkApprovalMode(env));
+  checks.push(checkRequiredEnv("GITHUB_WEBHOOK_SECRET", env, "Required for GitHub webhook signature verification."));
+  checks.push(await checkGitHubAuth(env, exec));
+  checks.push(checkRequiredEnv("SLACK_SIGNING_SECRET", env, "Required for Slack request signature verification."));
+  checks.push(checkRequiredEnv("SLACK_BOT_TOKEN", env, "Required so Assembly can reply in Slack threads."));
+
+  return {
+    ok: !checks.some((check) => check.status === "fail"),
+    checks,
+  };
+}
+
+export function formatDoctorReport(report) {
+  const rows = report.checks.map((check) => [
+    check.status.toUpperCase(),
+    check.name,
+    check.message,
+  ]);
+  const headers = ["STATUS", "CHECK", "DETAIL"];
+  const widths = headers.map((header, index) => Math.max(header.length, ...rows.map((row) => row[index].length)));
+  const formatRow = (row) => row.map((value, index) => value.padEnd(widths[index])).join("  ");
+
+  return [
+    "Assembly doctor",
+    "",
+    formatRow(headers),
+    formatRow(widths.map((width) => "-".repeat(width))),
+    ...rows.map(formatRow),
+    "",
+    report.ok ? "Ready: required setup is present." : "Not ready: fix the failed checks above.",
+    "",
+  ].join("\n");
+}
+
+async function checkEnvFile(envPath) {
+  try {
+    await access(envPath);
+    return pass(".env", "Found local .env file.");
+  } catch {
+    return warn(".env", "No .env file found; using process environment only.");
+  }
+}
+
+async function checkTargetRepository(rootDir, exec) {
+  try {
+    const { stdout } = await exec("git", ["rev-parse", "--show-toplevel"], { cwd: rootDir });
+    const gitRoot = path.resolve(stdout.trim());
+    const targetRoot = path.resolve(rootDir);
+    if (gitRoot !== targetRoot) {
+      return warn("Target repository", `Using ${targetRoot}, but Git root is ${gitRoot}. Run from the repo root or pass --repo.`);
+    }
+    return pass("Target repository", `Git repository at ${targetRoot}.`);
+  } catch {
+    return fail("Target repository", "Run from a Git repository or pass --repo <path>.");
+  }
+}
+
+function checkAgentProvider(env) {
+  const provider = env.ASSEMBLY_AGENT_PROVIDER || "stub";
+  if (!VALID_AGENT_PROVIDERS.has(provider)) {
+    return fail("ASSEMBLY_AGENT_PROVIDER", `Unsupported provider "${provider}". Use stub or openai.`);
+  }
+  if (provider === "stub") {
+    return warn("ASSEMBLY_AGENT_PROVIDER", "Using stub provider; real code editing needs ASSEMBLY_AGENT_PROVIDER=openai.");
+  }
+  return pass("ASSEMBLY_AGENT_PROVIDER", "OpenAI provider enabled.");
+}
+
+function checkOpenAI(env) {
+  const provider = env.ASSEMBLY_AGENT_PROVIDER || "stub";
+  if (provider !== "openai") {
+    return warn("OPENAI_API_KEY", "Skipped because ASSEMBLY_AGENT_PROVIDER is not openai.");
+  }
+  if (!env.OPENAI_API_KEY) {
+    return fail("OPENAI_API_KEY", "Required when ASSEMBLY_AGENT_PROVIDER=openai.");
+  }
+  if (!env.OPENAI_API_KEY.startsWith("sk-")) {
+    return warn("OPENAI_API_KEY", "Present, but it does not look like an OpenAI secret key.");
+  }
+  return pass("OPENAI_API_KEY", `Present. Model: ${env.OPENAI_MODEL || "gpt-4.1-mini"}.`);
+}
+
+function checkApprovalMode(env) {
+  const mode = env.ASSEMBLY_APPROVAL_MODE || "auto";
+  if (!VALID_APPROVAL_MODES.has(mode)) {
+    return fail("ASSEMBLY_APPROVAL_MODE", `Unsupported mode "${mode}". Use auto, manual, or never.`);
+  }
+  return pass("ASSEMBLY_APPROVAL_MODE", `Using ${mode}.`);
+}
+
+function checkRequiredEnv(name, env, missingMessage) {
+  if (!env[name]) {
+    return fail(name, missingMessage);
+  }
+  return pass(name, "Present.");
+}
+
+async function checkGitHubAuth(env, exec) {
+  if (env.GH_TOKEN || env.GITHUB_TOKEN) {
+    return pass("GitHub auth", "Token environment variable present.");
+  }
+  try {
+    await exec("gh", ["auth", "status"]);
+    return pass("GitHub auth", "`gh auth status` is authenticated.");
+  } catch (error) {
+    if (error.code === "ENOENT") {
+      return fail("GitHub auth", "GitHub CLI not found; install `gh` or set GH_TOKEN/GITHUB_TOKEN.");
+    }
+    return fail("GitHub auth", summarizeGitHubAuthError(error));
+  }
+}
+
+function summarizeGitHubAuthError(error) {
+  const output = `${error.stdout ?? ""}\n${error.stderr ?? ""}`;
+  if (/gh auth refresh/i.test(output)) {
+    return "`gh auth status` reports an invalid token. Run `gh auth refresh -h github.com` or set GH_TOKEN/GITHUB_TOKEN.";
+  }
+  if (/not logged into|not logged in|not authenticated/i.test(output)) {
+    return "`gh auth status` is not authenticated. Run `gh auth login` or set GH_TOKEN/GITHUB_TOKEN.";
+  }
+  return "`gh auth status` failed. Run `gh auth status` for details or set GH_TOKEN/GITHUB_TOKEN.";
+}
+
+function pass(name, message) {
+  return { status: "pass", name, message };
+}
+
+function warn(name, message) {
+  return { status: "warn", name, message };
+}
+
+function fail(name, message) {
+  return { status: "fail", name, message };
+}

package/src/file-updates.js

@@ -0,0 +1,89 @@
+import { mkdir, readFile, writeFile } from "node:fs/promises";
+import path from "node:path";
+
+import { validateChangedFilesWithinScope } from "./scope.js";
+
+export function validateFileUpdatesForTask(task, result) {
+  const errors = [];
+
+  if (result.fileUpdates === undefined) {
+    return errors;
+  }
+  if (!Array.isArray(result.fileUpdates)) {
+    return [`task ${task.id} result fileUpdates must be an array when provided`];
+  }
+
+  const updatePaths = [];
+  for (const update of result.fileUpdates) {
+    if (!update || typeof update !== "object" || Array.isArray(update)) {
+      errors.push(`task ${task.id} fileUpdates entries must be objects`);
+      continue;
+    }
+    if (typeof update.path !== "string" || update.path.trim() === "") {
+      errors.push(`task ${task.id} fileUpdates entry must include a path`);
+      continue;
+    }
+    if (typeof update.content !== "string") {
+      errors.push(`task ${task.id} fileUpdates entry for ${update.path} must include string content`);
+      continue;
+    }
+    updatePaths.push(update.path);
+  }
+
+  errors.push(...validateChangedFilesWithinScope(task, updatePaths));
+
+  const declaredFiles = new Set(result.changedFiles);
+  for (const updatePath of updatePaths) {
+    if (!declaredFiles.has(updatePath)) {
+      errors.push(`task ${task.id} updates ${updatePath} but result.changedFiles does not list it`);
+    }
+  }
+
+  return errors;
+}
+
+export async function applyFileUpdates(fileUpdates, rootDir = process.cwd()) {
+  for (const update of fileUpdates) {
+    const destination = path.join(rootDir, update.path);
+    await mkdir(path.dirname(destination), { recursive: true });
+    await writeFile(destination, update.content);
+  }
+}
+
+export async function validateAdditiveFileUpdates(task, result, rootDir = process.cwd()) {
+  if (task.changePolicy !== "additive" || !Array.isArray(result.fileUpdates)) {
+    return [];
+  }
+
+  const errors = [];
+  for (const update of result.fileUpdates) {
+    const original = await readFile(path.join(rootDir, update.path), "utf8").catch(() => null);
+    if (original === null) {
+      continue;
+    }
+
+    if (!isLineSubsequence(original, update.content)) {
+      errors.push(`task ${task.id} additive update for ${update.path} removes or rewrites existing lines`);
+    }
+  }
+
+  return errors;
+}
+
+function isLineSubsequence(originalContent, updatedContent) {
+  const originalLines = originalContent.split("\n");
+  const updatedLines = updatedContent.split("\n");
+  let updatedIndex = 0;
+
+  for (const originalLine of originalLines) {
+    while (updatedIndex < updatedLines.length && updatedLines[updatedIndex] !== originalLine) {
+      updatedIndex += 1;
+    }
+    if (updatedIndex >= updatedLines.length) {
+      return false;
+    }
+    updatedIndex += 1;
+  }
+
+  return true;
+}

package/src/follow-up.js

@@ -0,0 +1,33 @@
+import { createRun } from "./orchestrator.js";
+import { readRun } from "./run-store.js";
+
+export async function createFollowUpRun(parentRunId, feedback, options = {}) {
+  const rootDir = options.rootDir ?? process.cwd();
+  const parentRun = await readRun(parentRunId, rootDir);
+  const normalizedFeedback = normalizeFeedback(feedback);
+  const request = [
+    `Follow up on run ${parentRunId}.`,
+    `Original request: ${parentRun.request.request}`,
+    `Feedback: ${normalizedFeedback}`,
+  ].join(" ");
+
+  return createRun(request, {
+    ...options,
+    rootDir,
+    metadata: {
+      parentRunId,
+      parentRequest: parentRun.request.request,
+      followUpFeedback: normalizedFeedback,
+      source: options.source ?? { provider: "local", kind: "follow_up" },
+    },
+  });
+}
+
+function normalizeFeedback(feedback) {
+  const normalized = String(feedback ?? "").trim().replace(/\s+/g, " ");
+  if (!normalized) {
+    throw new Error("follow-up feedback cannot be empty");
+  }
+  return normalized;
+}
+

package/src/git-worktree.js

@@ -0,0 +1,35 @@
+import { cp, mkdir, mkdtemp, rm } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import path from "node:path";
+
+import { getRunDir } from "./run-store.js";
+
+export async function withTemporaryGitWorktree(rootDir, exec, callback) {
+  const worktreeDir = await mkdtemp(path.join(tmpdir(), "assembly-worktree-"));
+  let created = false;
+
+  try {
+    await exec("git", ["worktree", "add", "--detach", worktreeDir, "HEAD"], { cwd: rootDir });
+    created = true;
+    return await callback(worktreeDir);
+  } finally {
+    if (created) {
+      try {
+        await exec("git", ["worktree", "remove", "--force", worktreeDir], { cwd: rootDir });
+      } catch {
+        await rm(worktreeDir, { recursive: true, force: true });
+      }
+    } else {
+      await rm(worktreeDir, { recursive: true, force: true });
+    }
+  }
+}
+
+export async function copyRunRecord(runId, fromRootDir, toRootDir) {
+  const toRunDir = getRunDir(runId, toRootDir);
+  await mkdir(path.dirname(toRunDir), { recursive: true });
+  await cp(getRunDir(runId, fromRootDir), toRunDir, {
+    recursive: true,
+    force: true,
+  });
+}

package/src/github-webhooks.js

@@ -0,0 +1,159 @@
+import { createHmac, timingSafeEqual } from "node:crypto";
+
+import { getGitHubWebhookSecret } from "./config.js";
+import { enqueueJob, findJobByDelivery } from "./job-store.js";
+
+export function verifyGitHubSignature(rawBody, signature, secret = getGitHubWebhookSecret()) {
+  if (!secret) {
+    throw new Error("GITHUB_WEBHOOK_SECRET is required for webhook verification");
+  }
+  if (!signature?.startsWith("sha256=")) {
+    return false;
+  }
+
+  const expected = `sha256=${createHmac("sha256", secret).update(rawBody).digest("hex")}`;
+  const expectedBuffer = Buffer.from(expected);
+  const actualBuffer = Buffer.from(signature);
+  return expectedBuffer.length === actualBuffer.length && timingSafeEqual(expectedBuffer, actualBuffer);
+}
+
+export async function handleGitHubWebhook({ event, delivery, signature, rawBody }, rootDir = process.cwd()) {
+  if (!verifyGitHubSignature(rawBody, signature)) {
+    return { status: 401, body: { error: "invalid signature" } };
+  }
+
+  let payload;
+  try {
+    payload = JSON.parse(rawBody);
+  } catch {
+    return { status: 400, body: { error: "invalid JSON payload" } };
+  }
+  const normalized = normalizeGitHubWebhook(event, payload);
+  if (normalized.ignored) {
+    return { status: 202, body: normalized };
+  }
+
+  const existingJob = await findJobByDelivery(delivery, rootDir);
+  if (existingJob) {
+    return { status: 202, body: { queued: false, duplicate: true, jobId: existingJob.id } };
+  }
+
+  const job = await enqueueJob({
+    type: normalized.type,
+    delivery,
+    payload: normalized.payload,
+  }, rootDir);
+
+  return { status: 202, body: { queued: true, jobId: job.id } };
+}
+
+export function normalizeGitHubWebhook(event, payload) {
+  if (event === "issue_comment" && payload.action === "created") {
+    const body = payload.comment?.body ?? "";
+    if (!mentionsAssembly(body)) {
+      return { ignored: true, reason: "comment does not mention @assembly" };
+    }
+
+    if (payload.issue?.pull_request) {
+      return {
+        type: "github.pr_feedback",
+        payload: {
+          kind: "issue_comment",
+          commentId: String(payload.comment.id),
+          feedback: body,
+          commentUrl: payload.comment.html_url,
+          prNumber: payload.issue.number,
+        },
+      };
+    }
+
+    return {
+      type: "github.issue_request",
+      payload: {
+        kind: "issue_comment",
+        issueNumber: payload.issue.number,
+        issueTitle: payload.issue.title ?? "",
+        issueBody: payload.issue.body ?? "",
+        feedback: body,
+        url: payload.comment.html_url,
+      },
+    };
+  }
+
+  if (event === "pull_request_review_comment" && payload.action === "created") {
+    const body = payload.comment?.body ?? "";
+    if (!mentionsAssembly(body)) {
+      return { ignored: true, reason: "comment does not mention @assembly" };
+    }
+
+    return {
+      type: "github.pr_feedback",
+      payload: {
+        kind: "pull_request_review_comment",
+        commentId: String(payload.comment.id),
+        feedback: formatInlineCommentFeedback(payload.comment),
+        commentUrl: payload.comment.html_url,
+        prNumber: payload.pull_request.number,
+        path: payload.comment.path,
+        line: payload.comment.line ?? payload.comment.original_line,
+        diffHunk: payload.comment.diff_hunk,
+      },
+    };
+  }
+
+  if (event === "pull_request_review" && payload.action === "submitted") {
+    const body = payload.review?.body ?? "";
+    if (!mentionsAssembly(body)) {
+      return { ignored: true, reason: "review does not mention @assembly" };
+    }
+
+    return {
+      type: "github.pr_feedback",
+      payload: {
+        kind: "pull_request_review",
+        reviewId: String(payload.review.id),
+        feedback: body,
+        commentUrl: payload.review.html_url,
+        prNumber: payload.pull_request.number,
+        reviewState: payload.review.state,
+      },
+    };
+  }
+
+  if (event === "issues" && ["opened", "edited"].includes(payload.action)) {
+    if (payload.issue?.pull_request) {
+      return { ignored: true, reason: "issue event is for a pull request" };
+    }
+
+    const requestText = [payload.issue?.title, payload.issue?.body].filter(Boolean).join("\n\n");
+    if (!mentionsAssembly(requestText)) {
+      return { ignored: true, reason: "issue does not mention @assembly" };
+    }
+
+    return {
+      type: "github.issue_request",
+      payload: {
+        kind: `issues.${payload.action}`,
+        issueNumber: payload.issue.number,
+        issueTitle: payload.issue.title ?? "",
+        issueBody: payload.issue.body ?? "",
+        feedback: requestText,
+        url: payload.issue.html_url,
+      },
+    };
+  }
+
+  return { ignored: true, reason: "unsupported event" };
+}
+
+function mentionsAssembly(text) {
+  return /(^|\s)@assembly\b/i.test(text ?? "");
+}
+
+function formatInlineCommentFeedback(comment) {
+  return [
+    `Inline review comment on ${comment.path}${comment.line ? `:${comment.line}` : ""}.`,
+    comment.diff_hunk ? `Diff hunk:\n${comment.diff_hunk}` : "",
+    `Feedback: ${comment.body}`,
+  ].filter(Boolean).join("\n\n");
+}