@blxzer/cursor-trellis 0.1.0

package/vendor/smart-search/npm/scripts/resolve-prerelease-version.js

@@ -0,0 +1,108 @@
+const { execFileSync } = require("node:child_process");
+
+function parseArgs(argv) {
+  const args = {
+    prereleaseId: "beta",
+    versionsJson: ""
+  };
+  for (let index = 0; index < argv.length; index += 1) {
+    const arg = argv[index];
+    const next = argv[index + 1];
+    if (arg === "--package") {
+      args.packageName = next;
+      index += 1;
+    } else if (arg === "--base") {
+      args.baseVersion = next;
+      index += 1;
+    } else if (arg === "--id") {
+      args.prereleaseId = next;
+      index += 1;
+    } else if (arg === "--versions-json") {
+      args.versionsJson = next;
+      index += 1;
+    } else if (arg === "--help" || arg === "-h") {
+      printUsage(0);
+    } else {
+      console.error(`Unknown argument: ${arg}`);
+      printUsage(1);
+    }
+  }
+  return args;
+}
+
+function printUsage(exitCode) {
+  console.error(
+    [
+      "Usage: node npm/scripts/resolve-prerelease-version.js --package <name> --base <version> [--id beta]",
+      "",
+      "Options:",
+      "  --versions-json JSON   Use an explicit version list instead of querying npm."
+    ].join("\n")
+  );
+  process.exit(exitCode);
+}
+
+function escapeRegExp(value) {
+  return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+
+function readPublishedVersions(packageName, versionsJson) {
+  if (versionsJson) {
+    return JSON.parse(versionsJson);
+  }
+  try {
+    const output = execFileSync("npm", ["view", packageName, "versions", "--json"], {
+      encoding: "utf8",
+      stdio: ["ignore", "pipe", "pipe"]
+    });
+    return JSON.parse(output);
+  } catch (error) {
+    const stderr = String(error.stderr || "");
+    if (stderr.includes("E404") || stderr.includes("404 Not Found")) {
+      return [];
+    }
+    throw error;
+  }
+}
+
+function resolvePrereleaseVersion(versions, baseVersion, prereleaseId) {
+  const normalizedVersions = Array.isArray(versions) ? versions.filter((version) => typeof version === "string") : [];
+  const escapedBase = escapeRegExp(baseVersion);
+  const escapedId = escapeRegExp(prereleaseId);
+  const prereleasePattern = new RegExp(`^${escapedBase}-${escapedId}\\.(\\d+)$`);
+  const legacyDevPattern = new RegExp(`^${escapedBase}-dev\\..+$`);
+  const existingPrereleaseNumbers = [];
+  let legacyDevCount = 0;
+
+  for (const version of normalizedVersions) {
+    const prereleaseMatch = prereleasePattern.exec(version);
+    if (prereleaseMatch) {
+      existingPrereleaseNumbers.push(Number(prereleaseMatch[1]));
+      continue;
+    }
+    if (legacyDevPattern.test(version)) {
+      legacyDevCount += 1;
+    }
+  }
+
+  const maxExistingPrerelease = existingPrereleaseNumbers.length > 0 ? Math.max(...existingPrereleaseNumbers) : 0;
+  const nextNumber = Math.max(maxExistingPrerelease, legacyDevCount) + 1;
+  return `${baseVersion}-${prereleaseId}.${nextNumber}`;
+}
+
+function main() {
+  const args = parseArgs(process.argv.slice(2));
+  if (!args.packageName || !args.baseVersion) {
+    printUsage(1);
+  }
+  const versions = readPublishedVersions(args.packageName, args.versionsJson);
+  process.stdout.write(resolvePrereleaseVersion(versions, args.baseVersion, args.prereleaseId));
+}
+
+if (require.main === module) {
+  main();
+}
+
+module.exports = {
+  resolvePrereleaseVersion
+};

package/vendor/smart-search/npm/scripts/set-package-version.js

@@ -0,0 +1,35 @@
+const fs = require("node:fs");
+const path = require("node:path");
+
+const version = process.argv[2];
+if (!version) {
+  console.error("Usage: node npm/scripts/set-package-version.js <version>");
+  process.exit(1);
+}
+
+const packageRoot = path.resolve(__dirname, "..", "..");
+const packageJsonPath = path.join(packageRoot, "package.json");
+const packageLockPath = path.join(packageRoot, "package-lock.json");
+const pyprojectPath = path.join(packageRoot, "pyproject.toml");
+
+function writeJsonVersion(filePath) {
+  const data = JSON.parse(fs.readFileSync(filePath, "utf8"));
+  data.version = version;
+  if (data.packages && data.packages[""]) {
+    data.packages[""].version = version;
+  }
+  fs.writeFileSync(filePath, `${JSON.stringify(data, null, 2)}\n`);
+}
+
+writeJsonVersion(packageJsonPath);
+writeJsonVersion(packageLockPath);
+
+const pyproject = fs.readFileSync(pyprojectPath, "utf8");
+const versionPattern = /^version = ".*"$/m;
+if (!versionPattern.test(pyproject)) {
+  console.error("Could not find the project.version field in pyproject.toml.");
+  process.exit(1);
+}
+
+fs.writeFileSync(pyprojectPath, pyproject.replace(versionPattern, `version = "${version}"`));
+console.log(`Set package version to ${version}.`);

package/vendor/smart-search/npm/scripts/sync-python-version.js

@@ -0,0 +1,22 @@
+const fs = require("node:fs");
+const path = require("node:path");
+
+const packageRoot = path.resolve(__dirname, "..", "..");
+const packageJson = JSON.parse(
+  fs.readFileSync(path.join(packageRoot, "package.json"), "utf8")
+);
+const pyprojectPath = path.join(packageRoot, "pyproject.toml");
+const pyproject = fs.readFileSync(pyprojectPath, "utf8");
+const versionPattern = /^version = ".*"$/m;
+
+if (!versionPattern.test(pyproject)) {
+  console.error("Could not find the project.version field in pyproject.toml.");
+  process.exit(1);
+}
+
+const updated = pyproject.replace(versionPattern, `version = "${packageJson.version}"`);
+if (updated !== pyproject) {
+  fs.writeFileSync(pyprojectPath, updated);
+}
+
+console.log(`Synced pyproject.toml to ${packageJson.version}.`);

package/vendor/smart-search/npm/scripts/test-wrapper-repair.js

@@ -0,0 +1,99 @@
+const assert = require("node:assert");
+const fs = require("node:fs");
+const path = require("node:path");
+const vm = require("node:vm");
+
+const wrapperPath = path.resolve(__dirname, "..", "bin", "smart-search.js");
+const wrapperSource = fs.readFileSync(wrapperPath, "utf8");
+
+function runWrapper({ runtimeExists, repairStatus = 0, repairCreatesRuntime = true }) {
+  let repairedRuntimeExists = runtimeExists;
+  const spawnSyncCalls = [];
+  const spawnCalls = [];
+  const exits = [];
+
+  const fakeFs = {
+    existsSync(filePath) {
+      const normalized = filePath.replaceAll("\\", "/");
+      if (
+        normalized.endsWith("/.smart-search-python/Scripts/python.exe") ||
+        normalized.endsWith("/.smart-search-python/bin/python")
+      ) {
+        return repairedRuntimeExists;
+      }
+      return fs.existsSync(filePath);
+    }
+  };
+
+  const fakeProcess = {
+    ...process,
+    argv: ["node", wrapperPath, "--version"],
+    env: {},
+    cwd: () => "C:\\caller",
+    exit(code) {
+      exits.push(code);
+      throw new Error(`process.exit(${code})`);
+    },
+    kill() {}
+  };
+
+  const fakeChildProcess = {
+    spawnSync(command, args, options) {
+      spawnSyncCalls.push({ command, args, options });
+      if (repairCreatesRuntime) {
+        repairedRuntimeExists = true;
+      }
+      return { status: repairStatus };
+    },
+    spawn(command, args, options) {
+      spawnCalls.push({ command, args, options });
+      return {
+        on() {
+          return this;
+        }
+      };
+    }
+  };
+
+  const context = {
+    __dirname: path.dirname(wrapperPath),
+    console: { error() {}, log() {} },
+    process: fakeProcess,
+    require(moduleName) {
+      if (moduleName === "node:child_process") {
+        return fakeChildProcess;
+      }
+      if (moduleName === "node:fs") {
+        return fakeFs;
+      }
+      if (moduleName === "node:path") {
+        return path;
+      }
+      return require(moduleName);
+    }
+  };
+
+  try {
+    vm.runInNewContext(wrapperSource, context, { filename: wrapperPath });
+  } catch (error) {
+    if (!String(error.message).startsWith("process.exit(")) {
+      throw error;
+    }
+  }
+
+  return { spawnSyncCalls, spawnCalls, exits };
+}
+
+const healthy = runWrapper({ runtimeExists: true });
+assert.strictEqual(healthy.spawnSyncCalls.length, 0);
+assert.strictEqual(healthy.spawnCalls.length, 1);
+
+const repaired = runWrapper({ runtimeExists: false });
+assert.strictEqual(repaired.spawnSyncCalls.length, 1);
+assert(
+  repaired.spawnSyncCalls[0].args[0].replaceAll("\\", "/").endsWith("/npm/scripts/postinstall.js"),
+  "missing runtime should invoke package postinstall repair"
+);
+assert.strictEqual(repaired.spawnCalls.length, 1);
+assert.deepStrictEqual(Array.from(repaired.spawnCalls[0].args.slice(0, 2)), ["-m", "smart_search.cli"]);
+assert.strictEqual(repaired.exits.length, 0);

package/vendor/smart-search/npm/scripts/test.js

@@ -0,0 +1,85 @@
+const { spawnSync } = require("node:child_process");
+const fs = require("node:fs");
+const path = require("node:path");
+
+const packageRoot = path.resolve(__dirname, "..", "..");
+const venvDir = path.join(packageRoot, ".smart-search-python");
+const pythonPath =
+  process.platform === "win32"
+    ? path.join(venvDir, "Scripts", "python.exe")
+    : path.join(venvDir, "bin", "python");
+
+function run(command, args, options = {}) {
+  const result = spawnSync(command, args, {
+    cwd: packageRoot,
+    stdio: "inherit",
+    shell: options.shell || false,
+    windowsHide: true
+  });
+  if (result.error) {
+    console.error(result.error.message);
+    process.exit(1);
+  }
+  if (result.status !== 0) {
+    process.exit(result.status || 1);
+  }
+}
+
+function capture(command, args) {
+  const result = spawnSync(command, args, {
+    cwd: packageRoot,
+    encoding: "utf8",
+    windowsHide: true
+  });
+  if (result.error) {
+    console.error(result.error.message);
+    process.exit(1);
+  }
+  if (result.status !== 0) {
+    process.stdout.write(result.stdout || "");
+    process.stderr.write(result.stderr || "");
+    process.exit(result.status || 1);
+  }
+  return result.stdout || "";
+}
+
+function runNpm(args) {
+  if (process.env.npm_execpath) {
+    run(process.execPath, [process.env.npm_execpath, ...args]);
+    return;
+  }
+  run("npm", args, { shell: process.platform === "win32" });
+}
+
+if (!fs.existsSync(pythonPath)) {
+  console.error("Missing .smart-search-python runtime. Run npm install first.");
+  process.exit(1);
+}
+
+run(pythonPath, ["-m", "pip", "install", "--disable-pip-version-check", "-e", ".[dev]"]);
+run(pythonPath, ["-m", "pytest"]);
+run(process.execPath, ["npm/scripts/test-wrapper-repair.js"]);
+run(process.execPath, ["npm/bin/smart-search.js", "--help"]);
+const utf8Probe = spawnSync(process.execPath, [
+  "npm/bin/smart-search.js",
+  "search",
+  "深度搜索一下最近的比特币行情",
+  "--format",
+  "json"
+], {
+  cwd: packageRoot,
+  encoding: "utf8",
+  windowsHide: true,
+  env: { ...process.env, OPENAI_COMPATIBLE_API_KEY: "" }
+});
+let utf8Query = "";
+try {
+  utf8Query = JSON.parse(utf8Probe.stdout || "{}").query;
+} catch (err) {
+  utf8Query = "";
+}
+if (utf8Query !== "深度搜索一下最近的比特币行情") {
+  console.error("npm wrapper must preserve non-ASCII CLI arguments and JSON output as UTF-8.");
+  process.exit(1);
+}
+runNpm(["pack", "--dry-run"]);

package/vendor/smart-search/package.json

@@ -0,0 +1,42 @@
+{
+  "name": "@konbakuyomu/smart-search",
+  "version": "0.1.14",
+  "description": "CLI-first bilingual web research with OpenAI-compatible search, Exa, Context7, Tavily, Firecrawl, and staged Deep Research execution.",
+  "license": "MIT",
+  "homepage": "https://github.com/konbakuyomu/smartsearch#readme",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/konbakuyomu/smartsearch.git"
+  },
+  "bugs": {
+    "url": "https://github.com/konbakuyomu/smartsearch/issues"
+  },
+  "bin": {
+    "smart-search": "npm/bin/smart-search.js"
+  },
+  "files": [
+    "npm/",
+    "skills/smart-search-cli/**",
+    "src/smart_search/**/*.py",
+    "src/smart_search/assets/skills/smart-search-cli/**",
+    "pyproject.toml",
+    "README.md",
+    "README.zh-CN.md",
+    "LICENSE"
+  ],
+  "scripts": {
+    "postinstall": "node npm/scripts/postinstall.js",
+    "test": "node npm/scripts/test.js",
+    "set-version": "node npm/scripts/set-package-version.js",
+    "sync:python-version": "node npm/scripts/sync-python-version.js",
+    "version": "node npm/scripts/sync-python-version.js && git add pyproject.toml package.json package-lock.json",
+    "pack:dry": "npm pack --dry-run",
+    "publish:dry": "npm publish --dry-run --access public"
+  },
+  "engines": {
+    "node": ">=18"
+  },
+  "publishConfig": {
+    "access": "public"
+  }
+}

package/vendor/smart-search/pyproject.toml

@@ -0,0 +1,37 @@
+[build-system]
+requires = ["setuptools>=61.0"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "smart-search"
+version = "0.1.14"
+description = "CLI-first bilingual web research with OpenAI-compatible search, Exa, Context7, Tavily, Firecrawl, and staged Deep Research execution."
+readme = "README.md"
+requires-python = ">=3.10"
+dependencies = [
+    "httpx[socks]>=0.28.0",
+    "InquirerPy>=0.3.4,<0.4",
+    "pyfiglet>=1.0,<2",
+    "rich>=13.9,<16",
+    "tenacity>=8.0.0",
+]
+
+[project.optional-dependencies]
+dev = [
+    "pytest>=8.0.0",
+    "pytest-asyncio>=0.23.0",
+]
+
+[tool.setuptools.packages.find]
+where = ["src"]
+
+[tool.setuptools.package-data]
+smart_search = [
+    "assets/skills/smart-search-cli/SKILL.md",
+    "assets/skills/smart-search-cli/agents/*.yaml",
+    "assets/skills/smart-search-cli/examples/*.md",
+    "assets/skills/smart-search-cli/references/*.md",
+]
+
+[project.scripts]
+smart-search = "smart_search.cli:main"