litopencode 0.0.0

package/tools/check-version-lockstep.mjs

@@ -0,0 +1,144 @@
+#!/usr/bin/env node
+import fs from "node:fs/promises";
+import path from "node:path";
+import process from "node:process";
+
+class VersionLockstepError extends Error {
+  constructor(message, exitCode) {
+    super(message);
+    this.name = "VersionLockstepError";
+    this.exitCode = exitCode;
+  }
+}
+
+function parseArgs(argv) {
+  const options = {
+    packagePath: "package.json",
+    lockfilePath: "package-lock.json"
+  };
+
+  for (let index = 0; index < argv.length; index += 1) {
+    const arg = argv[index];
+    const next = argv[index + 1];
+    if (arg === "--package" && next !== undefined) {
+      options.packagePath = next;
+      index += 1;
+    } else if (arg === "--lockfile" && next !== undefined) {
+      options.lockfilePath = next;
+      index += 1;
+    } else {
+      throw new VersionLockstepError(`unknown or incomplete argument: ${arg}`, 2);
+    }
+  }
+
+  return options;
+}
+
+async function readJson(filePath, label) {
+  try {
+    return JSON.parse(await fs.readFile(filePath, "utf8"));
+  } catch (error) {
+    if (label === "package-lock.json" && error && error.code === "ENOENT") {
+      return undefined;
+    }
+    const detail = error instanceof Error ? error.message : String(error);
+    throw new VersionLockstepError(`cannot read or parse ${label}: ${detail}`, 2);
+  }
+}
+
+function requireObject(value, label) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) {
+    throw new VersionLockstepError(`${label} must be a JSON object`, 2);
+  }
+  return value;
+}
+
+function requireString(object, field, label) {
+  const value = object[field];
+  if (typeof value !== "string" || value.trim() === "") {
+    throw new VersionLockstepError(`${label} ${field} must be a non-empty string`, 2);
+  }
+  return value;
+}
+
+function readPackageIdentity(parsedPackage) {
+  const packageObject = requireObject(parsedPackage, "package.json");
+  return {
+    name: requireString(packageObject, "name", "package.json"),
+    version: requireString(packageObject, "version", "package.json")
+  };
+}
+
+function readLockfileIdentity(parsedLockfile) {
+  if (parsedLockfile === undefined) {
+    return undefined;
+  }
+  const lockfileObject = requireObject(parsedLockfile, "package-lock.json");
+  return {
+    name: requireString(lockfileObject, "name", "package-lock.json"),
+    version: requireString(lockfileObject, "version", "package-lock.json"),
+    packages: lockfileObject.packages
+  };
+}
+
+function readRootPackageEntry(packages) {
+  if (packages === undefined) {
+    return undefined;
+  }
+  const packagesObject = requireObject(packages, "package-lock.json packages");
+  const rootEntry = packagesObject[""];
+  if (rootEntry === undefined) {
+    return undefined;
+  }
+  const rootObject = requireObject(rootEntry, 'package-lock.json packages[""]');
+  return {
+    name: requireString(rootObject, "name", 'package-lock.json packages[""]'),
+    version: requireString(rootObject, "version", 'package-lock.json packages[""]')
+  };
+}
+
+function assertEqual(actual, expected, label) {
+  if (actual !== expected) {
+    throw new VersionLockstepError(`${label} mismatch: expected ${expected}, found ${actual}`, 1);
+  }
+}
+
+async function main() {
+  try {
+    const options = parseArgs(process.argv.slice(2));
+    const packagePath = path.resolve(options.packagePath);
+    const lockfilePath = path.resolve(options.lockfilePath);
+    const [parsedPackage, parsedLockfile] = await Promise.all([
+      readJson(packagePath, "package.json"),
+      readJson(lockfilePath, "package-lock.json")
+    ]);
+    const packageIdentity = readPackageIdentity(parsedPackage);
+    const lockfileIdentity = readLockfileIdentity(parsedLockfile);
+    if (lockfileIdentity === undefined) {
+      console.log(`version lockstep skipped: package-lock.json not present for ${packageIdentity.name}@${packageIdentity.version}`);
+      return;
+    }
+    const rootEntryIdentity = readRootPackageEntry(lockfileIdentity.packages);
+
+    assertEqual(lockfileIdentity.name, packageIdentity.name, "lockfile root name");
+    assertEqual(lockfileIdentity.version, packageIdentity.version, "lockfile root version");
+
+    if (rootEntryIdentity !== undefined) {
+      assertEqual(rootEntryIdentity.name, packageIdentity.name, 'lockfile packages[""] name');
+      assertEqual(rootEntryIdentity.version, packageIdentity.version, 'lockfile packages[""] version');
+    }
+
+    console.log(`version lockstep passed: ${packageIdentity.name}@${packageIdentity.version}`);
+  } catch (error) {
+    if (error instanceof VersionLockstepError) {
+      console.error(`version lockstep failed: ${error.message}`);
+      process.exitCode = error.exitCode;
+      return;
+    }
+    const message = error instanceof Error ? error.message : String(error);
+    console.error(`version lockstep failed: ${message}`);
+    process.exitCode = 2;
+  }
+}
+
+await main();

