@arungeorgesaji/assembly 0.1.0

package/src/approval.js

@@ -0,0 +1,45 @@
+import { getApprovalMode } from "./config.js";
+
+const VALID_APPROVAL_MODES = new Set(["auto", "manual", "never"]);
+
+export function resolveApproval({ task, result, mode = getApprovalMode() }) {
+  if (!VALID_APPROVAL_MODES.has(mode)) {
+    return {
+      approved: false,
+      status: "failed",
+      reason: `unknown ASSEMBLY_APPROVAL_MODE: ${mode}`,
+    };
+  }
+
+  const hasEdits = Boolean(result.patch) || result.fileUpdates?.length > 0;
+  if (!hasEdits || result.status !== "complete") {
+    return {
+      approved: true,
+      status: "approved",
+      reason: "No edits require approval.",
+    };
+  }
+
+  if (mode === "auto") {
+    return {
+      approved: true,
+      status: "approved",
+      reason: "Auto approval mode approved validated edits.",
+    };
+  }
+
+  if (mode === "never") {
+    return {
+      approved: false,
+      status: "dry_run",
+      reason: "Approval mode never records edits without applying them.",
+    };
+  }
+
+  return {
+    approved: false,
+    status: "pending",
+    reason: `Manual approval required before applying edits for task ${task.id}.`,
+  };
+}
+

package/src/cli.js

