@danmoisan/drm-copilot-mcp 1.1.4 → 1.1.6

package/out/mcp-server.js

@@ -2671,18 +2671,18 @@ var require_validate = __commonJS({
         const { schemaCode } = this;
         this.fail((0, codegen_1._)`${schemaCode} !== undefined && (${(0, codegen_1.or)(this.invalid$data(), condition)})`);
       }
-      error(append, errorParams, errorPaths) {
+      error(append2, errorParams, errorPaths) {
         if (errorParams) {
           this.setParams(errorParams);
-          this._error(append, errorPaths);
+          this._error(append2, errorPaths);
           this.setParams({});
           return;
         }
-        this._error(append, errorPaths);
+        this._error(append2, errorPaths);
       }
-      _error(append, errorPaths) {
+      _error(append2, errorPaths) {
         ;
-        (append ? errors_1.reportExtraError : errors_1.reportError)(this, this.def.error, errorPaths);
+        (append2 ? errors_1.reportExtraError : errors_1.reportError)(this, this.def.error, errorPaths);
       }
       $dataError() {
         (0, errors_1.reportError)(this, this.def.$dataError || errors_1.keyword$DataError);
@@ -23551,6 +23551,7 @@ var GENERATED_AGENT_FAMILIES = /* @__PURE__ */ new Set([
   "atomic-planner",
   "atomic-executor",
   "feature-reviewer",
+  "commit-steward",
   "task-researcher",
   "prd-feature",
   "pr-author",
@@ -26957,7 +26958,14 @@ function classifyKind(argv) {
   return "other";
 }
 function splitLines2(text) {
-  return text.split(/\r\n|\n|\r/);
+  if (text === "") {
+    return [];
+  }
+  const lines = text.split(/\r\n|\n|\r/);
+  if (lines[lines.length - 1] === "") {
+    lines.pop();
+  }
+  return lines;
 }
 function inlineSpans(line) {
   const spans = [];
@@ -26979,34 +26987,63 @@ function appendCommand(commands, taskId, sourceLine, rawSpan) {
     sourceLine,
     rawSpan,
     argv,
-    kind: classifyKind(argv)
+    kind: classifyKind(argv),
+    taskText: ""
   });
 }
+function closeWindow(commands, windowStart, windowLines) {
+  if (windowStart >= commands.length) {
+    return;
+  }
+  const taskText = windowLines.join("\n");
+  for (let index = windowStart; index < commands.length; index += 1) {
+    const record2 = commands[index];
+    if (record2 === void 0) {
+      continue;
+    }
+    commands[index] = { ...record2, taskText };
+  }
+}
 function extractPlanCommands(text) {
   const commands = [];
   let currentTask = null;
   let inFence = false;
+  let windowLines = [];
+  let windowStart = 0;
   const lines = splitLines2(text);
   for (let index = 0; index < lines.length; index += 1) {
     const line = lines[index] ?? "";
     const lineNumber = index + 1;
     if (FENCE_RE.test(line)) {
       inFence = !inFence;
+      if (currentTask !== null) {
+        windowLines.push(line);
+      }
       continue;
     }
     if (inFence) {
+      if (currentTask === null) {
+        continue;
+      }
+      windowLines.push(line);
       const fenced = line.trim();
-      if (currentTask !== null && fenced !== "") {
+      if (fenced !== "") {
         appendCommand(commands, currentTask, lineNumber, fenced);
       }
       continue;
     }
     if (PLAN_GATE_HEADING_PATTERN.test(line)) {
+      closeWindow(commands, windowStart, windowLines);
+      windowStart = commands.length;
+      windowLines = [];
       currentTask = null;
       continue;
     }
     const taskMatch = PLAN_GATE_TASK_PATTERN.exec(line);
     if (taskMatch !== null) {
+      closeWindow(commands, windowStart, windowLines);
+      windowStart = commands.length;
+      windowLines = [];
       const phase = taskMatch.groups?.["phase"] ?? "";
       const task = taskMatch.groups?.["task"] ?? "";
       currentTask = `P${phase}-T${task}`;
@@ -27014,10 +27051,12 @@ function extractPlanCommands(text) {
     if (currentTask === null) {
       continue;
     }
+    windowLines.push(line);
     for (const span of inlineSpans(line)) {
       appendCommand(commands, currentTask, lineNumber, span);
     }
   }
+  closeWindow(commands, windowStart, windowLines);
   return commands;
 }
 
@@ -27167,6 +27206,242 @@ function hasCrossLinePresence(context, literal2) {
   return false;
 }
 
+// ../../extensions/drm-copilot/src/lib/validate/plan-gate-observability.ts
+var G7_SEVERITY = "warning";
+var G8_SEVERITY = "warning";
+var G8B_SEVERITY = "warning";
+var G9_SEVERITY = "warning";
+var WRITE_MODE_REGISTER = [
+  {
+    name: "black-write",
+    shapes: [{ words: ["black"] }],
+    excludes: ["--check", "--diff"],
+    markers: ["reformatted", "left unchanged", "unchanged"]
+  },
+  {
+    name: "ruff-fix",
+    shapes: [{ words: ["ruff", "check"] }],
+    excludes: ["--no-fix"],
+    markers: ["Fixed", "All checks passed", "fixes applied"]
+  },
+  {
+    name: "prettier-write",
+    shapes: [
+      { words: ["prettier"], requires: ["--write"] },
+      { words: ["npm", "run", "format"] }
+    ],
+    excludes: [],
+    markers: ["(unchanged)", "unchanged", "rewrote"]
+  },
+  {
+    name: "poshqc-format",
+    shapes: [{ suffix: "run_poshqc_format" }],
+    excludes: [],
+    markers: ["formatted", "unchanged"]
+  },
+  {
+    name: "poshqc-analyze-autofix",
+    shapes: [{ suffix: "run_poshqc_analyze_autofix" }],
+    excludes: [],
+    markers: ["autofix", "Fixed", "unchanged"]
+  },
+  {
+    name: "poshqc-suite",
+    shapes: [{ suffix: "run_poshqc_suite" }],
+    excludes: [],
+    markers: ["formatted", "unchanged"]
+  }
+];
+var EXECUTABLE_SCAN_LIMIT2 = 4;
+var PATHSPEC_SEPARATOR = "--";
+var INDEX_FLAGS = ["--cached", "--staged"];
+var NAME_LISTING_FLAGS = ["--name-only", "--name-status"];
+var GIT_DIFF_SPAN = "git diff";
+var GIT_STATUS_SPAN = "git status";
+var GIT_ADD_SPAN = "git add";
+var GIT_PORCELAIN_SPAN = "git status --porcelain";
+var PROJECT_CONFIG_PATH = "pyproject.toml";
+var TERMINAL_REPORTER_PREFIX = "--cov-report=term";
+var FAIL_UNDER_PREFIX = "--cov-fail-under";
+var ADDOPTS_PATTERNS = [
+  /addopts[ \t]*=[ \t]*"([^"]*)"/,
+  /addopts[ \t]*=[ \t]*'([^']*)'/
+];
+function append(report, severity, finding) {
+  const channel = severity === BLOCKING_CHANNEL ? report.blocking : report.warnings;
+  channel.push(finding);
+}
+function executablePositions(argv) {
+  const limit = Math.min(argv.length, EXECUTABLE_SCAN_LIMIT2);
+  const positions = [];
+  for (let index = 0; index < limit; index += 1) {
+    if (index === 0 || !(argv[index - 1] ?? "").startsWith("-")) {
+      positions.push(index);
+    }
+  }
+  return positions;
+}
+function shapeMatches(argv, shape) {
+  const requires = shape.requires ?? [];
+  if (requires.some((required2) => !argv.includes(required2))) {
+    return false;
+  }
+  const words2 = shape.words ?? [];
+  for (const index of executablePositions(argv)) {
+    if (shape.suffix !== void 0 && shape.suffix !== "") {
+      if ((argv[index] ?? "").endsWith(shape.suffix)) {
+        return true;
+      }
+      continue;
+    }
+    const end = index + words2.length;
+    if (end <= argv.length && words2.every((word, offset) => argv[index + offset] === word)) {
+      return true;
+    }
+  }
+  return false;
+}
+function matchingEntry(argv) {
+  for (const entry of WRITE_MODE_REGISTER) {
+    if (entry.excludes.some((excluded) => argv.includes(excluded))) {
+      continue;
+    }
+    if (entry.shapes.some((shape) => shapeMatches(argv, shape))) {
+      return entry;
+    }
+  }
+  return null;
+}
+function taskTextWithoutSpan(command) {
+  return command.taskText.replace(command.rawSpan, " ");
+}
+function evaluateWriteMode(report, command) {
+  const entry = matchingEntry(command.argv);
+  if (entry === null) {
+    return;
+  }
+  const remainder = taskTextWithoutSpan(command);
+  if (entry.markers.some((marker) => remainder.includes(marker))) {
+    return;
+  }
+  append(
+    report,
+    G7_SEVERITY,
+    `[${command.taskId}] write-mode command \`${command.rawSpan}\` rewrites tracked source and exits 0 after rewriting; the attributed task text carries none of its observation markers. Record an observation beyond the exit code.`
+  );
+}
+function gitDiffIndex(argv) {
+  const limit = Math.min(argv.length, EXECUTABLE_SCAN_LIMIT2);
+  for (let index = 0; index < limit; index += 1) {
+    if (argv[index] === "git" && argv[index + 1] === "diff") {
+      return index + 1;
+    }
+  }
+  return null;
+}
+function diffOperands(argv, diffIndex) {
+  const operands = [];
+  for (const word of argv.slice(diffIndex + 1)) {
+    if (word === PATHSPEC_SEPARATOR) {
+      break;
+    }
+    operands.push(word);
+  }
+  return operands;
+}
+function carriesPairingCompanion(command) {
+  const remainder = taskTextWithoutSpan(command);
+  return remainder.includes(GIT_DIFF_SPAN) || remainder.includes(GIT_STATUS_SPAN);
+}
+function carriesListingCompanion(command) {
+  const remainder = taskTextWithoutSpan(command);
+  return remainder.includes(GIT_ADD_SPAN) || remainder.includes(GIT_PORCELAIN_SPAN);
+}
+function evaluateGitDiff(report, command) {
+  const argv = command.argv;
+  const diffIndex = gitDiffIndex(argv);
+  if (diffIndex === null) {
+    return;
+  }
+  const operands = diffOperands(argv, diffIndex);
+  const hasRefOperand = operands.some((word) => !word.startsWith("-"));
+  const hasIndexFlag = INDEX_FLAGS.some((flag) => argv.includes(flag));
+  if (!hasRefOperand && !hasIndexFlag) {
+    if (!carriesPairingCompanion(command)) {
+      append(
+        report,
+        G8_SEVERITY,
+        `[${command.taskId}] git diff span \`${command.rawSpan}\` carries no ref operand and no --cached flag; it compares the worktree against the index and passes vacuously once the change is committed. Anchor the diff to a ref.`
+      );
+    }
+    return;
+  }
+  if (hasRefOperand && NAME_LISTING_FLAGS.some((flag) => argv.includes(flag))) {
+    if (!carriesListingCompanion(command)) {
+      append(
+        report,
+        G8B_SEVERITY,
+        `[${command.taskId}] name-listing diff \`${command.rawSpan}\` never reports an untracked file, and the attributed task text carries neither a staging span nor a porcelain-status span; a path the plan creates is invisible to it. Add a staging or porcelain-status companion.`
+      );
+    }
+  }
+}
+function projectAddopts(context) {
+  const text = context.git.readTrackedText(PROJECT_CONFIG_PATH);
+  if (text === "") {
+    return null;
+  }
+  for (const pattern of ADDOPTS_PATTERNS) {
+    const match = pattern.exec(text);
+    if (match !== null) {
+      return match[1] ?? "";
+    }
+  }
+  return "";
+}
+function collectCoverageReporter(pending, command, addopts) {
+  const argv = command.argv;
+  if (!argv.some((word) => isCovFlagToken(word))) {
+    return;
+  }
+  if (argv.some((word) => word.startsWith(TERMINAL_REPORTER_PREFIX))) {
+    return;
+  }
+  if (argv.some((word) => word.startsWith(FAIL_UNDER_PREFIX))) {
+    return;
+  }
+  if (addopts.includes(TERMINAL_REPORTER_PREFIX)) {
+    return;
+  }
+  pending.push(
+    `[${command.taskId}] coverage command \`${command.rawSpan}\` supplies no terminal reporter and the project addopts supplies none either, so no coverage table is printed. Add --cov-report=term-missing.`
+  );
+}
+function evaluateObservabilityGates(report, commands, context) {
+  for (const command of commands) {
+    evaluateWriteMode(report, command);
+    evaluateGitDiff(report, command);
+  }
+  if (context === void 0) {
+    return;
+  }
+  const pending = [];
+  try {
+    const addopts = projectAddopts(context);
+    if (addopts === null) {
+      return;
+    }
+    for (const command of commands) {
+      collectCoverageReporter(pending, command, addopts);
+    }
+  } catch {
+    return;
+  }
+  for (const finding of pending) {
+    append(report, G9_SEVERITY, finding);
+  }
+}
+
 // ../../extensions/drm-copilot/src/lib/validate/plan-gate-discrimination.ts
 var G5_SEVERITY = "warning";
 var CommandRunnerPlanGateRepository = class {
@@ -27262,6 +27537,7 @@ function evaluatePlanGates(text, context) {
       evaluateCovValue(report, command, cov, context);
     }
   }
+  evaluateObservabilityGates(report, commands, context);
   if (context !== void 0) {
     evaluateLiteralRules(report, text, commands, context);
   }
@@ -31089,10 +31365,16 @@ function parseSection3(markdown, heading) {
 function formatDiffPath2(pathText) {
   return pathText !== null ? formatDiffPath(pathText) : "";
 }
-function appendGenerationTimestamp(clock = () => /* @__PURE__ */ new Date()) {
+var GENERATED_CONTEXT_SECTION_TITLE = "Context generated";
+var HEAD_SHA_LABEL = "Head SHA:";
+var UNKNOWN_HEAD_SHA_PLACEHOLDER = "(unknown)";
+function appendGenerationTimestamp(clock = () => /* @__PURE__ */ new Date(), headSha = null) {
   const now = clock();
   const timestamp = formatUtcTimestamp(now);
-  return section("Context generated") + "\n" + timestamp + "\n";
+  const shaText = headSha !== null && headSha !== "" ? headSha : UNKNOWN_HEAD_SHA_PLACEHOLDER;
+  return section(GENERATED_CONTEXT_SECTION_TITLE) + "\n" + timestamp + `
+${HEAD_SHA_LABEL} ${shaText}
+`;
 }
 function formatUtcTimestamp(date3) {
   const year = date3.getUTCFullYear().toString().padStart(4, "0");
@@ -31440,7 +31722,7 @@ function renderVerificationEvidenceSection(fs10, resolvedRoot, featureDocs) {
   }
   return lines.join("\n");
 }
-function buildSummaryText(collected, fs10, appendixPath) {
+function buildSummaryText(collected, fs10, appendixPath, generatedSection) {
   const ctx = collected.contextResult;
   const ghStatusText = resolveGhStatusText(collected);
   const intentBlock = [
@@ -31451,6 +31733,7 @@ function buildSummaryText(collected, fs10, appendixPath) {
     "Author-asserted autoclose issues:"
   ].join("\n");
   const summarySections = [
+    generatedSection,
     section("GitHub CLI status"),
     ghStatusText,
     intentBlock,
@@ -31528,7 +31811,7 @@ function buildSummaryText(collected, fs10, appendixPath) {
   }
   return summaryText;
 }
-function buildAppendixText(collected, clock) {
+function buildAppendixText(collected, generatedSection) {
   const featureBlock = collected.featureDocs.map((doc) => doc.excerpt).join("\n");
   const issueSections = collected.issueDetails.map(
     (detail) => issueAppendix(detail)
@@ -31537,7 +31820,7 @@ function buildAppendixText(collected, clock) {
     (detail) => prAppendix(detail)
   );
   const appendixParts = [
-    appendGenerationTimestamp(clock),
+    generatedSection,
     collected.contextResult.text,
     "",
     section("Issue details"),
@@ -31555,12 +31838,12 @@ function buildAppendixText(collected, clock) {
   }
   return appendixText;
 }
-function writeOutput(fs10, text, outPath, append) {
+function writeOutput(fs10, text, outPath, append2) {
   const parent = parentDir(outPath);
   if (parent) {
     fs10.ensureDir(parent);
   }
-  if (append && fs10.isFile(outPath)) {
+  if (append2 && fs10.isFile(outPath)) {
     const existing = fs10.readTextFile(outPath);
     fs10.writeTextFile(outPath, existing + text);
   } else {
@@ -31570,17 +31853,23 @@ function writeOutput(fs10, text, outPath, append) {
 function collectAndWrite(options) {
   const clock = options.clock ?? (() => /* @__PURE__ */ new Date());
   const collected = collectPrContext(options);
+  const generatedSection = appendGenerationTimestamp(
+    clock,
+    collected.contextResult.headSha
+  );
   const summaryText = buildSummaryText(
     collected,
     options.fs,
-    options.appendixOut
+    options.appendixOut,
+    generatedSection
   );
-  const appendixText = buildAppendixText(collected, clock);
+  const appendixText = buildAppendixText(collected, generatedSection);
   writeOutput(options.fs, summaryText, options.out, options.append);
   writeOutput(options.fs, appendixText, options.appendixOut, options.append);
   const log = options.log ?? (() => void 0);
   log(`Wrote context summary to: ${options.out}`);
   log(`Wrote context appendix to: ${options.appendixOut}`);
+  return { summaryText, appendixText };
 }
 function resolveGhStatusText(collected) {
   let ghStatusText = collected.ghStatusOverride || collected.ghStatusMessage || "GitHub CLI authenticated.";
@@ -31652,26 +31941,48 @@ function parentDir(path11) {
 // ../../extensions/drm-copilot/src/lib/pr-context/pr-context-service-call.ts
 var SUMMARY_OUT = "artifacts/pr_context.summary.txt";
 var APPENDIX_OUT = "artifacts/pr_context.appendix.txt";
+function verifyWrittenArtifact(fileSystem, artifactPath, expected) {
+  let actual;
+  try {
+    actual = fileSystem.readTextFile(artifactPath);
+  } catch (error2) {
+    const detail = error2 instanceof Error ? error2.message : String(error2);
+    throw new Error(
+      `Failed to verify PR context artifact '${artifactPath}': the file could not be read back after writing (${detail}).`,
+      { cause: error2 }
+    );
+  }
+  if (actual !== expected) {
+    throw new Error(
+      `Failed to verify PR context artifact '${artifactPath}': the content read back is not the content this invocation rendered (expected ${String(expected.length)} characters, read back ${String(actual.length)}).`
+    );
+  }
+}
 function collectPrContextServiceCall(input) {
-  collectAndWrite({
+  const summaryOut = normalizeGeneratedPath(
+    (0, import_node_path.join)(input.workspaceRoot, SUMMARY_OUT)
+  );
+  const appendixOut = normalizeGeneratedPath(
+    (0, import_node_path.join)(input.workspaceRoot, APPENDIX_OUT)
+  );
+  const rendered = collectAndWrite({
     base: input.base,
     repoRoot: input.workspaceRoot,
-    out: SUMMARY_OUT,
-    appendixOut: APPENDIX_OUT,
+    out: summaryOut,
+    appendixOut,
     append: false,
     includeUntracked: true,
     fs: input.fileSystem,
     runner: input.runner,
     ...input.log === void 0 ? {} : { log: input.log }
   });
+  verifyWrittenArtifact(input.fileSystem, summaryOut, rendered.summaryText);
+  verifyWrittenArtifact(input.fileSystem, appendixOut, rendered.appendixText);
   return {
     tool: "collect_pr_context",
     workspaceRoot: input.workspaceRoot,
     summary: `Collected PR context against base '${input.base}'.`,
-    artifacts: [
-      normalizeGeneratedPath((0, import_node_path.join)(input.workspaceRoot, SUMMARY_OUT)),
-      normalizeGeneratedPath((0, import_node_path.join)(input.workspaceRoot, APPENDIX_OUT))
-    ]
+    artifacts: [summaryOut, appendixOut]
   };
 }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@danmoisan/drm-copilot-mcp",
-  "version": "1.1.4",
+  "version": "1.1.6",
   "description": "Stdio MCP server exposing drm-copilot repo-automation tools.",
   "license": "MIT",
   "type": "commonjs",