package/tools/run-build.mjs

@@ -0,0 +1,34 @@
+#!/usr/bin/env node
+import fs from "node:fs";
+import { spawnSync } from "node:child_process";
+import process from "node:process";
+
+const tscBin = "node_modules/typescript/bin/tsc";
+const sourceEntry = "src/index.ts";
+const builtEntry = "dist/index.js";
+
+if (!fs.existsSync(sourceEntry)) {
+  if (fs.existsSync(builtEntry)) {
+    console.log("build skipped: source files are not present in this packed artifact.");
+    process.exit(0);
+  }
+  console.error("build failed: source files are missing and no built dist artifact exists.");
+  process.exit(1);
+}
+
+if (!fs.existsSync(tscBin)) {
+  if (fs.existsSync(builtEntry)) {
+    console.log("build skipped: TypeScript dev dependency is not installed and dist already exists.");
+    process.exit(0);
+  }
+  console.error("build failed: TypeScript dev dependency is not installed.");
+  process.exit(1);
+}
+
+const result = spawnSync(process.execPath, [tscBin, "-p", "tsconfig.build.json"], {
+  cwd: process.cwd(),
+  encoding: "utf8",
+  stdio: "inherit"
+});
+
+process.exit(result.status ?? 1);

package/tools/run-typecheck.mjs

@@ -0,0 +1,25 @@
+#!/usr/bin/env node
+import fs from "node:fs";
+import { spawnSync } from "node:child_process";
+import process from "node:process";
+
+const tscBin = "node_modules/typescript/bin/tsc";
+const sourceEntry = "src/index.ts";
+
+if (!fs.existsSync(tscBin)) {
+  console.log("typecheck skipped: TypeScript dev dependency is not installed in this packed artifact.");
+  process.exit(0);
+}
+
+if (!fs.existsSync(sourceEntry)) {
+  console.log("typecheck skipped: TypeScript source files are not present in this packed artifact.");
+  process.exit(0);
+}
+
+const result = spawnSync(process.execPath, [tscBin, "--noEmit"], {
+  cwd: process.cwd(),
+  encoding: "utf8",
+  stdio: "inherit"
+});
+
+process.exit(result.status ?? 1);

package/tools/scan-legacy-tokens.mjs

