@arungeorgesaji/assembly 0.1.0

package/src/github.js

@@ -0,0 +1,261 @@
+import { execFile } from "node:child_process";
+import { readFile, writeFile } from "node:fs/promises";
+import path from "node:path";
+import { promisify } from "node:util";
+
+import { getRunDir, readRun } from "./run-store.js";
+import { validateChangedFilesWithinScope } from "./scope.js";
+
+const execFileAsync = promisify(execFile);
+
+export async function createGitHubPullRequest(runId, { rootDir = process.cwd(), exec = execFileAsync } = {}) {
+  const run = await readRun(runId, rootDir);
+  const changedFiles = getRunOwnedChangedFiles(run);
+  await validateRunReadyForPullRequest(run, changedFiles, rootDir, exec);
+
+  const startingBranch = await getCurrentBranch(rootDir, exec);
+  const branchName = `assembly/${runId}`;
+  const title = `Assembly: ${run.request.request}`;
+  const reportPath = path.join(getRunDir(runId, rootDir), "final-report.md");
+  const report = await readFile(reportPath, "utf8");
+  const body = buildGitHubPullRequestBody(report, {
+    runId,
+    branchName,
+  });
+  const bodyPath = path.join(getRunDir(runId, rootDir), "github-pr-body.md");
+  await writeFile(bodyPath, body);
+
+  try {
+    await exec("git", ["checkout", "-B", branchName], { cwd: rootDir });
+    await exec("git", ["add", "--", ...changedFiles], { cwd: rootDir });
+    await exec("git", ["commit", "-m", title], { cwd: rootDir });
+    await exec("git", ["push", "-u", "origin", branchName], { cwd: rootDir });
+
+    const { stdout } = await exec(
+      "gh",
+      ["pr", "create", "--title", title, "--body-file", bodyPath],
+      { cwd: rootDir },
+    );
+
+    return {
+      runId,
+      branchName,
+      title,
+      url: stdout.trim(),
+      restoredBranch: startingBranch,
+    };
+  } finally {
+    if (startingBranch) {
+      await exec("git", ["checkout", startingBranch], { cwd: rootDir });
+    }
+  }
+}
+
+export async function updateGitHubPullRequestFromRun(
+  runId,
+  { rootDir = process.cwd(), branchName, prNumber, commentUrl, exec = execFileAsync } = {},
+) {
+  const run = await readRun(runId, rootDir);
+  const changedFiles = getRunOwnedChangedFiles(run);
+  await validateRunReadyForPullRequest(run, changedFiles, rootDir, exec);
+
+  if (!branchName) {
+    throw new Error("branchName is required to update a pull request");
+  }
+
+  await exec("git", ["add", "--", ...changedFiles], { cwd: rootDir });
+  await exec("git", ["commit", "-m", `Assembly follow-up: ${getRunTitleText(run)}`], { cwd: rootDir });
+  await exec("git", ["push", "origin", branchName], { cwd: rootDir });
+
+  const reportPath = path.join(getRunDir(runId, rootDir), "final-report.md");
+  const report = await readFile(reportPath, "utf8");
+  const bodyPath = path.join(getRunDir(runId, rootDir), "github-pr-body.md");
+  const prBody = buildGitHubPullRequestBody(report, {
+    runId,
+    branchName,
+    parentRunId: run.request.parentRunId,
+  });
+  await writeFile(bodyPath, prBody);
+  await exec("gh", ["pr", "edit", String(prNumber ?? branchName), "--body-file", bodyPath], { cwd: rootDir });
+
+  const body = [`Assembly handled this feedback with run ${runId}.`, "", report].join("\n");
+
+  if (commentUrl) {
+    await exec("gh", ["pr", "comment", "--body", body], { cwd: rootDir });
+  }
+
+  return {
+    runId,
+    branchName,
+    prNumber,
+    commentUrl,
+  };
+}
+
+function getRunTitleText(run) {
+  const title = run.request.followUpFeedback ?? run.request.request;
+  if (typeof title === "string") {
+    return title;
+  }
+  return JSON.stringify(title);
+}
+
+export async function validateRunReadyForPullRequest(run, changedFiles, rootDir, exec) {
+  if (run.state.status !== "complete") {
+    throw new Error(`run ${run.state.runId} must be complete before creating a pull request`);
+  }
+
+  if (changedFiles.length === 0) {
+    throw new Error(`run ${run.state.runId} has no owned changed files to commit`);
+  }
+
+  const scopeErrors = validateRunChangedFileScopes(run, changedFiles);
+  if (scopeErrors.length > 0) {
+    throw new Error(scopeErrors.join("\n"));
+  }
+
+  if (hasFailedVerification(run)) {
+    throw new Error(`run ${run.state.runId} has failed verification`);
+  }
+
+  if (!hasCompletedReview(run)) {
+    throw new Error(`run ${run.state.runId} does not have a completed review`);
+  }
+
+  const dirtyFiles = await getDirtyFiles(rootDir, exec);
+  const unrelatedDirtyFiles = dirtyFiles.filter((file) => !changedFiles.includes(file));
+  if (unrelatedDirtyFiles.length > 0) {
+    throw new Error(`working tree has unrelated changes: ${unrelatedDirtyFiles.join(", ")}`);
+  }
+
+  const finalDiffFiles = await getFinalDiffFiles(rootDir, exec);
+  const unownedDiffFiles = finalDiffFiles.filter((file) => !changedFiles.includes(file));
+  if (unownedDiffFiles.length > 0) {
+    throw new Error(`final diff includes files not owned by run ${run.state.runId}: ${unownedDiffFiles.join(", ")}`);
+  }
+}
+
+export function getRunOwnedChangedFiles(run) {
+  const files = new Set();
+  for (const event of run.events) {
+    if (!["task.complete", "files.updated", "patch.applied"].includes(event.type)) {
+      continue;
+    }
+    for (const file of event.data?.changedFiles ?? []) {
+      files.add(file);
+    }
+  }
+  return [...files].sort();
+}
+
+function validateRunChangedFileScopes(run, changedFiles) {
+  const errors = [];
+  const taskById = new Map(run.plan.tasks.map((task) => [task.id, task]));
+
+  for (const event of run.events) {
+    if (!["task.complete", "files.updated", "patch.applied"].includes(event.type)) {
+      continue;
+    }
+
+    const task = taskById.get(event.taskId);
+    if (!task) {
+      continue;
+    }
+
+    const eventChangedFiles = (event.data?.changedFiles ?? []).filter((file) => changedFiles.includes(file));
+    errors.push(...validateChangedFilesWithinScope(task, eventChangedFiles));
+  }
+
+  return errors;
+}
+
+function hasFailedVerification(run) {
+  return run.events
+    .filter((event) => event.type === "verification.completed")
+    .some((event) => event.data.results.some((result) => result.exitCode !== 0));
+}
+
+function hasCompletedReview(run) {
+  return run.events.some((event) => {
+    if (event.type !== "task.complete") {
+      return false;
+    }
+    const task = run.plan.tasks.find((candidate) => candidate.id === event.taskId);
+    return task?.owner === "review-agent" && event.data?.status === "complete";
+  });
+}
+
+async function getDirtyFiles(rootDir, exec) {
+  const { stdout } = await exec("git", ["status", "--porcelain"], { cwd: rootDir });
+  return stdout
+    .split("\n")
+    .map((line) => line.trimEnd())
+    .filter(Boolean)
+    .flatMap((line) => parsePorcelainChangedFiles(line))
+    .sort();
+}
+
+async function getFinalDiffFiles(rootDir, exec) {
+  const { stdout } = await exec("git", ["diff", "--name-only", "HEAD"], { cwd: rootDir });
+  return stdout
+    .split("\n")
+    .map((line) => line.trim())
+    .filter(Boolean)
+    .sort();
+}
+
+function parsePorcelainChangedFiles(line) {
+  const pathText = line.slice(3);
+  if (line.startsWith("R ") || line.startsWith(" R") || line.startsWith("RM") || line.startsWith("AM")) {
+    const [from, to] = pathText.split(" -> ");
+    return [from, to].filter(Boolean);
+  }
+  return [pathText];
+}
+
+export async function getGitHubComment(commentId, { rootDir = process.cwd(), exec = execFileAsync } = {}) {
+  const { stdout } = await exec(
+    "gh",
+    ["api", `repos/{owner}/{repo}/issues/comments/${commentId}`],
+    { cwd: rootDir },
+  );
+  const comment = JSON.parse(stdout);
+  return {
+    id: String(comment.id),
+    body: comment.body,
+    url: comment.html_url,
+  };
+}
+
+export async function getGitHubPullRequest(prNumber, { rootDir = process.cwd(), exec = execFileAsync } = {}) {
+  const { stdout } = await exec(
+    "gh",
+    ["pr", "view", String(prNumber), "--json", "body,headRefName"],
+    { cwd: rootDir },
+  );
+  const pr = JSON.parse(stdout);
+  return {
+    number: Number(prNumber),
+    body: pr.body ?? "",
+    branchName: pr.headRefName,
+    runId: extractAssemblyMetadata(pr.body ?? "").runId,
+  };
+}
+
+export function extractAssemblyMetadata(body) {
+  const metadata = {};
+  for (const match of String(body ?? "").matchAll(/<!--\s*assembly:([a-zA-Z0-9_-]+)=([^>]+?)\s*-->/g)) {
+    metadata[match[1]] = match[2].trim();
+  }
+  return metadata;
+}
+
+export function buildGitHubPullRequestBody(body, metadata) {
+  const lines = Object.entries(metadata).map(([key, value]) => `<!-- assembly:${key}=${value} -->`);
+  return [...lines, "", body].join("\n");
+}
+
+async function getCurrentBranch(rootDir, exec) {
+  const { stdout } = await exec("git", ["branch", "--show-current"], { cwd: rootDir });
+  return stdout.trim();
+}