@@ -0,0 +1,381 @@
+#!/usr/bin/env node
+
+import { realpathSync } from "node:fs";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+
+import { createPlan } from "./planner.js";
+import { createRun } from "./orchestrator.js";
+import { createFollowUpRun } from "./follow-up.js";
+import { createGitHubPullRequest, getGitHubComment } from "./github.js";
+import { formatInitResult, initializeAssembly } from "./init.js";
+import { processJob } from "./job-worker.js";
+import { listJobs, readJob, resetJobForRetry } from "./job-store.js";
+import { readRun } from "./run-store.js";
+import { startWebhookServer } from "./webhook-server.js";
+import { loadEnv } from "./config.js";
+import { formatDoctorReport, runDoctor } from "./doctor.js";
+import { parseGlobalOptions, resolveRootDir } from "./root.js";
+import { validatePlan } from "./validation.js";
+
+export async function main(argv = process.argv.slice(2), io = process) {
+  const { args: resolvedArgv, repo, errors } = parseGlobalOptions(argv);
+  if (errors.length > 0) {
+    for (const error of errors) {
+      io.stderr.write(`error: ${error}\n`);
+    }
+    io.stderr.write("usage: assembly [--repo <path>] <init|plan|run|follow-up|status|inspect|github|job|webhook|doctor> ...\n");
+    return 2;
+  }
+  const rootDir = await resolveRootDir({ repo });
+  await loadEnv(rootDir);
+  const [command, ...args] = resolvedArgv;
+
+  if (!["init", "plan", "run", "follow-up", "status", "inspect", "github", "job", "webhook", "doctor"].includes(command)) {
+    io.stderr.write("usage: assembly [--repo <path>] <init|plan|run|follow-up|status|inspect|github|job|webhook|doctor> ...\n");
+    return 2;
+  }
+
+  if (command === "init") {
+    return handleInit(args, io, rootDir);
+  }
+  if (command === "plan") {
+    return handlePlan(args, io, rootDir);
+  }
+  if (command === "run") {
+    return handleRun(args, io, rootDir);
+  }
+  if (command === "follow-up") {
+    return handleFollowUp(args, io, rootDir);
+  }
+  if (command === "status") {
+    return handleStatus(args, io, rootDir);
+  }
+  if (command === "inspect") {
+    return handleInspect(args, io, rootDir);
+  }
+  if (command === "github") {
+    return handleGitHub(args, io, rootDir);
+  }
+  if (command === "job") {
+    return handleJob(args, io, rootDir);
+  }
+  if (command === "doctor") {
+    return handleDoctor(args, io, rootDir);
+  }
+  return handleWebhook(args, io, rootDir);
+}
+
+async function handleInit(args, io, rootDir) {
+  const json = args.includes("--json");
+  const force = args.includes("--force");
+  const unknown = args.filter((arg) => !["--json", "--force"].includes(arg));
+  if (unknown.length > 0) {
+    io.stderr.write("usage: assembly init [--force] [--json]\n");
+    return 2;
+  }
+
+  try {
+    const result = await initializeAssembly({ rootDir, force });
+    io.stdout.write(json ? `${JSON.stringify(result, null, 2)}\n` : formatInitResult(result));
+    return 0;
+  } catch (error) {
+    io.stderr.write(`error: ${error.message}\n`);
+    return 1;
+  }
+}
+
+function handlePlan(args, io, rootDir) {
+  const pretty = args.includes("--pretty");
+  const request = args.filter((arg) => arg !== "--pretty").join(" ");
+
+  let plan;
+  try {
+    plan = createPlan(request, { rootDir });
+  } catch (error) {
+    io.stderr.write(`error: ${error.message}\n`);
+    return 2;
+  }
+
+  const errors = validatePlan(plan);
+  if (errors.length > 0) {
+    for (const error of errors) {
+      io.stderr.write(`error: ${error}\n`);
+    }
+    return 1;
+  }
+
+  io.stdout.write(`${JSON.stringify(plan, null, pretty ? 2 : 0)}\n`);
+  return 0;
+}
+
+async function handleRun(args, io, rootDir) {
+  const pretty = args.includes("--pretty");
+  const request = args.filter((arg) => arg !== "--pretty").join(" ");
+
+  try {
+    const run = await createRun(request, { rootDir });
+    io.stdout.write(`${JSON.stringify(run, null, pretty ? 2 : 0)}\n`);
+    return 0;
+  } catch (error) {
+    io.stderr.write(`error: ${error.message}\n`);
+    return 1;
+  }
+}
+
+async function handleFollowUp(args, io, rootDir) {
+  const pretty = args.includes("--pretty");
+  const filteredArgs = args.filter((arg) => arg !== "--pretty");
+  const parentRunId = filteredArgs[0];
+  const feedback = filteredArgs.slice(1).join(" ");
+
+  if (!parentRunId || !feedback) {
+    io.stderr.write("usage: assembly follow-up <run-id> <feedback> [--pretty]\n");
+    return 2;
+  }
+
+  try {
+    const run = await createFollowUpRun(parentRunId, feedback, { rootDir });
+    io.stdout.write(`${JSON.stringify(run, null, pretty ? 2 : 0)}\n`);
+    return 0;
+  } catch (error) {
+    io.stderr.write(`error: ${error.message}\n`);
+    return 1;
+  }
+}
+
+async function handleStatus(args, io, rootDir) {
+  const runId = args[0];
+  if (!runId) {
+    io.stderr.write("usage: assembly status <run-id>\n");
+    return 2;
+  }
+
+  try {
+    const run = await readRun(runId, rootDir);
+    io.stdout.write(formatStatus(run));
+    return 0;
+  } catch (error) {
+    io.stderr.write(`error: unable to read run ${runId}: ${error.message}\n`);
+    return 1;
+  }
+}
+
+async function handleInspect(args, io, rootDir) {
+  const pretty = args.includes("--pretty");
+  const runId = args.find((arg) => arg !== "--pretty");
+  if (!runId) {
+    io.stderr.write("usage: assembly inspect <run-id> [--pretty]\n");
+    return 2;
+  }
+
+  try {
+    const run = await readRun(runId, rootDir);
+    io.stdout.write(`${JSON.stringify(run, null, pretty ? 2 : 0)}\n`);
+    return 0;
+  } catch (error) {
+    io.stderr.write(`error: unable to read run ${runId}: ${error.message}\n`);
+    return 1;
+  }
+}
+
+async function handleGitHub(args, io, rootDir) {
+  const [subcommand, ...rest] = args;
+  if (subcommand === "create-pr") {
+    const runId = rest[0];
+    if (!runId) {
+      io.stderr.write("usage: assembly github create-pr <run-id>\n");
+      return 2;
+    }
+
+    try {
+      const result = await createGitHubPullRequest(runId, { rootDir });
+      io.stdout.write(`${JSON.stringify(result, null, 2)}\n`);
+      return 0;
+    } catch (error) {
+      io.stderr.write(`error: ${error.message}\n`);
+      return 1;
+    }
+  }
+
+  if (subcommand === "comment-to-follow-up") {
+    const [parentRunId, commentId] = rest;
+    if (!parentRunId || !commentId) {
+      io.stderr.write("usage: assembly github comment-to-follow-up <run-id> <comment-id>\n");
+      return 2;
+    }
+
+    try {
+      const comment = await getGitHubComment(commentId, { rootDir });
+      const run = await createFollowUpRun(parentRunId, comment.body, {
+        rootDir,
+        source: {
+          provider: "github",
+          kind: "issue_comment",
+          id: comment.id,
+          url: comment.url,
+        },
+      });
+      io.stdout.write(`${JSON.stringify(run, null, 2)}\n`);
+      return 0;
+    } catch (error) {
+      io.stderr.write(`error: ${error.message}\n`);
+      return 1;
+    }
+  }
+
+  io.stderr.write("usage: assembly github <create-pr|comment-to-follow-up> ...\n");
+  return 2;
+}
+
+async function handleJob(args, io, rootDir) {
+  const [subcommand, jobId] = args;
+  const pretty = args.includes("--pretty");
+  const json = args.includes("--json");
+
+  if (subcommand === "list") {
+    const jobs = await listJobs(rootDir);
+    if (json) {
+      io.stdout.write(`${JSON.stringify(jobs, null, pretty ? 2 : 0)}\n`);
+      return 0;
+    }
+    io.stdout.write(formatJobs(jobs));
+    return 0;
+  }
+
+  if (subcommand === "inspect" && jobId) {
+    const job = await readJob(jobId, rootDir);
+    io.stdout.write(`${JSON.stringify(job, null, pretty ? 2 : 0)}\n`);
+    return 0;
+  }
+
+  if (subcommand === "process" && jobId) {
+    const job = await processJob(jobId, { rootDir });
+    io.stdout.write(`${JSON.stringify(job, null, 2)}\n`);
+    return job.status === "failed" ? 1 : 0;
+  }
+
+  if (subcommand === "retry" && jobId) {
+    await resetJobForRetry(jobId, rootDir);
+    const job = await processJob(jobId, { rootDir });
+    io.stdout.write(`${JSON.stringify(job, null, 2)}\n`);
+    return job.status === "failed" ? 1 : 0;
+  }
+
+  if (subcommand === "retry") {
+    io.stderr.write("usage: assembly job retry <job-id>\n");
+    return 2;
+  }
+
+  io.stderr.write("usage: assembly job <list|inspect|process|retry> ...\n");
+  return 2;
+}
+
+function handleWebhook(args, io, rootDir) {
+  const portIndex = args.indexOf("--port");
+  const port = portIndex === -1 ? 3000 : Number(args[portIndex + 1]);
+  if (!Number.isInteger(port) || port <= 0) {
+    io.stderr.write("usage: assembly webhook [--port <port>]\n");
+    return 2;
+  }
+
+  const server = startWebhookServer({ port, rootDir });
+  server.on("listening", () => {
+    io.stdout.write([
+      `Assembly webhook server listening on http://127.0.0.1:${port}`,
+      `GitHub: http://127.0.0.1:${port}/github/webhook`,
+      `Slack:  http://127.0.0.1:${port}/slack/events`,
+      "",
+    ].join("\n"));
+  });
+  server.on("error", (error) => {
+    io.stderr.write(`error: unable to start webhook server: ${error.message}\n`);
+    process.exitCode = 1;
+  });
+  return 0;
+}
+
+async function handleDoctor(args, io, rootDir) {
+  const json = args.includes("--json");
+  const pretty = args.includes("--pretty");
+  const unknown = args.filter((arg) => !["--json", "--pretty"].includes(arg));
+  if (unknown.length > 0) {
+    io.stderr.write("usage: assembly doctor [--json] [--pretty]\n");
+    return 2;
+  }
+
+  const report = await runDoctor({ rootDir });
+  if (json) {
+    io.stdout.write(`${JSON.stringify(report, null, pretty ? 2 : 0)}\n`);
+  } else {
+    io.stdout.write(formatDoctorReport(report));
+  }
+  return report.ok ? 0 : 1;
+}
+
+function formatStatus({ request, state }) {
+  const taskLines = Object.entries(state.tasks)
+    .map(([taskId, task]) => `- ${task.status.padEnd(11)} ${taskId} (${task.owner})`)
+    .join("\n");
+
+  return [
+    `Run: ${state.runId}`,
+    `Status: ${state.status}`,
+    `Request: ${request.request}`,
+    "",
+    "Tasks:",
+    taskLines,
+    "",
+  ].join("\n");
+}
+
+function formatJobs(jobs) {
+  if (jobs.length === 0) {
+    return "No jobs found.\n";
+  }
+
+  const rows = jobs.map((job) => [
+    job.id,
+    job.status,
+    job.type,
+    describeJobTarget(job),
+    job.updatedAt ?? job.createdAt,
+  ]);
+  const headers = ["ID", "STATUS", "TYPE", "TARGET", "UPDATED"];
+  const widths = headers.map((header, index) => Math.max(header.length, ...rows.map((row) => String(row[index] ?? "").length)));
+  const formatRow = (row) => row.map((value, index) => String(value ?? "").padEnd(widths[index])).join("  ");
+  return [
+    formatRow(headers),
+    formatRow(widths.map((width) => "-".repeat(width))),
+    ...rows.map(formatRow),
+    "",
+  ].join("\n");
+}
+
+function describeJobTarget(job) {
+  if (job.payload?.prNumber) {
+    return `PR #${job.payload.prNumber}`;
+  }
+  if (job.payload?.issueNumber) {
+    return `Issue #${job.payload.issueNumber}`;
+  }
+  return "";
+}
+
+function isDirectExecution() {
+  if (!process.argv[1]) {
+    return false;
+  }
+  if (path.basename(process.argv[1]) === "assembly") {
+    return true;
+  }
+  try {
+    return realpathSync(fileURLToPath(import.meta.url)) === realpathSync(process.argv[1]);
+  } catch {
+    return false;
+  }
+}
+
+if (isDirectExecution()) {
+  process.exitCode = await main();
+}

