@ltm-alpha/alpha-cs 1.6.0

package/scripts/clean-remaining.mjs

@@ -0,0 +1,243 @@
+#!/usr/bin/env node
+import fs from "fs";
+import path from "path";
+const ROOT = process.cwd();
+
+// File-by-file targeted fixes for remaining "codegraph" references
+const fixes = {
+  // === directory.ts - variable names (codegraphDir -> alphaCsDir) ===
+  "src/directory.ts": [
+    ["const codegraphDir", "const alphaCsDir"],
+    ["codegraphDir", "alphaCsDir"],
+    ["if (!fs.existsSync(alphaCsDir) || !fs.statSync(alphaCsDir).isDirectory())", "if (!fs.existsSync(alphaCsDir) || !fs.statSync(alphaCsDir).isDirectory())"],
+  ],
+
+  // === mcp/tools.ts - codegraph_ prefix stripping in filter patterns ===
+  "src/mcp/tools.ts": [
+    ["[[codegraph-explore-summary]]", "[[alpha-cs-explore-summary]]"],
+    ["DEFAULT_MCP_TOOLS.has(t.name.replace(/^codegraph_/, \"\"))", "DEFAULT_MCP_TOOLS.has(t.name.replace(/^alpha_cs_/, \"\"))"],
+    ["s.trim().replace(/^codegraph_/, \"\")", "s.trim().replace(/^alpha_cs_/, \"\")"],
+    ["name.replace(/^codegraph_/, \"\")", "name.replace(/^alpha_cs_/, \"\")"],
+    ["allow.has(t.name.replace(/^codegraph_/, \"\"))", "allow.has(t.name.replace(/^alpha_cs_/, \"\"))"],
+    ["/^codegraph_/", "/^alpha_cs_/"],
+    ["codegraph\"s home turf", "Alpha Code Sense\"s home turf"],
+    ["codegraph\"s value-add", "Alpha Code Sense\"s value-add"],
+  ],
+
+  // === mcp/session.ts - MCP protocol name ===
+  "src/mcp/session.ts": [
+    ["name: \"codegraph\"", "name: \"alpha-cs\""],
+  ],
+
+  // === mcp/daemon.ts - protocol field names ===
+  "src/mcp/daemon.ts": [
+    ["codegraph: string; // package version", "alpha_cs: string; // package version"],
+    ["codegraph_client: 1;", "alpha_cs_client: 1;"],
+  ],
+
+  // === mcp/proxy.ts ===
+  "src/mcp/proxy.ts": [
+    ["codegraph_client: 1,", "alpha_cs_client: 1,"],
+  ],
+
+  // === mcp/query-pool.ts ===
+  "src/mcp/query-pool.ts": [
+    ["\"codegraph worker crashed\"", "\"alpha-cs worker crashed\""],
+    ["\"codegraph is shutting down\"", "\"alpha-cs is shutting down\""],
+  ],
+
+  // === mcp/daemon-paths.ts ===
+  "src/mcp/daemon-paths.ts": [
+    ["pipe\\\\codegraph-", "pipe\\\\alpha-cs-"],
+  ],
+
+  // === mcp/writer-lock.ts ===
+  "src/mcp/writer-lock.ts": [
+    ["codegraph daemon stop", "alpha-cs daemon stop"],
+  ],
+
+  // === mcp/server-instructions.ts ===
+  "src/mcp/server-instructions.ts": [
+    ["Trust codegraph", "Trust Alpha Code Sense"],
+  ],
+
+  // === mcp/index.ts ===
+  "src/mcp/index.ts": [
+    ["from \"codegraph\"", "from \"alpha-cs\""],
+  ],
+
+  // === src/index.ts ===
+  "src/index.ts": [
+    ["codegraph\"s own", "Alpha Code Sense\"s own"],
+  ],
+
+  // === src/errors.ts ===
+  "src/errors.ts": [
+    ["from \"codegraph\"", "from \"alpha-cs\""],
+  ],
+
+  // === src/utils.ts ===
+  "src/utils.ts": [
+    ["from \"codegraph\"", "from \"alpha-cs\""],
+    ["\"codegraph unlock\"", "\"ltm-alpha-cs unlock\""],
+  ],
+
+  // === src/telemetry/index.ts ===
+  "src/telemetry/index.ts": [
+    ["codegraph_version:", "alpha_cs_version:"],
+    ["[codegraph telemetry]", "[alpha-cs telemetry]"],
+  ],
+
+  // === src/db/index.ts ===
+  "src/db/index.ts": [
+    ["[codegraph] FTS5", "[alpha-cs] FTS5"],
+  ],
+
+  // === src/sync/git-hooks.ts ===
+  "src/sync/git-hooks.ts": [
+    ["command -v codegraph", "command -v ltm-alpha-cs"],
+  ],
+
+  // === src/ui/color.ts ===
+  "src/ui/color.ts": [
+    ["codegraph-authored", "Alpha Code Sense-authored"],
+    ["codegraph lines", "Alpha Code Sense lines"],
+  ],
+
+  // === src/ui-server/security.ts ===
+  "src/ui-server/security.ts": [
+    ["x-alpha-cs-ui", "x-alpha-cs-ui"],
+  ],
+
+  // === src/upgrade/remove-binary.ts ===
+  "src/upgrade/remove-binary.ts": [
+    ["LOCALAPPDATA}\\codegraph", "LOCALAPPDATA}\\alpha-cs"],
+    ["\"codegraph\"", "\"ltm-alpha-cs\""],
+    [", \"codegraph\")", ", \"ltm-alpha-cs\")"],
+  ],
+
+  // === src/upgrade/index.ts ===
+  "src/upgrade/index.ts": [
+    ["bin/codegraph", "bin/ltm-alpha-cs"],
+    ["hasCommand(\"codegraph\")", "hasCommand(\"ltm-alpha-cs\")"],
+    ["capture(\"codegraph\"", "capture(\"ltm-alpha-cs\""],
+    ["capture(\"cmd.exe\"", "capture(\"cmd.exe\""],
+    ["which -a codegraph", "which -a ltm-alpha-cs"],
+    ["where codegraph", "where ltm-alpha-cs"],
+    ["run(\"codegraph\"", "run(\"ltm-alpha-cs\""],
+    ["codegraph-${target}", "alpha-cs-${target}"],
+    ["\"codegraph\" on", "\"ltm-alpha-cs\" on"],
+    ["the \"codegraph\" this", "the \"ltm-alpha-cs\" this"],
+    ["`codegraph` on", "`ltm-alpha-cs` on"],
+    ["removes codegraph", "removes ltm-alpha-cs"],
+  ],
+
+  // === src/installer/targets/shared.ts ===
+  "src/installer/targets/shared.ts": [
+    ["command: \"codegraph\"", "command: \"ltm-alpha-cs\""],
+    ["mcp__alpha_cs__", "mcp__alpha_cs__"],
+  ],
+
+  // === src/installer/targets/cursor.ts ===
+  "src/installer/targets/cursor.ts": [
+    ["mcpServers: { alpha-cs:", "mcpServers: { alpha-cs:"],
+  ],
+
+  // === src/installer/targets/antigravity.ts ===
+  "src/installer/targets/antigravity.ts": [
+    ["\"codegraph\"", "\"ltm-alpha-cs\""],
+    ["return \"codegraph\"", "return \"ltm-alpha-cs\""],
+    ["mcpServers: { alpha-cs:", "mcpServers: { alpha-cs:"],
+    ["which codegraph", "which ltm-alpha-cs"],
+    ["where codegraph", "where ltm-alpha-cs"],
+    ["prefer-alpha-cs-over-grep", "prefer-alpha-cs-over-grep"],
+  ],
+
+  // === src/installer/targets/kiro.ts ===
+  "src/installer/targets/kiro.ts": [
+    ["mcpServers: { alpha-cs:", "mcpServers: { alpha-cs:"],
+  ],
+
+  // === src/installer/targets/copilot-cli.ts ===
+  "src/installer/targets/copilot-cli.ts": [
+    ["mcpServers: { alpha-cs:", "mcpServers: { alpha-cs:"],
+  ],
+
+  // === src/installer/targets/copilot-vscode.ts ===
+  "src/installer/targets/copilot-vscode.ts": [
+    ["servers: { alpha-cs:", "servers: { alpha-cs:"],
+    ["\"servers\", \"codegraph\"", "\"servers\", \"alpha-cs\""],
+  ],
+
+  // === src/installer/targets/opencode.ts ===
+  "src/installer/targets/opencode.ts": [
+    ["command: [\"codegraph\"", "command: [\"ltm-alpha-cs\""],
+    ["servers: { alpha-cs:", "servers: { alpha-cs:"],
+    ["\"mcp\", \"codegraph\"", "\"mcp\", \"alpha-cs\""],
+    ["\"mcp\", \"servers\", \"codegraph\"", "\"mcp\", \"servers\", \"alpha-cs\""],
+  ],
+
+  // === src/resolution/c-fnptr-synthesizer.ts ===
+  "src/resolution/c-fnptr-synthesizer.ts": [
+    ["codegraph-kernel/src/cfnptr.rs", "alpha-cs-kernel/src/cfnptr.rs"],
+  ],
+};
+
+for (const [filePath, fileFixes] of Object.entries(fixes)) {
+  const fullPath = path.join(ROOT, filePath);
+  if (!fs.existsSync(fullPath)) {
+    console.log("SKIP (not found): " + filePath);
+    continue;
+  }
+  let content = fs.readFileSync(fullPath, "utf-8");
+  let changed = false;
+  for (const [from, to] of fileFixes) {
+    while (content.includes(from)) {
+      content = content.replace(from, to);
+      changed = true;
+    }
+  }
+  if (changed) {
+    fs.writeFileSync(fullPath, content, "utf-8");
+    console.log("FIXED: " + filePath);
+  } else {
+    console.log("OK: " + filePath);
+  }
+}
+
+// Fix remaining colbymchenry references
+const colbyFiles = {
+  "README.md": [
+    ["colbymchenry.github.io/codegraph", "LTM.github.io/alpha-code-sense"],
+    ["colbymchenry.github.io/alpha-code-sense", "LTM.github.io/alpha-code-sense"],
+  ],
+  "scripts/pack-npm.sh": [
+    ["SCOPE=\"@colbymchenry\"", "SCOPE=\"@ltm\""],
+  ],
+  "site/astro.config.mjs": [
+    ["colbymchenry.github.io/codegraph", "LTM.github.io/alpha-code-sense"],
+    ["colbymchenry.github.io", "LTM.github.io"],
+  ],
+};
+
+for (const [filePath, fileFixes] of Object.entries(colbyFiles)) {
+  const fullPath = path.join(ROOT, filePath);
+  if (!fs.existsSync(fullPath)) {
+    console.log("SKIP: " + filePath);
+    continue;
+  }
+  let content = fs.readFileSync(fullPath, "utf-8");
+  let changed = false;
+  for (const [from, to] of fileFixes) {
+    while (content.includes(from)) {
+      content = content.replace(from, to);
+      changed = true;
+    }
+  }
+  if (changed) {
+    fs.writeFileSync(fullPath, content, "utf-8");
+    console.log("FIXED: " + filePath);
+  }
+}
+
+console.log("\nDone. Now run verification...");

