@liumir/lmcode 0.5.13

package/dist/suppress-sqlite-warning-C2VB0doZ.mjs

@@ -0,0 +1,52 @@
+#!/usr/bin/env node
+import { fileURLToPath as __cjsShimFileURLToPath } from 'node:url';
+import { dirname as __cjsShimDirname } from 'node:path';
+const __filename = __cjsShimFileURLToPath(import.meta.url);
+const __dirname = __cjsShimDirname(__filename);
+//#region src/utils/suppress-sqlite-warning.ts
+/**
+* Suppress Node's ExperimentalWarning for the built-in `node:sqlite` module.
+*
+* Node emits this warning while `node:sqlite` is loaded as a transitive
+* dependency during ESM module evaluation, before any app code can intercept
+* it via `process.emitWarning` or `process.on('warning')`. We filter the known
+* warning text from stderr to keep startup output clean.
+*/
+const originalWrite = process.stderr.write.bind(process.stderr);
+let expectingTraceSuggestion = false;
+function isSQLiteExperimentalWarning(line) {
+	return /^\(node:\d+\) ExperimentalWarning: SQLite is an experimental feature/.test(line);
+}
+function isTraceSuggestion(line) {
+	return line.startsWith("(Use `node --trace-warnings");
+}
+process.stderr.write = (chunk, ...args) => {
+	const lines = (typeof chunk === "string" ? chunk : Buffer.from(chunk).toString("utf8")).split("\n");
+	let changed = false;
+	const kept = [];
+	for (const line of lines) {
+		if (isSQLiteExperimentalWarning(line)) {
+			expectingTraceSuggestion = true;
+			changed = true;
+			continue;
+		}
+		if (expectingTraceSuggestion && isTraceSuggestion(line)) {
+			expectingTraceSuggestion = false;
+			changed = true;
+			continue;
+		}
+		expectingTraceSuggestion = false;
+		kept.push(line);
+	}
+	if (changed) {
+		const filtered = kept.join("\n");
+		if (filtered.length === 0) {
+			args.find((a) => typeof a === "function")?.();
+			return true;
+		}
+		return originalWrite(filtered, ...args);
+	}
+	return originalWrite(chunk, ...args);
+};
+//#endregion
+export {};

package/package.json

@@ -0,0 +1,80 @@
+{
+  "name": "@liumir/lmcode",
+  "version": "0.5.13",
+  "description": "A terminal-native AI agent for builders",
+  "license": "MIT",
+  "author": "liumir",
+  "homepage": "https://github.com/Lyin01/LMcode-cli/tree/main/apps/lmcode#readme",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/Lyin01/LMcode-cli.git",
+    "directory": "apps/lmcode"
+  },
+  "bugs": {
+    "url": "https://github.com/Lyin01/LMcode-cli/issues"
+  },
+  "keywords": [
+    "lmcode",
+    "cli",
+    "agent",
+    "coding-agent",
+    "ai",
+    "tui"
+  ],
+  "bin": {
+    "lm": "dist/main.mjs"
+  },
+  "files": [
+    "dist",
+    "icon.ico",
+    "scripts/postinstall.mjs",
+    "scripts/postinstall"
+  ],
+  "type": "module",
+  "imports": {
+    "#/*": [
+      "./src/*.ts",
+      "./src/*/index.ts"
+    ]
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "build": "tsdown",
+    "dev": "node scripts/dev.mjs",
+    "dev:cli-only": "tsx --import ../../build/register-raw-text-loader.mjs ./src/main.ts",
+    "dev:prod": "node dist/main.mjs",
+    "clean": "rm -rf dist",
+    "typecheck": "tsc -p tsconfig.json --noEmit",
+    "test": "pnpm -w run build:packages && vitest run",
+    "e2e": "pnpm -w run build:packages && LMCODE_E2E=1 vitest run test/e2e",
+    "e2e:real": "pnpm -w run build:packages && LMCODE_E2E_REAL=1 vitest run test/e2e/real-llm-smoke.e2e.test.ts",
+    "preinstall": "node -e \"console.log('\\n📦 正在安装 lmcode，请稍候...\\n')\"",
+    "postinstall": "node scripts/postinstall.mjs",
+    "smoke": "node dist/main.mjs --version"
+  },
+  "dependencies": {
+    "@earendil-works/pi-tui": "^0.78.1",
+    "@mariozechner/clipboard": "^0.3.2",
+    "chalk": "^5.4.1",
+    "cli-highlight": "^2.1.11",
+    "commander": "^13.1.0",
+    "semver": "^7.7.4",
+    "smol-toml": "^1.6.1",
+    "zod": "^4.3.6"
+  },
+  "devDependencies": {
+    "@modelcontextprotocol/sdk": "^1.29.0",
+    "@lmcode-cli/agent-core": "workspace:^",
+    "@lmcode-cli/config": "workspace:^",
+    "@lmcode-cli/migration-legacy": "workspace:^",
+    "@lmcode-cli/lmcode-sdk": "workspace:^",
+    "@lmcode/memory": "workspace:*",
+    "@types/semver": "^7.7.0",
+    "tsx": "^4.21.0"
+  },
+  "engines": {
+    "node": ">=22.19.0"
+  }
+}

