@linzumi/cli 0.0.80-beta → 0.0.82-beta

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@linzumi/cli",
-  "version": "0.0.80-beta",
+  "version": "0.0.82-beta",
   "description": "Linzumi CLI — point a Codex agent at the real code on your laptop, with your team watching and steering from shared threads.",
   "type": "module",
   "bin": {
@@ -14,6 +14,7 @@
   ],
   "scripts": {
     "build": "node scripts/build.mjs",
+    "bump-version": "node scripts/bump-cli-version.mjs",
     "codex:history-table": "node scripts/codex_history_table.mjs",
     "test": "vitest run --config vitest.config.mjs",
     "prepack": "node scripts/build.mjs",
@@ -30,7 +31,7 @@
     "access": "public"
   },
   "dependencies": {
-    "@anthropic-ai/claude-agent-sdk": "^0.2.141",
+    "@anthropic-ai/claude-agent-sdk": "0.3.170",
     "@inquirer/prompts": "^7.8.6",
     "@modelcontextprotocol/sdk": "^1.18.2",
     "@openai/codex": "^0.131.0",

package/scripts/bump-cli-version.mjs

@@ -0,0 +1,306 @@
+// Single-command CLI version bump.
+//
+// Releasing the CLI:
+// (Example versions below use 1.2.3-beta on purpose: the leftover scan reads
+// this script too, so a REAL version literal here would collide with the
+// live package version and abort a bump.)
+//
+//   1. pnpm bump-version <new-version>     (for example: 1.2.3-beta)
+//   2. Run the test suite: pnpm vitest run --config vitest.config.mjs
+//   3. Commit with a "[deploy-cli]" title and merge to main.
+//   4. The main publish workflow (.github/workflows/linzumi-cli-publish.yml)
+//      publishes @linzumi/cli@<new-version> to npm.
+//
+// The package version is pinned in several places (package.json,
+// src/version.ts, README.md, and version-pinning tests). This script rewrites
+// every known site, FAILS LOUDLY if any expected pattern is missing, and then
+// scans package.json/src/README/test/scripts/bin for any leftover
+// old-version string - so a future, not-yet-listed pin site cannot silently
+// drift past a release.
+//
+// Flags:
+//   --dry-run      Plan and verify every rewrite without writing files.
+//   --root <dir>   Operate on a different package root (used by tests).
+import { readdirSync, readFileSync, statSync, writeFileSync } from 'node:fs';
+import { dirname, join, relative } from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+function fail(message) {
+  process.stderr.write(`bump-cli-version: ${message}\n`);
+  process.exit(1);
+}
+
+const usage =
+  'usage: node scripts/bump-cli-version.mjs <new-version> [--dry-run] [--root <dir>]';
+
+const rawArgs = process.argv.slice(2);
+let dryRun = false;
+let explicitRoot;
+const positional = [];
+
+for (let index = 0; index < rawArgs.length; index += 1) {
+  const arg = rawArgs[index];
+
+  if (arg === '--dry-run') {
+    dryRun = true;
+  } else if (arg === '--root') {
+    explicitRoot = rawArgs[index + 1];
+    index += 1;
+
+    if (explicitRoot === undefined) {
+      fail(`--root requires a directory argument\n${usage}`);
+    }
+  } else if (arg.startsWith('--')) {
+    fail(`unknown flag ${arg}\n${usage}`);
+  } else {
+    positional.push(arg);
+  }
+}
+
+const newVersion = positional[0];
+
+if (newVersion === undefined || positional.length !== 1) {
+  fail(usage);
+}
+
+if (!/^\d+\.\d+\.\d+(-[0-9A-Za-z][0-9A-Za-z.-]*)?$/.test(newVersion)) {
+  fail(
+    `'${newVersion}' does not look like a version (expected something like 1.2.3-beta)`
+  );
+}
+
+const packageRoot =
+  explicitRoot ?? dirname(dirname(fileURLToPath(import.meta.url)));
+
+let manifest;
+
+try {
+  manifest = JSON.parse(
+    readFileSync(join(packageRoot, 'package.json'), 'utf8')
+  );
+} catch (error) {
+  fail(`could not read package.json under ${packageRoot}: ${error.message}`);
+}
+
+const oldVersion = manifest.version;
+
+if (typeof oldVersion !== 'string' || oldVersion.trim() === '') {
+  fail('package.json has no "version" field to bump from');
+}
+
+if (oldVersion === newVersion) {
+  fail(`package.json is already at version ${oldVersion}`);
+}
+
+// Every place the version is pinned. Each entry must match at least once or
+// the bump aborts; add new entries here when a new pin site appears (the
+// leftover scan below is what tells you one appeared).
+const knownSites = [
+  {
+    file: 'package.json',
+    description: 'npm package manifest version',
+    pattern: `"version": "${oldVersion}"`,
+    replacement: `"version": "${newVersion}"`,
+  },
+  {
+    file: 'src/version.ts',
+    description: 'linzumiCliVersion constant',
+    pattern: `export const linzumiCliVersion = '${oldVersion}';`,
+    replacement: `export const linzumiCliVersion = '${newVersion}';`,
+  },
+  {
+    file: 'README.md',
+    description: 'pinned npx --version example',
+    pattern: `npx -y @linzumi/cli@${oldVersion} --version`,
+    replacement: `npx -y @linzumi/cli@${newVersion} --version`,
+  },
+  {
+    file: 'test/packageManifest.test.ts',
+    description: 'package manifest version expectation',
+    pattern: `expect(manifest.version).toBe('${oldVersion}');`,
+    replacement: `expect(manifest.version).toBe('${newVersion}');`,
+  },
+  {
+    file: 'test/cli.test.ts',
+    description: '--version output expectation',
+    pattern: `'linzumi ${oldVersion}'`,
+    replacement: `'linzumi ${newVersion}'`,
+  },
+  {
+    file: 'test/runnerBridge.test.ts',
+    description: 'runner join metadata version pin',
+    pattern: `version: '${oldVersion}',`,
+    replacement: `version: '${newVersion}',`,
+  },
+  {
+    file: 'test/runnerLock.test.ts',
+    description: 'runner lock cliVersion pins',
+    pattern: `cliVersion: '${oldVersion}',`,
+    replacement: `cliVersion: '${newVersion}',`,
+  },
+];
+
+function countOccurrences(haystack, needle) {
+  return haystack.split(needle).length - 1;
+}
+
+// src/version.ts keeps a spec-comment block where each bump appends an entry.
+function appendVersionSpecComment(content) {
+  const anchor = `*/\nexport const linzumiCliVersion = '${newVersion}';`;
+
+  if (!content.includes(anchor)) {
+    fail(
+      'src/version.ts spec-comment block convention not found (expected the comment to close right before the linzumiCliVersion export)'
+    );
+  }
+
+  const today = new Date().toISOString().slice(0, 10);
+  const entry = [
+    `- Date: ${today}`,
+    '  Spec: scripts/bump-cli-version.mjs (automated version bump)',
+    `  Relationship: Bumps the published CLI version so the`,
+    '  current mainline CLI can be released under a fresh immutable npm',
+    '  version with `[deploy-cli]`.',
+    '',
+  ].join('\n');
+
+  return content.replace(anchor, `${entry}${anchor}`);
+}
+
+const plannedWrites = new Map();
+const summary = [];
+
+for (const site of knownSites) {
+  const absolutePath = join(packageRoot, site.file);
+  let content;
+
+  try {
+    content =
+      plannedWrites.get(site.file) ?? readFileSync(absolutePath, 'utf8');
+  } catch (error) {
+    fail(`expected pin site ${site.file} could not be read: ${error.message}`);
+  }
+
+  const occurrences = countOccurrences(content, site.pattern);
+
+  if (occurrences === 0) {
+    fail(
+      `expected pattern not found in ${site.file}: ${JSON.stringify(site.pattern)} (${site.description}). The known-sites list in scripts/bump-cli-version.mjs is out of date; fix it before bumping.`
+    );
+  }
+
+  let rewritten = content.split(site.pattern).join(site.replacement);
+
+  if (site.file === 'src/version.ts') {
+    rewritten = appendVersionSpecComment(rewritten);
+  }
+
+  plannedWrites.set(site.file, rewritten);
+  summary.push({
+    file: site.file,
+    description: site.description,
+    occurrences,
+  });
+}
+
+// Leftover scan: after the planned rewrites, no old-version string may remain
+// anywhere in the package surface. This is what catches an unlisted 8th site.
+function scanTargets() {
+  const roots = ['src', 'test', 'scripts', 'bin'];
+  const files = ['package.json', 'README.md'];
+
+  for (const root of roots) {
+    const rootPath = join(packageRoot, root);
+    let entries;
+
+    try {
+      entries = walk(rootPath);
+    } catch {
+      continue;
+    }
+
+    for (const entry of entries) {
+      files.push(relative(packageRoot, entry));
+    }
+  }
+
+  return files;
+}
+
+function walk(directory) {
+  const results = [];
+
+  for (const name of readdirSync(directory)) {
+    if (name === 'node_modules' || name === 'dist') {
+      continue;
+    }
+
+    const path = join(directory, name);
+
+    if (statSync(path).isDirectory()) {
+      results.push(...walk(path));
+    } else {
+      results.push(path);
+    }
+  }
+
+  return results;
+}
+
+const leftovers = [];
+
+for (const file of scanTargets()) {
+  let content = plannedWrites.get(file);
+
+  if (content === undefined) {
+    try {
+      content = readFileSync(join(packageRoot, file), 'utf8');
+    } catch (error) {
+      if (error?.code === 'ENOENT') {
+        // The file disappeared between walk() and this read; a file that no
+        // longer exists cannot hold a leftover pin, so skip it.
+        continue;
+      }
+
+      // Anything else (permissions, I/O) means the scan could MISS a
+      // leftover, so fail loudly in the script's own format instead of
+      // letting a raw Node.js stack trace escape.
+      fail(
+        `could not read ${file} while scanning for leftover '${oldVersion}' pins: ${error?.message ?? error}`
+      );
+    }
+  }
+
+  if (content.includes(oldVersion)) {
+    leftovers.push(file);
+  }
+}
+
+if (leftovers.length > 0) {
+  fail(
+    `'${oldVersion}' still appears in: ${leftovers.join(', ')}. These pin sites are not in the known-sites list in scripts/bump-cli-version.mjs; add them so the bump rewrites every site, then re-run.`
+  );
+}
+
+for (const [file, content] of plannedWrites) {
+  if (!dryRun) {
+    writeFileSync(join(packageRoot, file), content);
+  }
+}
+
+const verb = dryRun ? 'Would rewrite' : 'Rewrote';
+process.stdout.write(`bump-cli-version: ${oldVersion} -> ${newVersion}\n`);
+
+for (const item of summary) {
+  process.stdout.write(
+    `  ${verb} ${item.file} (${item.occurrences} occurrence${item.occurrences === 1 ? '' : 's'}: ${item.description})\n`
+  );
+}
+
+if (dryRun) {
+  process.stdout.write('Dry run - no files were written.\n');
+} else {
+  process.stdout.write(
+    'Done. Now run the test suite before committing:\n  pnpm vitest run --config vitest.config.mjs\nThen commit with a "[deploy-cli]" title and merge to main to publish.\n'
+  );
+}