package/scripts/count-codegraph.mjs

@@ -0,0 +1,26 @@
+#!/usr/bin/env node
+import fs from 'fs';
+import path from 'path';
+
+const root = process.cwd();
+let count = 0;
+
+function walk(dir) {
+  const entries = fs.readdirSync(dir, { withFileTypes: true });
+  for (const e of entries) {
+    const fp = path.join(dir, e.name);
+    if (e.isDirectory()) {
+      if (!['node_modules', '.git', 'codegraph-kernel'].includes(e.name)) walk(fp);
+    } else if (e.name.endsWith('.ts') && !e.name.endsWith('.d.ts')) {
+      const c = fs.readFileSync(fp, 'utf-8');
+      const matches = c.match(/(?<![a-zA-Z0-9_])CodeGraph(?![a-zA-Z0-9_])/g);
+      if (matches) {
+        count += matches.length;
+        console.log(path.relative(root, fp) + ': ' + matches.length + ' matches');
+      }
+    }
+  }
+}
+
+walk(path.join(root, 'src'));
+console.log('\nTotal standalone CodeGraph refs: ' + count);

package/scripts/deep-clean.mjs

@@ -0,0 +1,66 @@
+#!/usr/bin/env node
+import fs from "fs";
+import path from "path";
+const ROOT = process.cwd();
+const SKIP = new Set(["node_modules", ".git", "ltm-alpha-cs-kernel"]);
+
+const replacements = [
+  ["ltm-alpha-cs.js", "ltm-alpha-cs.js"],
+  ["ltm-alpha-cs.cmd", "ltm-alpha-cs.cmd"],
+  ["ltm-alpha-cs-old-node", "ltm-alpha-cs-old-node"],
+  ["/alpha-cs-", "/alpha-cs-"],
+  ["ltm-alpha-cs upgrade", "ltm-alpha-cs upgrade"],
+  ["ltm-alpha-cs install", "ltm-alpha-cs install"],
+  ["ltm-alpha-cs init", "ltm-alpha-cs init"],
+  ["ltm-alpha-cs uninit", "ltm-alpha-cs uninit"],
+  ["ltm-alpha-cs index", "ltm-alpha-cs index"],
+  ["ltm-alpha-cs sync", "ltm-alpha-cs sync"],
+  ["ltm-alpha-cs status", "ltm-alpha-cs status"],
+  ["ltm-alpha-cs query", "ltm-alpha-cs query"],
+  ["ltm-alpha-cs ui", "ltm-alpha-cs ui"],
+  ["ltm-alpha-cs version", "ltm-alpha-cs version"],
+  ["ltm-alpha-cs help", "ltm-alpha-cs help"],
+  ["ltm-alpha-cs uninstall", "ltm-alpha-cs uninstall"],
+  ["`ltm-alpha-cs", "`ltm-alpha-cs"],
+  [" ltm-alpha-cs ", " ltm-alpha-cs "],
+  ["ltm-alpha-cs)", "ltm-alpha-cs)"],
+  ["ltm-alpha-cs.", "ltm-alpha-cs."],
+  ["ltm-alpha-cs,", "ltm-alpha-cs,"],
+  ["ltm-alpha-cs\"s", "ltm-alpha-cs\"s"],
+  ["\"ltm-alpha-cs", "\"ltm-alpha-cs"],
+  ["ltm-alpha-cs\\", "ltm-alpha-cs\\"],
+  ["ltm-alpha-cs-upgrade", "alpha-cs-upgrade"],
+  ["ltm-alpha-cs-update", "alpha-cs-update"],
+  ["dist/bin/ltm-alpha-cs.js", "dist/bin/ltm-alpha-cs.js"],
+  ["LOCALAPPDATA}\\codegraph", "LOCALAPPDATA}\\alpha-cs"],
+];
+
+function walk(dir) {
+  for (const e of fs.readdirSync(dir, { withFileTypes: true })) {
+    const p = path.join(dir, e.name);
+    if (SKIP.has(e.name)) continue;
+    if (p.includes("/node_modules/") || p.includes("/.git/")) continue;
+    if (e.isDirectory()) { walk(p); continue; }
+    const ext = path.extname(e.name).toLowerCase();
+    if (![".ts",".js",".mjs",".json",".md",".sh",".yml",".yaml",".css",".html",".mts",".svelte",".ps1",".sql"].includes(ext)) continue;
+    if (e.name === "package-lock.json" || e.name === "Cargo.lock") continue;
+    try {
+      let c = fs.readFileSync(p, "utf-8");
+      let changed = false;
+      for (const [from, to] of replacements) {
+        while (c.includes(from)) {
+          c = c.replace(from, to);
+          changed = true;
+        }
+      }
+      if (changed) {
+        fs.writeFileSync(p, c, "utf-8");
+        console.log("  " + path.relative(ROOT, p));
+      }
+    } catch(e) {}
+  }
+}
+
+console.log("=== Deep Clean ===\n");
+walk(ROOT);
+console.log("\nDone");