package/scripts/postinstall/migrate.mjs

@@ -0,0 +1,351 @@
+/**
+ * Detection of the previous Python `scream-cli` shim and the actual
+ * filesystem operations that perform (or refuse) the rename.
+ *
+ * Detection:
+ *   - {@link detectLegacyShims}: walks the caller-supplied
+ *     `pathString` and returns every legacy `lm` shim along the
+ *     way (in PATH order). A shim qualifies when it realpath-resolves
+ *     outside our own installed package root and its head 4 KiB
+ *     contains the `scream_cli` module marker — the setuptools
+ *     entry-point format produced by `uv tool install`,
+ *     `pipx install`, `pip install`, etc. Returning all hits (not
+ *     just the first) matters because a user with both uv- and
+ *     pipx-installed `scream-cli` has two legacy shims in different
+ *     dirs, and renaming only the earlier one leaves the later one
+ *     shadowing our new CLI. Callers should pass the `detection`
+ *     field from `postinstallPaths()` so detection sees the union of
+ *     the shell PATH and the installer's PATH.
+ *   - {@link isLegacyShim}: same criterion in standalone form, used to
+ *     decide whether an existing `scream-legacy` is itself a legacy CLI
+ *     (safe to consolidate over) or a user-managed file (preserve).
+ *
+ * Classify + execute (two-phase):
+ *   - {@link classifyShim}: pre-flight inspection that says what we
+ *     COULD do to a given shim. Returns one of `renameable`,
+ *     `consolidate`, `delete-only`, `blocked`. No filesystem writes.
+ *   - {@link renameInPlace} / {@link deleteShim}: the primitive
+ *     operations that actually mutate the filesystem. Run after the
+ *     orchestrator has looked at the full set of classifications and
+ *     decided to proceed.
+ *
+ * Splitting classification from execution lets the orchestrator make
+ * the abort-or-proceed decision once, against the whole detected set,
+ * rather than discovering mid-loop that something failed and ending up
+ * with a misleading "scream now launches the new CLI" notice in front of
+ * a "permission denied" notice. Uses `fs.lstat` (not `fs.access`) to
+ * detect dangling symlinks at the target so we don't clobber them.
+ */
+
+import { constants as fsConstants, promises as fs } from 'node:fs';
+import { delimiter, dirname, extname, join, sep } from 'node:path';
+
+const LEGACY_BIN = 'scream';
+const LEGACY_RENAME = 'scream-legacy';
+const PYTHON_MARKER = 'scream_cli';
+const IS_WINDOWS = process.platform === 'win32';
+
+// Read window for the marker sniff.
+//   POSIX: setuptools entry-point scripts are a few hundred bytes —
+//          4 KiB is generous.
+//   Windows: `uv tool install` produces a Rust-built launcher .exe
+//            (~45 KiB) and the `scream_cli` module name sits embedded
+//            near the END of the file (verified offset ≈ 44103 on
+//            uv 0.11). Cap reads at 256 KiB so a hostile or
+//            unexpectedly large file can't make us hold a lot of
+//            memory.
+const SHIM_SNIFF_BYTES_POSIX = 4096;
+const SHIM_SNIFF_BYTES_WINDOWS_MAX = 256 * 1024;
+
+function pathEntries(pathString) {
+  if (!pathString) return [];
+  const seen = new Set();
+  const out = [];
+  for (const entry of pathString.split(delimiter)) {
+    if (!entry || seen.has(entry)) continue;
+    seen.add(entry);
+    out.push(entry);
+  }
+  return out;
+}
+
+/**
+ * Expand `lm` into the set of filenames that resolve as executables
+ * on this platform. POSIX → just `[,]`. Windows → adds every
+ * `PATHEXT` extension (so we find `scream.exe`, `scream.cmd`, etc).
+ */
+function executableCandidates(basename) {
+  if (!IS_WINDOWS) return [basename];
+  const pathext = (process.env['PATHEXT'] ?? '.EXE;.CMD;.BAT;.COM')
+    .toLowerCase()
+    .split(';')
+    .map((e) => e.trim())
+    .filter(Boolean);
+  return [basename, ...pathext.map((ext) => basename + ext)];
+}
+
+async function isExecutableFile(filePath) {
+  try {
+    const info = await fs.stat(filePath);
+    if (!info.isFile()) return false;
+    // Windows: stat().mode doesn't reflect ACLs in any useful way.
+    // Callers already restrict to PATHEXT candidates, so existence
+    // suffices.
+    if (IS_WINDOWS) return true;
+    return (info.mode & 0o111) !== 0;
+  } catch {
+    return false;
+  }
+}
+
+async function readShimHead(filePath) {
+  let handle;
+  try {
+    handle = await fs.open(filePath, 'r');
+    const stat = await handle.stat();
+    const limit = IS_WINDOWS ? SHIM_SNIFF_BYTES_WINDOWS_MAX : SHIM_SNIFF_BYTES_POSIX;
+    const target = Math.min(stat.size, limit);
+    const buffer = Buffer.alloc(target);
+    const { bytesRead } = await handle.read(buffer, 0, target, 0);
+    // `latin1` is a 1-to-1 byte→char mapping; we're searching for an
+    // ASCII substring, so we don't want UTF-8 decoding to mangle the
+    // bytes around the marker.
+    return buffer.subarray(0, bytesRead).toString('latin1');
+  } catch {
+    return null;
+  } finally {
+    if (handle) await handle.close().catch(() => {});
+  }
+}
+
+/**
+ * Walk `pathString` and return every legacy `lm` shim along the
+ * way, in PATH order. The orchestrator renames each in turn — a
+ * single rename is insufficient when the user has multiple legacy
+ * installs (e.g. one from `uv tool install` and another from `pipx
+ * install`) in different directories, because the survivor still
+ * shadows the new CLI.
+ *
+ * Each entry has the same shape as the previous single-return
+ * value: `{ shimPath, realPath }`. The empty array means
+ * "fresh-install / no-op".
+ */
+export async function detectLegacyShims(ownRoot, pathString) {
+  const ownRootPrefix = ownRoot ? ownRoot + sep : null;
+  const candidates = executableCandidates(LEGACY_BIN);
+  const results = [];
+  const seenShims = new Set();
+
+  for (const dir of pathEntries(pathString)) {
+    for (const name of candidates) {
+      const shimPath = join(dir, name);
+      if (seenShims.has(shimPath)) continue;
+      if (!(await isExecutableFile(shimPath))) continue;
+
+      let realPath;
+      try {
+        realPath = await fs.realpath(shimPath);
+      } catch {
+        continue;
+      }
+
+      // Defence-in-depth: never touch a `lm` that resolves into our
+      // own installed package. The `scream_cli` marker check below
+      // already excludes the manager's generated wrapper today, but
+      // this layer keeps us safe if anything in our bundle ever
+      // happens to contain the marker substring.
+      if (
+        ownRootPrefix !== null &&
+        (realPath === ownRoot || realPath.startsWith(ownRootPrefix))
+      ) {
+        continue;
+      }
+
+      const head = await readShimHead(realPath);
+      if (!head || !head.includes(PYTHON_MARKER)) continue;
+
+      seenShims.add(shimPath);
+      results.push({ shimPath, realPath });
+    }
+  }
+  return results;
+}
+
+/**
+ * Does the file at `p` look like the legacy Python `scream-cli`?
+ *
+ * Same criterion as {@link detectLegacyShim} uses to recognize the
+ * original shim: realpath-resolvable and the first 4 KiB of the
+ * resolved file contains the `scream_cli` module name. Used to decide
+ * whether an existing `scream-legacy` is itself a legacy shim (safe to
+ * drop the duplicate `lm`) or a user-managed file we must not
+ * clobber.
+ */
+export async function isLegacyShim(p) {
+  let real;
+  try {
+    real = await fs.realpath(p);
+  } catch {
+    return false;
+  }
+  const head = await readShimHead(real);
+  return Boolean(head && head.includes(PYTHON_MARKER));
+}
+
+async function pathExists(p) {
+  try {
+    // lstat (not access/stat) so a dangling symlink at `p` still
+    // reports as existing — `fs.access` follows symlinks and would
+    // return ENOENT for a broken link, after which `fs.rename` would
+    // silently replace it.
+    await fs.lstat(p);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * Compute where `shimPath` should be renamed to. Preserves the file
+ * extension so a Windows `C:\…\scream.exe` ends up at `scream-legacy.exe`
+ * rather than an extension-less `scream-legacy` that `scream.exe -- legacy`
+ * shells won't run.
+ */
+function renameTargetFor(shimPath) {
+  const ext = extname(shimPath);  // "" on POSIX, ".exe" on Windows
+  return join(dirname(shimPath), LEGACY_RENAME + ext);
+}
+
+/**
+ * Is the directory containing `shimPath` a system-managed location
+ * the current user can't write to?
+ *
+ * POSIX: dir owned by uid 0 (root) — captures
+ *   `sudo pip install scream-cli` → `/usr/local/bin/`.
+ *
+ * Windows: dir under one of the well-known system roots
+ *   (`C:\Program Files`, `C:\ProgramData`, `C:\Windows`). uv tool
+ *   installs land in user space (`%USERPROFILE%\.local\bin`) so this
+ *   path almost never fires on Windows in practice, but the heuristic
+ *   correctly classifies the rare admin-prefix install case.
+ *
+ * The dedicated permission-denied notice (`logPermissionDenied`)
+ * uses this to switch from a bare "rename it manually" message to a
+ * sudo-aware / admin-aware explanation.
+ */
+async function isSystemOwnedDir(shimPath) {
+  if (IS_WINDOWS) {
+    const dir = dirname(shimPath).toLowerCase();
+    const systemRoots = [
+      'c:\\program files',
+      'c:\\program files (x86)',
+      'c:\\programdata',
+      'c:\\windows',
+    ];
+    return systemRoots.some(
+      (root) => dir === root || dir.startsWith(root + '\\'),
+    );
+  }
+  try {
+    const info = await fs.stat(dirname(shimPath));
+    return info.uid === 0;
+  } catch {
+    return false;
+  }
+}
+
+async function canWriteDir(dir) {
+  try {
+    // For `fs.rename` and `fs.unlink` the parent dir needs to be both
+    // writable and executable (POSIX `wx`). `fs.access` follows the
+    // same semantics. On Windows ACL details are coarse but
+    // `fs.access(W_OK)` is a reasonable best-effort.
+    await fs.access(dir, fsConstants.W_OK | fsConstants.X_OK);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * Pre-flight inspection of a single legacy shim. Returns what action
+ * we could take WITHOUT executing it. The orchestrator uses these
+ * classifications to decide the whole-set strategy (abort vs proceed,
+ * which shim becomes scream-legacy) before any filesystem writes
+ * happen.
+ *
+ * Result shapes (all carry `shimPath` and `target` so the renderer
+ * has the paths):
+ *   - `renameable`     : can `fs.rename(shim → target)` cleanly;
+ *                        target slot is free.
+ *   - `consolidate`    : target already exists and is itself a legacy
+ *                        shim; we'd `fs.unlink(shim)` and leave the
+ *                        existing `scream-legacy` as the canonical
+ *                        fallback (functionally equivalent — same
+ *                        upstream package).
+ *   - `delete-only`    : target exists but is a user-managed file we
+ *                        won't clobber. We can still `fs.unlink(shim)`
+ *                        to stop the shadowing; the
+ *                        "preserve original scream" invariant fails for
+ *                        THIS dir (we tell the user).
+ *   - `blocked`        : we can't write to the parent dir. Carries
+ *                        `isSystemPath` so the renderer can suggest
+ *                        sudo (POSIX) or admin PowerShell (Windows).
+ */
+export async function classifyShim(shimPath) {
+  const target = renameTargetFor(shimPath);
+  const dir = dirname(shimPath);
+
+  if (!(await canWriteDir(dir))) {
+    return {
+      kind: 'blocked',
+      shimPath,
+      target,
+      isSystemPath: await isSystemOwnedDir(shimPath),
+    };
+  }
+
+  if (await pathExists(target)) {
+    if (await isLegacyShim(target)) {
+      return { kind: 'consolidate', shimPath, target };
+    }
+    return { kind: 'delete-only', shimPath, target };
+  }
+
+  return { kind: 'renameable', shimPath, target };
+}
+
+/**
+ * Execute an `fs.rename`. Pre-flight classification establishes
+ * whether this is expected to succeed; this primitive just runs the
+ * call and wraps the error.
+ */
+export async function renameInPlace(shimPath, target) {
+  try {
+    await fs.rename(shimPath, target);
+    return { success: true };
+  } catch (err) {
+    const code = err && typeof err === 'object' ? err.code : undefined;
+    const message = err instanceof Error ? err.message : String(err);
+    return { success: false, code, message };
+  }
+}
+
+/**
+ * Execute an `fs.unlink`. Used when:
+ *   - we're consolidating onto an existing legacy `scream-legacy`, or
+ *   - we couldn't rename (foreign target) but can still remove the
+ *     shadow, or
+ *   - this is a non-first shim and we just want to clear it out so
+ *     PATH order resolves to our new CLI.
+ */
+export async function deleteShim(shimPath) {
+  try {
+    await fs.unlink(shimPath);
+    return { success: true };
+  } catch (err) {
+    const code = err && typeof err === 'object' ? err.code : undefined;
+    const message = err instanceof Error ? err.message : String(err);
+    return { success: false, code, message };
+  }
+}