package/src/init.js

@@ -0,0 +1,91 @@
+import { mkdir, readFile, writeFile } from "node:fs/promises";
+import path from "node:path";
+
+const DEFAULT_ENV = [
+  "ASSEMBLY_AGENT_PROVIDER=stub",
+  "ASSEMBLY_APPROVAL_MODE=auto",
+  "OPENAI_API_KEY=",
+  "OPENAI_MODEL=gpt-4.1-mini",
+  "GITHUB_WEBHOOK_SECRET=",
+  "SLACK_SIGNING_SECRET=",
+  "SLACK_BOT_TOKEN=",
+  "",
+].join("\n");
+
+export async function initializeAssembly({ rootDir = process.cwd(), force = false } = {}) {
+  await mkdir(path.join(rootDir, ".assembly"), { recursive: true });
+
+  const envPath = path.join(rootDir, ".env");
+  const existingEnv = await readFile(envPath, "utf8").catch((error) => {
+    if (error.code === "ENOENT") {
+      return null;
+    }
+    throw error;
+  });
+
+  if (existingEnv !== null && !force) {
+    return {
+      rootDir,
+      createdEnv: false,
+      createdStateDir: true,
+      nextSteps: [
+        ".env already exists; no values were overwritten.",
+        "Run `assembly doctor` to see missing setup.",
+      ],
+    };
+  }
+
+  const envContents = existingEnv === null ? DEFAULT_ENV : mergeEnvDefaults(existingEnv);
+  await writeFile(envPath, envContents);
+
+  return {
+    rootDir,
+    createdEnv: existingEnv === null,
+    updatedEnv: existingEnv !== null,
+    createdStateDir: true,
+    nextSteps: [
+      "Fill in .env values for OpenAI, GitHub webhooks, and Slack.",
+      "Run `assembly doctor` to verify setup.",
+      "Run `assembly webhook --port 3000` when doctor passes.",
+    ],
+  };
+}
+
+export function formatInitResult(result) {
+  const lines = [
+    `Initialized Assembly in ${result.rootDir}`,
+    result.createdEnv ? "Created .env" : result.updatedEnv ? "Updated .env with missing defaults" : "Kept existing .env",
+    "Ensured .assembly/ exists",
+    "",
+    "Next steps:",
+    ...result.nextSteps.map((step) => `- ${step}`),
+    "",
+  ];
+  return lines.join("\n");
+}
+
+function mergeEnvDefaults(existingEnv) {
+  const existingKeys = new Set(
+    existingEnv
+      .split(/\r?\n/)
+      .map((line) => line.trim())
+      .filter((line) => line && !line.startsWith("#") && line.includes("="))
+      .map((line) => line.slice(0, line.indexOf("=")).trim()),
+  );
+  const missingLines = DEFAULT_ENV
+    .split("\n")
+    .filter((line) => {
+      if (!line.trim()) {
+        return false;
+      }
+      const key = line.slice(0, line.indexOf("=")).trim();
+      return !existingKeys.has(key);
+    });
+
+  if (missingLines.length === 0) {
+    return existingEnv.endsWith("\n") ? existingEnv : `${existingEnv}\n`;
+  }
+
+  const separator = existingEnv.endsWith("\n") ? "" : "\n";
+  return `${existingEnv}${separator}\n# Assembly defaults\n${missingLines.join("\n")}\n`;
+}