package/src/config.js

@@ -0,0 +1,90 @@
+import { readFile } from "node:fs/promises";
+import path from "node:path";
+
+export async function loadEnv(rootDir = process.cwd()) {
+  const envPath = path.join(rootDir, ".env");
+  let contents;
+
+  try {
+    contents = await readFile(envPath, "utf8");
+  } catch (error) {
+    if (error.code === "ENOENT") {
+      return;
+    }
+    throw error;
+  }
+
+  for (const line of contents.split(/\r?\n/)) {
+    const parsed = parseEnvLine(line);
+    if (!parsed || process.env[parsed.key] !== undefined) {
+      continue;
+    }
+    process.env[parsed.key] = parsed.value;
+  }
+}
+
+export function getAgentProvider() {
+  return process.env.ASSEMBLY_AGENT_PROVIDER || "stub";
+}
+
+export function getApprovalMode() {
+  return process.env.ASSEMBLY_APPROVAL_MODE || "auto";
+}
+
+export function getGitHubWebhookSecret() {
+  return process.env.GITHUB_WEBHOOK_SECRET || "";
+}
+
+export function getSlackSigningSecret() {
+  return process.env.SLACK_SIGNING_SECRET || "";
+}
+
+export function getSlackBotToken() {
+  return process.env.SLACK_BOT_TOKEN || "";
+}
+
+export function getOpenAIConfig() {
+  const apiKey = process.env.OPENAI_API_KEY;
+  if (!apiKey) {
+    throw new Error("OPENAI_API_KEY is required when ASSEMBLY_AGENT_PROVIDER=openai");
+  }
+
+  return {
+    apiKey,
+    model: process.env.OPENAI_MODEL || "gpt-4.1-mini",
+    baseUrl: process.env.OPENAI_BASE_URL || "https://api.openai.com/v1",
+  };
+}
+
+function parseEnvLine(line) {
+  const trimmed = line.trim();
+  if (!trimmed || trimmed.startsWith("#")) {
+    return null;
+  }
+
+  const equalsIndex = trimmed.indexOf("=");
+  if (equalsIndex === -1) {
+    return null;
+  }
+
+  const key = trimmed.slice(0, equalsIndex).trim();
+  const rawValue = trimmed.slice(equalsIndex + 1).trim();
+  if (!/^[A-Z_][A-Z0-9_]*$/i.test(key)) {
+    return null;
+  }
+
+  return {
+    key,
+    value: unquote(rawValue),
+  };
+}
+
+function unquote(value) {
+  if (
+    (value.startsWith('"') && value.endsWith('"')) ||
+    (value.startsWith("'") && value.endsWith("'"))
+  ) {
+    return value.slice(1, -1);
+  }
+  return value;
+}

