@engineeros/connector 0.4.4 → 0.4.7

package/bin/engineeros-connector.mjs

@@ -147,7 +147,9 @@ async function connect() {
     if (message.type === "workspace.assessment") {
       if (
         active?.runId !== message.assessment_id &&
-        !assessments.some((candidate) => candidate.assessment_id === message.assessment_id)
+        !assessments.some(
+          (candidate) => candidate.assessment_id === message.assessment_id,
+        )
       ) {
         assessments.push(message);
       }
@@ -327,7 +329,9 @@ function pump() {
 
 async function executePrompt(assignment) {
   const promptId = assignment.prompt_id;
-  console.log(`Answering ${assignment.purpose || "project"} prompt with Codex CLI.`);
+  console.log(
+    `Answering ${assignment.purpose || "project"} prompt with Codex CLI.`,
+  );
   try {
     const result = await executeConnectedPrompt(assignment, config, {
       onProcess: (child) => {
@@ -366,8 +370,12 @@ async function executeAssessment(assignment) {
   const assessmentId = assignment.assessment_id;
   console.log(`Assessing workspace with Codex CLI (${assessmentId}).`);
   let progress = 10;
-  const reportProgress = (message) => {
-    if (socket.readyState !== WebSocket.OPEN || active?.runId !== assessmentId) return;
+  const reportedMilestones = new Set();
+  const reportProgress = (message, { milestone = true } = {}) => {
+    if (socket.readyState !== WebSocket.OPEN || active?.runId !== assessmentId)
+      return;
+    if (milestone && reportedMilestones.has(message)) return;
+    if (milestone) reportedMilestones.add(message);
     socket.send(
       JSON.stringify({
         type: "workspace.assessment.progress",
@@ -377,12 +385,16 @@ async function executeAssessment(assignment) {
       }),
     );
   };
-  reportProgress("Codex is inspecting the workspace");
+  reportProgress("Starting read-only repository assessment");
   const heartbeat = setInterval(() => {
     progress = Math.min(90, progress + 5);
-    reportProgress("Codex is building the evidence-backed assessment");
+    reportProgress("Assessment in progress", { milestone: false });
   }, 15_000);
   try {
+    if (assignment.assessment_mode === "incremental") {
+      progress = 15;
+      reportProgress("Calculating changed files and affected evidence");
+    }
     const result = await executeWorkspaceAssessment(assignment, config, {
       onProcess: (child) => {
         if (active?.runId === assessmentId) active.child = child;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@engineeros/connector",
-  "version": "0.4.4",
+  "version": "0.4.7",
   "description": "Connect a local Codex CLI workspace to EngineerOS over an outbound WebSocket.",
   "private": false,
   "type": "module",

package/src/runner.mjs

@@ -145,9 +145,23 @@ export async function executeWorkspaceAssessment(
       "This workspace is no longer at the commit inventoried by EngineerOS. Refresh the workspace inventory before assessing it.",
     );
   }
+  const changeImpact =
+    assignment.assessment_mode === "incremental"
+      ? await workspaceChangeImpact(
+          config.workspace,
+          assignment.base_head_revision,
+          assignment.target_head_revision,
+        )
+      : { changedFiles: [], markdown: null };
+  const prompt = changeImpact.markdown
+    ? execution.prompt.replace(
+        "<!-- ENGINEEROS_CHANGE_IMPACT -->",
+        changeImpact.markdown,
+      )
+    : execution.prompt;
   const controller = launchCodexProcess(
     config.workspace,
-    execution.prompt,
+    prompt,
     execution.sandboxMode,
     callbacks,
   );
@@ -173,9 +187,97 @@ export async function executeWorkspaceAssessment(
   return {
     report_markdown: report,
     observed_head_revision: endingHead,
+    changed_files: changeImpact.changedFiles,
+    change_impact_markdown: changeImpact.markdown,
   };
 }
 
+export async function workspaceChangeImpact(workspace, baseRevision, targetRevision) {
+  if (!baseRevision || !targetRevision) {
+    throw new Error(
+      "Incremental assessment requires both the previously assessed and current Git commits. Run a full assessment instead.",
+    );
+  }
+  const range = `${baseRevision}..${targetRevision}`;
+  const names = await run(
+    "git",
+    ["diff", "--name-status", "--find-renames", range],
+    workspace,
+    { allowFailure: true },
+  );
+  if (names.code !== 0) {
+    throw new Error(
+      "Codex could not compare the assessed and current commits. Fetch the missing Git history or run a full assessment.",
+    );
+  }
+  const committedFiles = await run(
+    "git",
+    ["-c", "core.quotepath=false", "diff", "--name-only", range],
+    workspace,
+    { allowFailure: true },
+  );
+  const workingFiles = await run(
+    "git",
+    ["-c", "core.quotepath=false", "ls-files", "--others", "--modified", "--deleted", "--exclude-standard"],
+    workspace,
+    { allowFailure: true },
+  );
+  const status = await run("git", ["status", "--short"], workspace, {
+    allowFailure: true,
+  });
+  const stat = await run(
+    "git",
+    ["diff", "--stat", "--compact-summary", range],
+    workspace,
+    { allowFailure: true },
+  );
+  const allChangedFiles = [...new Set([
+    ...pathLines(committedFiles.stdout),
+    ...pathLines(workingFiles.stdout),
+  ])];
+  if (allChangedFiles.length > 500) {
+    throw new Error(
+      `This change affects ${allChangedFiles.length} paths, above the 500-path incremental limit. Run a full reassessment instead.`,
+    );
+  }
+  const changedFiles = allChangedFiles;
+  if (!changedFiles.length) {
+    throw new Error(
+      "The inventoried repository changed but Git reports no assessable paths. Refresh inventory or run a full assessment.",
+    );
+  }
+  const lines = [
+    `Comparison: \`${range}\``,
+    `Changed paths: ${changedFiles.length}`,
+    "",
+    "### Name status",
+    "",
+    "```text",
+    boundedText(names.stdout, 12_000),
+    "```",
+  ];
+  if (status.stdout.trim()) {
+    lines.push("", "### Working tree", "", "```text", boundedText(status.stdout, 6_000), "```");
+  }
+  if (stat.stdout.trim()) {
+    lines.push("", "### Diff summary", "", "```text", boundedText(stat.stdout, 6_000), "```");
+  }
+  return { changedFiles, markdown: lines.join("\n") };
+}
+
+function pathLines(output) {
+  return String(output || "")
+    .split(/\r?\n/)
+    .map((line) => line.trim())
+    .filter(Boolean)
+    .map((line) => line.replace(/^"|"$/g, ""));
+}
+
+function boundedText(value, maximum) {
+  const text = String(value || "").trim();
+  return text.length <= maximum ? text : `${text.slice(0, maximum)}\n... truncated by EngineerOS`;
+}
+
 export async function executeConnectedPrompt(assignment, config, callbacks) {
   const execution = connectorExecution(assignment);
   const controller = launchCodexProcess(
@@ -229,32 +331,45 @@ export function codexFailureMessage(output, code) {
 export function assessmentProgressMessage(event) {
   if (!event || typeof event !== "object") return null;
   if (event.type === "turn.started")
-    return "Codex started analyzing repository evidence";
+    return "Reviewing repository structure and current Git state";
   if (event.type === "item.started") {
     if (event.item?.type === "command_execution") {
-      const command = compactCommand(event.item.command);
-      return command
-        ? `Inspecting with ${command}`
-        : "Inspecting repository files";
+      return assessmentCommandMilestone(event.item.command);
     }
     if (event.item?.type === "mcp_tool_call")
-      return "Consulting a connected analysis tool";
+      return "Tracing architecture and code relationships";
     if (event.item?.type === "web_search")
       return "Checking an external technical reference";
     return null;
   }
   if (event.type === "item.completed" && event.item?.type === "agent_message") {
-    return "Assessment report prepared";
+    return "Synthesizing findings and highest-return actions";
   }
   return null;
 }
 
-function compactCommand(command) {
+function assessmentCommandMilestone(command) {
   const value = Array.isArray(command)
     ? command.join(" ")
     : String(command || "");
-  const compact = value.replace(/\s+/g, " ").trim();
-  return compact.length > 96 ? `${compact.slice(0, 93)}...` : compact;
+  const normalized = value.replace(/\s+/g, " ").trim().toLowerCase();
+  if (!normalized) return "Inspecting repository evidence";
+  if (/\bgit\s+(status|log|diff|show|rev-parse)\b/.test(normalized)) {
+    return "Comparing Git history and workspace changes";
+  }
+  if (
+    /\b(test|pytest|vitest|jest|ruff|eslint|tsc|build|lint)\b/.test(normalized)
+  ) {
+    return "Checking verification and delivery signals";
+  }
+  if (
+    /\b(audit|dependency|dependencies|lockfile|package-lock|pnpm-lock|requirements)\b/.test(
+      normalized,
+    )
+  ) {
+    return "Reviewing dependencies and security signals";
+  }
+  return "Tracing architecture and code relationships";
 }
 
 export function connectorExecution(assignment) {
@@ -470,20 +585,17 @@ function runCodexCommand(command, args, cwd) {
 async function changedFilePaths(workspace) {
   const tracked = await run(
     "git",
-    ["diff", "--name-only", "HEAD", "--"],
+    ["diff", "--name-only", "-z", "HEAD", "--"],
     workspace,
   );
   const untracked = await run(
     "git",
-    ["ls-files", "--others", "--exclude-standard"],
+    ["ls-files", "-z", "--others", "--exclude-standard"],
     workspace,
   );
   return [
     ...new Set(
-      `${tracked.stdout}\n${untracked.stdout}`
-        .split(/\r?\n/)
-        .map(normalizePath)
-        .filter(Boolean),
+      [...gitPathList(tracked.stdout), ...gitPathList(untracked.stdout)],
     ),
   ].sort();
 }
@@ -495,16 +607,15 @@ async function boundedDiff(workspace, changedFiles) {
     workspace,
   );
   const untracked = new Set(
-    (
-      await run(
-        "git",
-        ["ls-files", "--others", "--exclude-standard"],
-        workspace,
-      )
-    ).stdout
-      .split(/\r?\n/)
-      .map(normalizePath)
-      .filter(Boolean),
+    gitPathList(
+      (
+        await run(
+          "git",
+          ["ls-files", "-z", "--others", "--exclude-standard"],
+          workspace,
+        )
+      ).stdout,
+    ),
   );
   const parts = [tracked.stdout];
   for (const relative of changedFiles.filter((item) => untracked.has(item))) {
@@ -523,15 +634,13 @@ async function boundedDiff(workspace, changedFiles) {
   return diff;
 }
 
-async function repositoryArchive(workspace) {
+export async function repositoryArchive(workspace) {
   const listed = await run(
     "git",
-    ["ls-files", "-co", "--exclude-standard"],
+    ["ls-files", "-z", "-co", "--exclude-standard"],
     workspace,
   );
-  const files = [
-    ...new Set(listed.stdout.split(/\r?\n/).map(normalizePath).filter(Boolean)),
-  ].sort();
+  const files = [...new Set(gitPathList(listed.stdout))].sort();
   return createZip(
     await Promise.all(
       files.map(async (relative) => ({
@@ -686,6 +795,13 @@ function normalizePath(value) {
     .replace(/^\.\//, "");
 }
 
+function gitPathList(value) {
+  return String(value ?? "")
+    .split("\0")
+    .map(normalizePath)
+    .filter(Boolean);
+}
+
 function run(command, args, cwd, options = {}) {
   return new Promise((resolve, reject) => {
     const child = spawn(command, args, {