fix: align release tag format and batch template with patchloom CLI (#98)

The patchloom CLI changed its release tag format from v{version} to
patchloom-v{version} starting with v0.1.1 (cargo-dist convention).
The managed installer was producing 404 URLs for all downloads.

- Update normalizeReleaseVersion to strip patchloom-v prefix
- Update buildManagedInstallReleaseAssets to use patchloom-v tag format
- Change batch template from JSON to line-oriented format matching
  what patchloom batch actually expects
- Update parseBatchOperationCount to count non-empty lines
- Open batch template as plaintext instead of JSON
- Update all affected tests

Closes #97

Signed-off-by: Sebastien Tardif <sebtardif@ncf.ca>

Author: SebTardif

src/commands/batchApply.ts

@@ -5,28 +5,19 @@ import { formatCliOutput } from "../util.js";
 import { getPatchloomLog } from "../logging/outputChannel.js";
 import { activeWorkspaceFolder } from "../workspace/readiness.js";
 
-export const BATCH_TEMPLATE = JSON.stringify({
-  operations: [
-    { op: "replace", file: "", from: "", to: "" },
-    { op: "tidy", file: "", fixes: ["ensure-final-newline"] },
-    { op: "doc-set", file: "", selector: "", value: "" }
-  ]
-}, null, 2) + "\n";
+export const BATCH_TEMPLATE = [
+  "replace src/example.ts \"old text\" \"new text\"",
+  "doc.set package.json version \"2.0.0\"",
+  "tidy.fix src/example.ts",
+  ""
+].join("\n");
 
 export function buildBatchTemplate(): string {
   return BATCH_TEMPLATE;
 }
 
 export function parseBatchOperationCount(plan: string): number {
-  try {
-    const parsed = JSON.parse(plan);
-    if (Array.isArray(parsed?.operations)) {
-      return parsed.operations.length;
-    }
-  } catch {
-    // Invalid JSON
-  }
-  return 0;
+  return plan.split("\n").filter((line) => line.trim().length > 0).length;
 }
 
 export async function batchApply(): Promise<void> {
@@ -62,7 +53,7 @@ export async function batchApply(): Promise<void> {
 
   const binaryPath = status.binaryPath;
   const doc = await vscode.workspace.openTextDocument({
-    language: "json",
+    language: "plaintext",
     content: BATCH_TEMPLATE
   });
   await vscode.window.showTextDocument(doc, { preview: false });

src/install/managed.ts

@@ -300,11 +300,11 @@ export function buildManagedInstallReleaseAssets(
   const normalizedVersion = normalizeReleaseVersion(version);
   const paths = resolveManagedInstallPaths(PATCHLOOM_MANAGED_INSTALL_DIR, normalizedVersion, target);
   return {
-    tagName: `v${normalizedVersion}`,
+    tagName: `patchloom-v${normalizedVersion}`,
     archiveFileName: paths.archiveFileName,
     checksumFileName: paths.checksumFileName,
-    archiveDownloadUrl: `https://github.com/${repo}/releases/download/v${normalizedVersion}/${paths.archiveFileName}`,
-    checksumDownloadUrl: `https://github.com/${repo}/releases/download/v${normalizedVersion}/${paths.checksumFileName}`
+    archiveDownloadUrl: `https://github.com/${repo}/releases/download/patchloom-v${normalizedVersion}/${paths.archiveFileName}`,
+    checksumDownloadUrl: `https://github.com/${repo}/releases/download/patchloom-v${normalizedVersion}/${paths.checksumFileName}`
   };
 }
 
@@ -645,7 +645,7 @@ function classifyInstallFailureStage(error: unknown): { stage: ManagedInstallFai
 }
 
 export function normalizeReleaseVersion(version: string): string {
-  return version.replace(/^v/, "").trim();
+  return version.replace(/^patchloom-v/, "").replace(/^v/, "").trim();
 }
 
 function managedBinaryName(platform: NodeJS.Platform): string {

test/unit/batchApply.test.ts

@@ -2,75 +2,66 @@ import assert from "node:assert/strict";
 import test from "node:test";
 import { buildBatchTemplate, parseBatchOperationCount } from "../../src/commands/batchApply.js";
 
-test("buildBatchTemplate returns valid JSON with three operations", () => {
+test("buildBatchTemplate returns line-oriented format with three operations", () => {
   const template = buildBatchTemplate();
-  const parsed = JSON.parse(template);
+  const lines = template.split("\n").filter((line) => line.trim().length > 0);
 
-  assert.ok(Array.isArray(parsed.operations));
-  assert.equal(parsed.operations.length, 3);
-  assert.equal(parsed.operations[0].op, "replace");
-  assert.equal(parsed.operations[1].op, "tidy");
-  assert.equal(parsed.operations[2].op, "doc-set");
+  assert.equal(lines.length, 3);
+  assert.ok(lines[0].startsWith("replace "), "first line should be a replace operation");
+  assert.ok(lines[1].startsWith("doc.set "), "second line should be a doc.set operation");
+  assert.ok(lines[2].startsWith("tidy.fix "), "third line should be a tidy.fix operation");
 });
 
 test("buildBatchTemplate ends with a newline", () => {
   const template = buildBatchTemplate();
   assert.ok(template.endsWith("\n"));
 });
 
-test("parseBatchOperationCount counts operations in valid plan", () => {
-  const plan = JSON.stringify({
-    operations: [
-      { op: "replace", file: "a.txt", from: "x", to: "y" },
-      { op: "tidy", file: "b.txt", fixes: [] }
-    ]
-  });
+test("parseBatchOperationCount counts non-empty lines", () => {
+  const plan = [
+    'replace a.txt "x" "y"',
+    'doc.set b.json key "val"'
+  ].join("\n");
 
   assert.equal(parseBatchOperationCount(plan), 2);
 });
 
-test("parseBatchOperationCount returns 0 for invalid JSON", () => {
-  assert.equal(parseBatchOperationCount("not json"), 0);
+test("parseBatchOperationCount returns 0 for empty input", () => {
+  assert.equal(parseBatchOperationCount(""), 0);
 });
 
-test("parseBatchOperationCount returns 0 for missing operations", () => {
-  assert.equal(parseBatchOperationCount('{"other": "data"}'), 0);
+test("parseBatchOperationCount returns 0 for whitespace-only input", () => {
+  assert.equal(parseBatchOperationCount("   \n  \n"), 0);
 });
 
-test("parseBatchOperationCount returns 0 for empty operations array", () => {
-  assert.equal(parseBatchOperationCount('{"operations": []}'), 0);
+test("parseBatchOperationCount ignores blank lines between operations", () => {
+  const plan = 'replace a.txt "x" "y"\n\ndoc.set b.json key "v"\n';
+  assert.equal(parseBatchOperationCount(plan), 2);
 });
 
-test("parseBatchOperationCount returns 0 when operations is not an array", () => {
-  assert.equal(parseBatchOperationCount('{"operations": "not-an-array"}'), 0);
-  assert.equal(parseBatchOperationCount('{"operations": 42}'), 0);
-  assert.equal(parseBatchOperationCount('{"operations": null}'), 0);
+test("parseBatchOperationCount counts a single operation", () => {
+  assert.equal(parseBatchOperationCount('tidy.fix src/main.ts'), 1);
 });
 
 // --- #34: snapshot-style template tests ---
 
-test("buildBatchTemplate replace operation has required fields", () => {
-  const parsed = JSON.parse(buildBatchTemplate());
-  const replace = parsed.operations[0];
-  assert.equal(replace.op, "replace");
-  assert.ok("file" in replace, "replace operation missing 'file'");
-  assert.ok("from" in replace, "replace operation missing 'from'");
-  assert.ok("to" in replace, "replace operation missing 'to'");
+test("buildBatchTemplate replace line has file and quoted arguments", () => {
+  const lines = buildBatchTemplate().split("\n");
+  const replaceLine = lines.find((l) => l.startsWith("replace "));
+  assert.ok(replaceLine, "template should contain a replace line");
+  assert.match(replaceLine, /replace \S+ ".+" ".+"/, "replace should have file and two quoted args");
 });
 
-test("buildBatchTemplate tidy operation has required fields", () => {
-  const parsed = JSON.parse(buildBatchTemplate());
-  const tidy = parsed.operations[1];
-  assert.equal(tidy.op, "tidy");
-  assert.ok("file" in tidy, "tidy operation missing 'file'");
-  assert.ok(Array.isArray(tidy.fixes), "tidy operation 'fixes' should be an array");
+test("buildBatchTemplate doc.set line has file, selector, and quoted value", () => {
+  const lines = buildBatchTemplate().split("\n");
+  const docSetLine = lines.find((l) => l.startsWith("doc.set "));
+  assert.ok(docSetLine, "template should contain a doc.set line");
+  assert.match(docSetLine, /doc\.set \S+ \S+ ".+"/, "doc.set should have file, selector, and quoted value");
 });
 
-test("buildBatchTemplate doc-set operation has required fields", () => {
-  const parsed = JSON.parse(buildBatchTemplate());
-  const docSet = parsed.operations[2];
-  assert.equal(docSet.op, "doc-set");
-  assert.ok("file" in docSet, "doc-set operation missing 'file'");
-  assert.ok("selector" in docSet, "doc-set operation missing 'selector'");
-  assert.ok("value" in docSet, "doc-set operation missing 'value'");
+test("buildBatchTemplate tidy.fix line has a file path", () => {
+  const lines = buildBatchTemplate().split("\n");
+  const tidyLine = lines.find((l) => l.startsWith("tidy.fix "));
+  assert.ok(tidyLine, "template should contain a tidy.fix line");
+  assert.match(tidyLine, /tidy\.fix \S+/, "tidy.fix should have a file path");
 });

test/unit/binary.test.ts

@@ -224,16 +224,16 @@ test("resolveManagedInstallPaths uses cargo-dist style archive names", () => {
   assert.equal(paths.binaryPath, path.join("/managed/install", "0.1.0", "managed-bin", "patchloom"));
 });
 
-test("buildManagedInstallReleaseAssets builds archive and checksum urls", () => {
+test("buildManagedInstallReleaseAssets builds archive and checksum urls with patchloom-v tag", () => {
   const target = detectManagedInstallTarget("linux", "x64");
   assert.ok(target);
   const release = buildManagedInstallReleaseAssets("v0.1.0", target);
 
-  assert.equal(release.tagName, "v0.1.0");
+  assert.equal(release.tagName, "patchloom-v0.1.0");
   assert.equal(release.archiveFileName, "patchloom-x86_64-unknown-linux-gnu.tar.xz");
   assert.equal(release.checksumFileName, "patchloom-x86_64-unknown-linux-gnu.tar.xz.sha256");
-  assert.match(release.archiveDownloadUrl, /patchloom-x86_64-unknown-linux-gnu\.tar\.xz$/);
-  assert.match(release.checksumDownloadUrl, /patchloom-x86_64-unknown-linux-gnu\.tar\.xz\.sha256$/);
+  assert.match(release.archiveDownloadUrl, /\/patchloom-v0\.1\.0\/patchloom-x86_64-unknown-linux-gnu\.tar\.xz$/);
+  assert.match(release.checksumDownloadUrl, /\/patchloom-v0\.1\.0\/patchloom-x86_64-unknown-linux-gnu\.tar\.xz\.sha256$/);
 });
 
 test("parseManagedInstallChecksumFile accepts common sha256 sidecar formats", () => {
@@ -629,9 +629,19 @@ test("resolvePatchloomStatusWithInputs surfaces persisted managed install failur
   }
 });
 
-test("normalizeReleaseVersion removes a leading v", () => {
+test("normalizeReleaseVersion strips v and patchloom-v prefixes", () => {
   assert.equal(normalizeReleaseVersion("v0.1.0"), "0.1.0");
   assert.equal(normalizeReleaseVersion("0.1.0"), "0.1.0");
+  assert.equal(normalizeReleaseVersion("patchloom-v0.1.2"), "0.1.2");
+});
+
+test("buildManagedInstallReleaseAssets normalizes patchloom-v prefixed versions", () => {
+  const target = detectManagedInstallTarget("darwin", "arm64");
+  assert.ok(target);
+  const release = buildManagedInstallReleaseAssets("patchloom-v0.1.2", target);
+
+  assert.equal(release.tagName, "patchloom-v0.1.2");
+  assert.match(release.archiveDownloadUrl, /\/patchloom-v0\.1\.2\/patchloom-aarch64-apple-darwin\.tar\.xz$/);
 });
 
 test("resolvePatchloomStatusWithInputs falls back to a managed install when present", async () => {