package/src/context-builder.js

@@ -0,0 +1,91 @@
+import { readdir, readFile, stat } from "node:fs/promises";
+import path from "node:path";
+
+const MAX_FILES = 24;
+const MAX_TOTAL_CHARS = 60000;
+const SKIP_DIRS = new Set([".git", ".assembly", "node_modules", "coverage", "dist", "build"]);
+
+export async function buildTaskContext(task, rootDir = process.cwd()) {
+  const candidatePaths = [...task.scope.allowlist, ...task.scope.paths];
+  const files = [];
+  let totalChars = 0;
+
+  for (const candidatePath of candidatePaths) {
+    if (files.length >= MAX_FILES || totalChars >= MAX_TOTAL_CHARS) {
+      break;
+    }
+
+    const discovered = await discoverFiles(rootDir, candidatePath);
+    for (const filePath of discovered) {
+      if (files.length >= MAX_FILES || totalChars >= MAX_TOTAL_CHARS) {
+        break;
+      }
+
+      const content = await readFile(path.join(rootDir, filePath), "utf8").catch(() => null);
+      if (content === null) {
+        continue;
+      }
+
+      const remainingChars = MAX_TOTAL_CHARS - totalChars;
+      const truncatedContent = content.slice(0, remainingChars);
+      files.push({
+        path: filePath,
+        content: truncatedContent,
+        truncated: truncatedContent.length < content.length,
+      });
+      totalChars += truncatedContent.length;
+    }
+  }
+
+  return {
+    files,
+    limits: {
+      maxFiles: MAX_FILES,
+      maxTotalChars: MAX_TOTAL_CHARS,
+      truncated: files.length >= MAX_FILES || totalChars >= MAX_TOTAL_CHARS,
+    },
+  };
+}
+
+async function discoverFiles(rootDir, scopePath) {
+  const normalized = scopePath.replaceAll("\\", "/");
+  const absolutePath = path.join(rootDir, normalized);
+  const stats = await stat(absolutePath).catch(() => null);
+  if (!stats) {
+    return [];
+  }
+
+  if (stats.isFile()) {
+    return [normalized];
+  }
+
+  if (!stats.isDirectory()) {
+    return [];
+  }
+
+  return walkDirectory(rootDir, normalized);
+}
+
+async function walkDirectory(rootDir, relativeDir) {
+  const entries = await readdir(path.join(rootDir, relativeDir), { withFileTypes: true }).catch(() => []);
+  const files = [];
+
+  for (const entry of entries) {
+    if (entry.isDirectory() && SKIP_DIRS.has(entry.name)) {
+      continue;
+    }
+
+    const childPath = path.posix.join(relativeDir, entry.name);
+    if (entry.isDirectory()) {
+      files.push(...(await walkDirectory(rootDir, childPath)));
+    } else if (entry.isFile() && isTextFile(childPath)) {
+      files.push(childPath);
+    }
+  }
+
+  return files.sort();
+}
+
+function isTextFile(filePath) {
+  return /\.(cjs|css|js|json|jsx|md|mjs|ts|tsx|txt|yaml|yml)$/i.test(filePath);
+}