package/scripts/dump-graph.mjs

@@ -0,0 +1,57 @@
+#!/usr/bin/env node
+/**
+ * Dump a .codegraph/codegraph.db graph by NATURAL KEYS (no rowids, no
+ * timestamps), sorted — two dumps diff clean iff the graphs are semantically
+ * identical. The byte-identical gate used by every perf/kernel PR:
+ *
+ *   node scripts/dump-graph.mjs <repo-or-db> > a.dump
+ *   node scripts/dump-graph.mjs <repo-or-db> > b.dump
+ *   diff a.dump b.dump
+ *
+ * Volatile fields excluded: nodes.updated_at, files.modified_at/indexed_at/
+ * content_hash+size (environment-dependent), edges.id / unresolved_refs.id
+ * (insertion rowids), and unresolved_refs.status (resolution bookkeeping —
+ * kept, actually: status is deterministic given the same input; excluded only
+ * if it proves flaky. We keep status.)
+ */
+
+import { DatabaseSync } from 'node:sqlite';
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+
+const arg = process.argv[2];
+if (!arg) {
+  console.error('usage: dump-graph.mjs <repo-root-or-db-path>');
+  process.exit(2);
+}
+let dbPath = arg;
+if (fs.statSync(arg).isDirectory()) {
+  dbPath = path.join(arg, '.codegraph', 'codegraph.db');
+}
+const db = new DatabaseSync(dbPath, { readOnly: true });
+
+function dump(title, sql) {
+  const rows = db.prepare(sql).all();
+  const lines = rows.map((r) => JSON.stringify(r)).sort();
+  process.stdout.write(`== ${title} (${lines.length})\n`);
+  for (const l of lines) process.stdout.write(l + '\n');
+}
+
+dump(
+  'nodes',
+  `SELECT id, kind, name, qualified_name, file_path, language, start_line, end_line,
+          start_column, end_column, docstring, signature, visibility, is_exported,
+          is_async, is_static, is_abstract, decorators, type_parameters, return_type
+   FROM nodes`
+);
+dump(
+  'edges',
+  `SELECT source, target, kind, metadata, line, col, provenance FROM edges`
+);
+dump(
+  'refs',
+  `SELECT from_node_id, reference_name, reference_kind, line, col, candidates,
+          file_path, language, status, name_tail
+   FROM unresolved_refs`
+);
+dump('files', `SELECT path, language, node_count FROM files`);