@@ -0,0 +1,211 @@
+#!/usr/bin/env node
+import fs from "node:fs/promises";
+import path from "node:path";
+import process from "node:process";
+
+const LEGACY_TOKEN_PARTS = [
+  ["om", "o"],
+  ["oh-my-open", "agent"],
+  ["oh-my-open", "code"],
+  ["sisyphus", "labs"],
+  ["lazy", "codex"],
+  ["lazy", "claude"],
+  ["code-yeong", "yu"],
+  ["u", "lw"],
+  ["ultra", "work"],
+  ["ultra", "goal"]
+];
+const LEGACY_TOKENS = LEGACY_TOKEN_PARTS.map((parts) => parts.join(""));
+const TOKEN_PATTERN = new RegExp(
+  `(?<![A-Za-z0-9_])(${LEGACY_TOKENS.map(escapeRegex).join("|")})(?![A-Za-z0-9_])`,
+  "giu"
+);
+const SKIPPED_DIRS = new Set([".git", ".litcodex", ".litopencode", "node_modules", "# REFERENCE"]);
+const SKIPPED_FILES = new Set(["tools/scan-legacy-tokens.mjs", "tools/legacy-token-allowlist.json"]);
+const SKIPPED_EXTENSIONS = [".tgz", ".zip", ".tar", ".gz", ".bz2", ".xz", ".7z"];
+
+class AllowlistError extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "AllowlistError";
+  }
+}
+
+function escapeRegex(value) {
+  return value.replace(/[.*+?^${}()|[\]\\]/gu, "\\$&");
+}
+
+function parseArgs(argv) {
+  const options = {
+    root: process.cwd(),
+    allowlist: "tools/legacy-token-allowlist.json"
+  };
+
+  for (let index = 0; index < argv.length; index += 1) {
+    const arg = argv[index];
+    const next = argv[index + 1];
+    if (arg === "--root" && next !== undefined) {
+      options.root = next;
+      index += 1;
+    } else if (arg === "--allowlist" && next !== undefined) {
+      options.allowlist = next;
+      index += 1;
+    } else {
+      throw new AllowlistError(`unknown or incomplete argument: ${arg}`);
+    }
+  }
+
+  return options;
+}
+
+function normalizeRelativePath(value) {
+  return value.split(path.sep).join("/");
+}
+
+function isSkippedFile(relativePath, extraSkippedFiles) {
+  if (SKIPPED_FILES.has(relativePath) || extraSkippedFiles.has(relativePath)) {
+    return true;
+  }
+  if (relativePath === "pack-report.json" || relativePath.endsWith(".pack-report.json")) {
+    return true;
+  }
+  return SKIPPED_EXTENSIONS.some((extension) => relativePath.endsWith(extension));
+}
+
+function requireString(entry, field, index) {
+  const value = entry[field];
+  if (typeof value !== "string" || value.trim() === "") {
+    throw new AllowlistError(`entries[${index}].${field} must be a non-empty string`);
+  }
+  return value;
+}
+
+async function readAllowlist(allowlistPath) {
+  let parsed;
+  try {
+    parsed = JSON.parse(await fs.readFile(allowlistPath, "utf8"));
+  } catch (error) {
+    if (error && error.code === "ENOENT") {
+      return [];
+    }
+    throw new AllowlistError(`cannot read or parse allowlist: ${error.message}`);
+  }
+
+  if (!parsed || typeof parsed !== "object" || !Array.isArray(parsed.entries)) {
+    throw new AllowlistError("allowlist must be an object with an entries array");
+  }
+
+  return parsed.entries.map((entry, index) => {
+    if (!entry || typeof entry !== "object" || Array.isArray(entry)) {
+      throw new AllowlistError(`entries[${index}] must be an object`);
+    }
+    const token = requireString(entry, "token", index).toLowerCase();
+    if (!LEGACY_TOKENS.includes(token)) {
+      throw new AllowlistError(`entries[${index}].token must be one of: ${LEGACY_TOKENS.join(", ")}`);
+    }
+    return {
+      path: normalizeRelativePath(requireString(entry, "path", index)),
+      token,
+      reason: requireString(entry, "reason", index),
+      removalCondition: requireString(entry, "removalCondition", index),
+      match: requireString(entry, "match", index)
+    };
+  });
+}
+
+function isAllowed(match, allowlist) {
+  return allowlist.some((entry) => (
+    entry.path === match.path
+    && entry.token === match.token
+    && entry.match === match.line
+  ));
+}
+
+async function collectFiles(root, extraSkippedFiles, current = root) {
+  const entries = await fs.readdir(current, { withFileTypes: true });
+  const files = [];
+  for (const entry of entries) {
+    if (entry.isDirectory() && SKIPPED_DIRS.has(entry.name)) {
+      continue;
+    }
+    const fullPath = path.join(current, entry.name);
+    const relativePath = normalizeRelativePath(path.relative(root, fullPath));
+    if (entry.isDirectory()) {
+      files.push(...await collectFiles(root, extraSkippedFiles, fullPath));
+    } else if (entry.isFile() && !isSkippedFile(relativePath, extraSkippedFiles)) {
+      files.push({ fullPath, relativePath });
+    }
+  }
+  return files;
+}
+
+function scanText(relativePath, text) {
+  if (text.includes("\u0000")) {
+    return [];
+  }
+
+  const matches = [];
+  const lines = text.split(/\r?\n/);
+  for (let lineIndex = 0; lineIndex < lines.length; lineIndex += 1) {
+    const line = lines[lineIndex];
+    for (const tokenMatch of line.matchAll(TOKEN_PATTERN)) {
+      matches.push({
+        path: relativePath,
+        lineNumber: lineIndex + 1,
+        token: tokenMatch[1].toLowerCase(),
+        line
+      });
+    }
+  }
+  return matches;
+}
+
+async function scan(root, allowlist, extraSkippedFiles) {
+  const files = await collectFiles(root, extraSkippedFiles);
+  const matches = [];
+  for (const file of files) {
+    const text = await fs.readFile(file.fullPath, "utf8");
+    matches.push(...scanText(file.relativePath, text));
+  }
+
+  const unallowlisted = matches.filter((match) => !isAllowed(match, allowlist));
+  return {
+    allowedCount: matches.length - unallowlisted.length,
+    unallowlisted
+  };
+}
+
+function printMatches(matches) {
+  for (const match of matches) {
+    console.log(`${match.path}:${match.lineNumber}: ${match.line}`);
+  }
+}
+
+async function main() {
+  try {
+    const options = parseArgs(process.argv.slice(2));
+    const root = path.resolve(options.root);
+    const allowlistPath = path.isAbsolute(options.allowlist)
+      ? options.allowlist
+      : path.resolve(root, options.allowlist);
+    const allowlist = await readAllowlist(allowlistPath);
+    const allowlistRelativePath = normalizeRelativePath(path.relative(root, allowlistPath));
+    const result = await scan(root, allowlist, new Set([allowlistRelativePath]));
+
+    if (result.unallowlisted.length > 0) {
+      console.log(`legacy-token scan failed: ${result.unallowlisted.length} unallowlisted match(es)`);
+      printMatches(result.unallowlisted);
+      process.exitCode = 1;
+      return;
+    }
+
+    const suffix = result.allowedCount === 1 ? "match" : "matches";
+    console.log(`legacy-token scan passed: allowed ${result.allowedCount} ${suffix}`);
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    console.error(`legacy-token allowlist error: ${message}`);
+    process.exitCode = 2;
+  }
+}
+
+await main();

package/tsconfig.build.json

@@ -0,0 +1,12 @@
+{
+  "extends": "./tsconfig.json",
+  "compilerOptions": {
+    "noEmit": false,
+    "declaration": true,
+    "emitDeclarationOnly": false,
+    "outDir": "dist",
+    "rootDir": "src",
+    "rewriteRelativeImportExtensions": true
+  },
+  "include": ["src/**/*.ts"]
+}

package/tsconfig.json

@@ -0,0 +1,13 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "NodeNext",
+    "moduleResolution": "NodeNext",
+    "strict": true,
+    "noEmit": true,
+    "allowImportingTsExtensions": true,
+    "verbatimModuleSyntax": true,
+    "skipLibCheck": true
+  },
+  "include": ["src/**/*.ts"]
+}