package/src/job-store.js

@@ -0,0 +1,97 @@
+import { mkdir, readFile, readdir, writeFile } from "node:fs/promises";
+import path from "node:path";
+
+const JOBS_DIR = ".assembly/jobs";
+
+export function createJobId(date = new Date()) {
+  const timestamp = date.toISOString().replaceAll(":", "").replace(/\.\d{3}Z$/, "Z");
+  const suffix = Math.random().toString(36).slice(2, 8);
+  return `${timestamp}-${suffix}`;
+}
+
+export async function enqueueJob(job, rootDir = process.cwd()) {
+  const jobId = job.id ?? createJobId();
+  const queuedJob = {
+    id: jobId,
+    status: "queued",
+    createdAt: new Date().toISOString(),
+    updatedAt: new Date().toISOString(),
+    ...job,
+    id: jobId,
+  };
+  await writeJob(queuedJob, rootDir);
+  return queuedJob;
+}
+
+export async function readJob(jobId, rootDir = process.cwd()) {
+  return JSON.parse(await readFile(getJobPath(jobId, rootDir), "utf8"));
+}
+
+export async function listJobs(rootDir = process.cwd()) {
+  let entries;
+  try {
+    entries = await readdir(path.join(rootDir, JOBS_DIR));
+  } catch (error) {
+    if (error.code === "ENOENT") {
+      return [];
+    }
+    throw error;
+  }
+
+  const jobs = await Promise.all(
+    entries
+      .filter((entry) => entry.endsWith(".json"))
+      .map(async (entry) => JSON.parse(await readFile(path.join(rootDir, JOBS_DIR, entry), "utf8"))),
+  );
+  return jobs.sort((a, b) => String(b.createdAt).localeCompare(String(a.createdAt)));
+}
+
+export async function findJobByDelivery(delivery, rootDir = process.cwd()) {
+  if (!delivery) {
+    return null;
+  }
+  const jobs = await listJobs(rootDir);
+  return jobs.find((job) => job.delivery === delivery) ?? null;
+}
+
+export async function updateJob(jobId, updates, rootDir = process.cwd()) {
+  const job = await readJob(jobId, rootDir);
+  const updatedJob = {
+    ...job,
+    ...updates,
+    updatedAt: new Date().toISOString(),
+  };
+  await writeJob(updatedJob, rootDir);
+  return updatedJob;
+}
+
+export async function resetJobForRetry(jobId, rootDir = process.cwd()) {
+  const job = await readJob(jobId, rootDir);
+  const retryCount = (job.retryCount ?? 0) + 1;
+  const retriedAt = new Date().toISOString();
+  const resetJob = {
+    ...job,
+    status: "queued",
+    retryCount,
+    retriedAt,
+    updatedAt: retriedAt,
+  };
+
+  delete resetJob.startedAt;
+  delete resetJob.completedAt;
+  delete resetJob.failedAt;
+  delete resetJob.error;
+  delete resetJob.result;
+
+  await writeJob(resetJob, rootDir);
+  return resetJob;
+}
+
+async function writeJob(job, rootDir) {
+  await mkdir(path.join(rootDir, JOBS_DIR), { recursive: true });
+  await writeFile(getJobPath(job.id, rootDir), `${JSON.stringify(job, null, 2)}\n`);
+}
+
+function getJobPath(jobId, rootDir) {
+  return path.join(rootDir, JOBS_DIR, `${jobId}.json`);
+}