package/scripts/extract-release-notes.mjs

@@ -0,0 +1,130 @@
+#!/usr/bin/env node
+/**
+ * Extract a release-notes block from CHANGELOG.md for a given version
+ * (or unwrap text supplied on stdin), then join hard-wrapped paragraphs.
+ *
+ * Why: GitHub renders release-note Markdown with GFM hard breaks, so
+ * every `\n` becomes `<br>`. The CHANGELOG is hard-wrapped at ~75
+ * chars for readable diffs, which then renders as awkward visible
+ * line breaks on the release page. This script joins indented
+ * continuation lines into a single line per bullet so the GFM
+ * renderer produces clean paragraphs.
+ *
+ * Repo-level CHANGELOG.md viewing is unaffected (CommonMark treats
+ * newlines as spaces there).
+ *
+ * Usage:
+ *   extract-release-notes.mjs <version>     # read CHANGELOG.md
+ *   extract-release-notes.mjs --stdin       # read from stdin (any text)
+ */
+
+import { readFileSync } from 'fs';
+
+const arg = process.argv[2];
+if (!arg) {
+  console.error('usage: extract-release-notes.mjs <version> | --stdin');
+  process.exit(1);
+}
+
+let block;
+if (arg === '--stdin') {
+  block = readFileSync(0, 'utf8').replace(/\r\n?/g, '\n').split('\n');
+} else {
+  const version = arg;
+  const escaped = version.replace(/\./g, '\\.');
+  const headerRe = new RegExp(`^## \\[${escaped}\\]`);
+  const anyHeaderRe = /^## \[/;
+  const lines = readFileSync('CHANGELOG.md', 'utf8').split('\n');
+  const start = lines.findIndex((l) => headerRe.test(l));
+  if (start === -1) {
+    console.error(`no '## [${version}]' entry found in CHANGELOG.md`);
+    process.exit(1);
+  }
+  const after = lines.findIndex((l, i) => i > start && anyHeaderRe.test(l));
+  block = lines.slice(start, after === -1 ? lines.length : after);
+}
+
+// Track a stack of `{ indent: number }` frames so a continuation line
+// can attach to the right ancestor. Handles the post-nested-list
+// continuation pattern:
+//
+//     - top-level
+//         - nested
+//       back to top-level  <- 2-space indent, joins the top-level bullet
+const out = [];
+let buf = '';
+let stack = [];
+
+function flushBuf() {
+  if (buf !== '') {
+    out.push(buf);
+    buf = '';
+  }
+}
+
+function leadingSpaces(s) {
+  const m = s.match(/^(\s*)/);
+  return m ? m[1].length : 0;
+}
+
+// Bullets: `-`, `*`, `digit.` only. `+` is intentionally excluded — the
+// CHANGELOG uses literal `+` inline (`config + instructions`) and we
+// don't want to misread those as nested bullets.
+const listItemRe = /^(\s*)([-*]|\d+\.)\s+/;
+const fenceRe = /^\s*```/;
+
+let inFence = false;
+
+for (const line of block) {
+  // Fenced code blocks: pass through verbatim, no joining.
+  if (fenceRe.test(line)) {
+    flushBuf();
+    stack = [];
+    out.push(line);
+    inFence = !inFence;
+    continue;
+  }
+  if (inFence) {
+    out.push(line);
+    continue;
+  }
+  if (/^\s*$/.test(line)) {
+    flushBuf();
+    out.push('');
+    continue;
+  }
+  if (/^#/.test(line)) {
+    flushBuf();
+    stack = [];
+    out.push(line);
+    continue;
+  }
+  const itemMatch = line.match(listItemRe);
+  if (itemMatch) {
+    flushBuf();
+    const indent = itemMatch[1].length;
+    while (stack.length > 0 && stack[stack.length - 1].indent >= indent) {
+      stack.pop();
+    }
+    stack.push({ indent });
+    buf = line;
+    continue;
+  }
+  if (/^\s/.test(line)) {
+    const indent = leadingSpaces(line);
+    while (stack.length > 1 && stack[stack.length - 1].indent >= indent) {
+      flushBuf();
+      stack.pop();
+    }
+    const trimmed = line.replace(/^\s+/, '');
+    buf = buf === '' ? trimmed : `${buf} ${trimmed}`;
+    continue;
+  }
+  flushBuf();
+  stack = [];
+  out.push(line);
+}
+flushBuf();
+
+process.stdout.write(out.join('\n'));
+if (!out[out.length - 1]?.endsWith('\n')) process.stdout.write('\n');

package/scripts/final-codegraph-cleanup.mjs

@@ -0,0 +1,57 @@
+#!/usr/bin/env node
+import fs from 'fs';
+import path from 'path';
+
+const root = process.cwd();
+
+function fixFile(rel, replacements) {
+  const fp = path.join(root, rel);
+  if (!fs.existsSync(fp)) {
+    console.log('SKIP: ' + rel);
+    return;
+  }
+  let c = fs.readFileSync(fp, 'utf-8');
+  let newc = c;
+  for (const [old, next] of replacements) {
+    newc = newc.replace(old, next);
+  }
+  if (newc !== c) {
+    fs.writeFileSync(fp, newc);
+    console.log('FIXED: ' + rel);
+  } else {
+    console.log('OK: ' + rel);
+  }
+}
+
+fixFile('src/bin/codegraph.ts', [
+  ['CodeGraph MCP server', 'Alpha Code Sense MCP server'],
+  ['CodeGraph MCP Server', 'Alpha Code Sense MCP Server'],
+  ['CodeGraph viewer', 'Alpha Code Sense viewer'],
+  ['CodeGraph daemons', 'Alpha Code Sense daemons'],
+  ['CodeGraph background daemons', 'Alpha Code Sense background daemons'],
+  ['Manage running CodeGraph', 'Manage running Alpha Code Sense'],
+  ['No CodeGraph daemons', 'No Alpha Code Sense daemons'],
+  ['Open the CodeGraph viewer', 'Open the Alpha Code Sense viewer'],
+  ['Start CodeGraph as an MCP', 'Start Alpha Code Sense as an MCP'],
+  ['form CodeGraph stores', 'form Alpha Code Sense stores'],
+  ['CodeGraph is available', 'Alpha Code Sense is available'],
+  ['Self-update, however CodeGraph was installed', 'Self-update, however Alpha Code Sense was installed'],
+  ['Print the installed CodeGraph version', 'Print the installed Alpha Code Sense version'],
+]);
+
+fixFile('src/bin/node-version-check.ts', [
+  ['reliably crashes CodeGraph', 'reliably crashes Alpha Code Sense'],
+  ['CodeGraph detects', 'Alpha Code Sense detects'],
+  ['when CodeGraph compiles', 'when Alpha Code Sense compiles'],
+  ['CodeGraph WILL crash', 'Alpha Code Sense WILL crash'],
+  ['CodeGraph relies on', 'Alpha Code Sense relies on'],
+  ['CodeGraph depends on', 'Alpha Code Sense depends on'],
+  ['CodeGraph can start', 'Alpha Code Sense can start'],
+  ['CodeGraph documents', 'Alpha Code Sense documents'],
+]);
+
+fixFile('src/upgrade/index.ts', [
+]);
+// Already handled
+
+console.log('Done');