autohand-cli 0.8.3 → 0.9.0

package/dist/fffSearchProvider-W6627E2V.cjs

@@ -0,0 +1,412 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { newObj[key] = obj[key]; } } } newObj.default = obj; return newObj; } } function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } } async function _asyncNullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return await rhsFn(); } } function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; }
+
+var _chunkXF2WIKHRcjs = require('./chunk-XF2WIKHR.cjs');
+require('./chunk-3HT76LNN.cjs');
+
+// src/search/fffSearchProvider.ts
+var _child_process = require('child_process');
+var _promises = require('fs/promises'); var _promises2 = _interopRequireDefault(_promises);
+var _module = require('module');
+var _path = require('path'); var _path2 = _interopRequireDefault(_path);
+var _url = require('url');
+var _util = require('util');
+var execFileAsync = _util.promisify.call(void 0, _child_process.execFile);
+var FILE_WALK_IGNORED_DIRECTORIES = /* @__PURE__ */ new Set([
+  ".git",
+  ".hg",
+  ".svn",
+  "node_modules",
+  "dist",
+  "build",
+  "coverage"
+]);
+var FFFSearchProvider = class _FFFSearchProvider {
+  
+  constructor(backend) {
+    this.backend = backend;
+  }
+  static async create(workspaceRoot) {
+    const backend = await _asyncNullishCoalesce(await _asyncNullishCoalesce(await createNativeClassBackend(workspaceRoot), async () => ( await createLowLevelFfiBackend(workspaceRoot))), async () => ( new RipgrepSearchBackend(workspaceRoot)));
+    return new _FFFSearchProvider(backend);
+  }
+  async grep(params) {
+    return this.backend.grep(params);
+  }
+  async fileSearch(params) {
+    return this.backend.fileSearch(params);
+  }
+  destroy() {
+    this.backend.destroy();
+  }
+};
+async function createNativeClassBackend(workspaceRoot) {
+  try {
+    const fffPackage = await Promise.resolve().then(() => _interopRequireWildcard(require("@ff-labs/fff-bun")));
+    const create = _optionalChain([fffPackage, 'access', _ => _.FileFinder, 'optionalAccess', _2 => _2.create]);
+    if (typeof create !== "function") {
+      return null;
+    }
+    const result = create({
+      basePath: workspaceRoot,
+      aiMode: true
+    });
+    if (!result.ok) {
+      throw new Error(`Failed to initialize FFF: ${result.error}`);
+    }
+    const finder = result.value;
+    if (typeof finder.waitForScan !== "function" || typeof finder.grep !== "function" || typeof finder.fileSearch !== "function" || typeof finder.destroy !== "function") {
+      _optionalChain([finder, 'access', _3 => _3.destroy, 'optionalCall', _4 => _4()]);
+      return null;
+    }
+    const scanResult = finder.waitForScan(1e4);
+    if (!scanResult.ok) {
+      throw new Error(`Failed to scan workspace with FFF: ${scanResult.error}`);
+    }
+    return new NativeClassSearchBackend(finder);
+  } catch (e) {
+    return null;
+  }
+}
+async function createLowLevelFfiBackend(workspaceRoot) {
+  try {
+    const ffi = await importLowLevelFfiModule();
+    if (!ffi) {
+      return null;
+    }
+    const result = ffi.ffiCreate(
+      workspaceRoot,
+      "",
+      "",
+      false,
+      true,
+      true,
+      true,
+      true,
+      "",
+      "",
+      0n,
+      0n,
+      0n
+    );
+    if (!result.ok) {
+      throw new Error(`Failed to initialize FFF: ${result.error}`);
+    }
+    const scanResult = ffi.ffiWaitForScan(result.value, 1e4);
+    if (!scanResult.ok) {
+      ffi.ffiDestroy(result.value);
+      throw new Error(`Failed to scan workspace with FFF: ${scanResult.error}`);
+    }
+    return new LowLevelFfiSearchBackend(ffi, result.value);
+  } catch (e2) {
+    return null;
+  }
+}
+async function importLowLevelFfiModule() {
+  try {
+    const require2 = _module.createRequire.call(void 0, import.meta.url);
+    const packageJsonPath = require2.resolve("@ff-labs/fff-bun/package.json");
+    const ffiPath = _path2.default.join(_path2.default.dirname(packageJsonPath), "src", "ffi.ts");
+    return await Promise.resolve().then(() => _interopRequireWildcard(require(_url.pathToFileURL.call(void 0, ffiPath).href)));
+  } catch (e3) {
+    return null;
+  }
+}
+var NativeClassSearchBackend = class {
+  constructor(finder) {
+    this.finder = finder;
+  }
+  
+  async grep(params) {
+    const query = buildConstrainedQuery(params);
+    const mode = inferGrepMode(params.query);
+    const result = unwrap(this.finder.grep(query, {
+      mode,
+      smartCase: !params.caseSensitive,
+      beforeContext: _nullishCoalesce(params.beforeContext, () => ( 2)),
+      afterContext: _nullishCoalesce(params.afterContext, () => ( 2)),
+      maxMatchesPerFile: params.limit
+    }));
+    if (!result.items.length && mode !== "fuzzy") {
+      return formatGrepResult(unwrap(this.finder.grep(query, {
+        mode: "fuzzy",
+        smartCase: !params.caseSensitive,
+        beforeContext: _nullishCoalesce(params.beforeContext, () => ( 2)),
+        afterContext: _nullishCoalesce(params.afterContext, () => ( 2)),
+        maxMatchesPerFile: params.limit
+      })), params.limit);
+    }
+    return formatGrepResult(result, params.limit);
+  }
+  async fileSearch(params) {
+    return formatSearchResult(unwrap(this.finder.fileSearch(params.query, {
+      pageSize: _nullishCoalesce(params.limit, () => ( 50))
+    })));
+  }
+  destroy() {
+    this.finder.destroy();
+  }
+};
+var LowLevelFfiSearchBackend = class {
+  constructor(ffi, handle) {
+    this.ffi = ffi;
+    this.handle = handle;
+  }
+  
+  
+  async grep(params) {
+    const query = buildConstrainedQuery(params);
+    const mode = inferGrepMode(params.query);
+    const result = this.grepWithMode(query, mode, params);
+    if (!result.items.length && mode !== "fuzzy") {
+      return formatGrepResult(this.grepWithMode(query, "fuzzy", params), params.limit);
+    }
+    return formatGrepResult(result, params.limit);
+  }
+  async fileSearch(params) {
+    const result = this.ffi.ffiSearch(
+      this.handle,
+      params.query,
+      "",
+      0,
+      0,
+      _nullishCoalesce(params.limit, () => ( 50)),
+      0,
+      0
+    );
+    return formatSearchResult(unwrap(result));
+  }
+  destroy() {
+    this.ffi.ffiDestroy(this.handle);
+  }
+  grepWithMode(query, mode, params) {
+    return unwrap(this.ffi.ffiLiveGrep(
+      this.handle,
+      query,
+      mode,
+      0,
+      0,
+      !params.caseSensitive,
+      0,
+      _nullishCoalesce(params.limit, () => ( 50)),
+      0,
+      _nullishCoalesce(params.beforeContext, () => ( 2)),
+      _nullishCoalesce(params.afterContext, () => ( 2)),
+      _nullishCoalesce(params.classifyDefinitions, () => ( true))
+    ));
+  }
+};
+var RipgrepSearchBackend = class {
+  constructor(workspaceRoot) {
+    this.workspaceRoot = workspaceRoot;
+  }
+  
+  async grep(params) {
+    const target = normalizeSearchTarget(params.path);
+    const args = [
+      "--line-number",
+      "--color",
+      "never",
+      "--no-heading",
+      "--with-filename",
+      "--no-binary",
+      params.caseSensitive ? "--case-sensitive" : "--smart-case"
+    ];
+    const mode = inferGrepMode(params.query);
+    if (mode === "plain") {
+      args.push("--fixed-strings");
+    }
+    if (params.beforeContext !== void 0) {
+      args.push("--before-context", String(params.beforeContext));
+    }
+    if (params.afterContext !== void 0) {
+      args.push("--after-context", String(params.afterContext));
+    }
+    for (const pattern of splitExcludePatterns(params.exclude)) {
+      args.push("--glob", `!${pattern}`);
+    }
+    args.push(params.query, target);
+    try {
+      const result = await execFileAsync(_chunkXF2WIKHRcjs.resolveRipgrepCommand.call(void 0, ), args, {
+        cwd: this.workspaceRoot,
+        encoding: "utf8",
+        maxBuffer: 10 * 1024 * 1024
+      });
+      const lines = result.stdout.trim().split("\n").filter(Boolean);
+      if (!lines.length) {
+        return "No matches found.";
+      }
+      return formatPlainLines(lines, _nullishCoalesce(params.limit, () => ( 50)), "match", "matches");
+    } catch (error) {
+      if (isNoMatchError(error)) {
+        return "No matches found.";
+      }
+      throw error;
+    }
+  }
+  async fileSearch(params) {
+    try {
+      const result = await execFileAsync(_chunkXF2WIKHRcjs.resolveRipgrepCommand.call(void 0, ), ["--files", "."], {
+        cwd: this.workspaceRoot,
+        encoding: "utf8",
+        maxBuffer: 10 * 1024 * 1024
+      });
+      const files = result.stdout.trim().split("\n").filter(Boolean);
+      const ranked = rankPaths(files, params.query).slice(0, _nullishCoalesce(params.limit, () => ( 50)));
+      if (!ranked.length) {
+        return "No files found.";
+      }
+      return ranked.join("\n");
+    } catch (error) {
+      if (isNoMatchError(error)) {
+        return "No files found.";
+      }
+      if (isMissingExecutableError(error)) {
+        return this.fileSearchWithFilesystemWalk(params);
+      }
+      throw error;
+    }
+  }
+  destroy() {
+  }
+  async fileSearchWithFilesystemWalk(params) {
+    const files = await collectWorkspaceFiles(this.workspaceRoot);
+    const ranked = rankPaths(files, params.query).slice(0, _nullishCoalesce(params.limit, () => ( 50)));
+    if (!ranked.length) {
+      return "No files found.";
+    }
+    return ranked.join("\n");
+  }
+};
+function unwrap(result) {
+  if (!result.ok) {
+    throw new Error(result.error);
+  }
+  return result.value;
+}
+function formatGrepResult(searchResult, limit = 50) {
+  const hits = searchResult.items;
+  if (!hits.length) {
+    return "No matches found.";
+  }
+  const limited = hits.slice(0, limit);
+  const formattedHits = limited.map((hit) => {
+    const before = _nullishCoalesce(_optionalChain([hit, 'access', _5 => _5.contextBefore, 'optionalAccess', _6 => _6.join, 'call', _7 => _7("\n")]), () => ( ""));
+    const line = `${hit.relativePath}:${hit.lineNumber}: ${hit.lineContent}`;
+    const after = _nullishCoalesce(_optionalChain([hit, 'access', _8 => _8.contextAfter, 'optionalAccess', _9 => _9.join, 'call', _10 => _10("\n")]), () => ( ""));
+    return [before, line, after].filter(Boolean).join("\n");
+  }).join("\n\n");
+  const header = hits.length > limit ? `Found ${hits.length} matches (showing first ${limit}):
+
+` : `Found ${hits.length} match${hits.length === 1 ? "" : "es"}:
+
+`;
+  return header + formattedHits;
+}
+function formatSearchResult(result) {
+  const files = result.items;
+  if (!files.length) {
+    return "No files found.";
+  }
+  return files.map((file) => {
+    const gitStatus = file.gitStatus && file.gitStatus !== "clean" ? `[${file.gitStatus}] ` : "";
+    return `${gitStatus}${file.relativePath}`;
+  }).join("\n");
+}
+function inferGrepMode(query) {
+  return /(^|[^\\])[\\^$.*+?()[\]{}|]/.test(query) ? "regex" : "plain";
+}
+function buildConstrainedQuery(params) {
+  if (!_optionalChain([params, 'access', _11 => _11.path, 'optionalAccess', _12 => _12.trim, 'call', _13 => _13()])) {
+    return params.query;
+  }
+  const normalizedPath = params.path.trim().replace(/\\/g, "/").replace(/^\.\//, "");
+  if (!normalizedPath) {
+    return params.query;
+  }
+  const constraint = normalizedPath.endsWith("/") || normalizedPath.includes("*") || /\.[^/]+$/.test(normalizedPath) ? normalizedPath : `${normalizedPath}/`;
+  return `${constraint} ${params.query}`;
+}
+function splitExcludePatterns(exclude) {
+  return _nullishCoalesce(_optionalChain([exclude, 'optionalAccess', _14 => _14.split, 'call', _15 => _15(/[,\s]+/), 'access', _16 => _16.map, 'call', _17 => _17((entry) => entry.trim()), 'access', _18 => _18.filter, 'call', _19 => _19(Boolean)]), () => ( []));
+}
+function normalizeSearchTarget(target) {
+  const trimmed = _optionalChain([target, 'optionalAccess', _20 => _20.trim, 'call', _21 => _21()]);
+  if (!trimmed || trimmed === ".") {
+    return ".";
+  }
+  return trimmed.replace(/\\/g, "/").replace(/^\.\//, "");
+}
+function isNoMatchError(error) {
+  const exitCode = _optionalChain([error, 'optionalAccess', _22 => _22.code]);
+  return exitCode === 1 || exitCode === "1";
+}
+function isMissingExecutableError(error) {
+  return _optionalChain([error, 'optionalAccess', _23 => _23.code]) === "ENOENT";
+}
+function formatPlainLines(lines, limit, singular, plural) {
+  const limited = lines.slice(0, limit);
+  const header = lines.length > limit ? `Found ${lines.length} ${plural} (showing first ${limit}):
+
+` : `Found ${lines.length} ${lines.length === 1 ? singular : plural}:
+
+`;
+  return header + limited.join("\n");
+}
+function rankPaths(files, query) {
+  const terms = query.toLowerCase().split(/\s+/).filter(Boolean);
+  return files.map((file) => ({ file, score: scorePath(file, terms) })).filter((entry) => entry.score > 0).sort((a, b) => b.score - a.score || a.file.localeCompare(b.file)).map((entry) => entry.file);
+}
+function scorePath(file, terms) {
+  if (!terms.length) {
+    return 1;
+  }
+  const normalized = file.toLowerCase();
+  const basename = _path2.default.basename(normalized);
+  let score = 0;
+  for (const term of terms) {
+    if (basename === term) {
+      score += 20;
+    } else if (basename.includes(term)) {
+      score += 10;
+    } else if (normalized.includes(term)) {
+      score += 4;
+    } else {
+      return 0;
+    }
+  }
+  return score;
+}
+async function collectWorkspaceFiles(workspaceRoot) {
+  const files = [];
+  await walkWorkspaceFiles(workspaceRoot, workspaceRoot, files);
+  return files;
+}
+async function walkWorkspaceFiles(workspaceRoot, currentDirectory, files) {
+  let entries;
+  try {
+    entries = await _promises2.default.readdir(currentDirectory, { withFileTypes: true });
+  } catch (e4) {
+    return;
+  }
+  for (const entry of entries) {
+    if (entry.isDirectory()) {
+      if (FILE_WALK_IGNORED_DIRECTORIES.has(entry.name)) {
+        continue;
+      }
+      await walkWorkspaceFiles(workspaceRoot, _path2.default.join(currentDirectory, entry.name), files);
+      continue;
+    }
+    if (!entry.isFile()) {
+      continue;
+    }
+    files.push(_path2.default.relative(workspaceRoot, _path2.default.join(currentDirectory, entry.name)).replace(/\\/g, "/"));
+  }
+}
+
+
+exports.FFFSearchProvider = FFFSearchProvider;
+/**
+ * @license
+ * Copyright 2025 Autohand AI LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */

package/dist/{filesystem-Z7BWAWMZ.js → filesystem-L6DQKGWK.js}

@@ -1,8 +1,9 @@
 import {
   FILE_LIMITS,
   FileActionManager
-} from "./chunk-7UOUW76C.js";
-import "./chunk-EZMINVLU.js";
+} from "./chunk-ZQAT5VT5.js";
+import "./chunk-H4D2Q2AL.js";
+import "./chunk-UOQECODR.js";
 import "./chunk-QGM4M3NI.js";
 export {
   FILE_LIMITS,

package/dist/filesystem-PGUPCMVK.cjs

@@ -0,0 +1,11 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});
+
+
+var _chunk5K3CDSWZcjs = require('./chunk-5K3CDSWZ.cjs');
+require('./chunk-HXQREVTA.cjs');
+require('./chunk-XF2WIKHR.cjs');
+require('./chunk-3HT76LNN.cjs');
+
+
+
+exports.FILE_LIMITS = _chunk5K3CDSWZcjs.FILE_LIMITS; exports.FileActionManager = _chunk5K3CDSWZcjs.FileActionManager;

package/dist/help-BAXLP2M2.cjs

@@ -0,0 +1,12 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});
+
+
+
+var _chunkPHJO5YALcjs = require('./chunk-PHJO5YAL.cjs');
+require('./chunk-CHI52KFR.cjs');
+require('./chunk-3HT76LNN.cjs');
+
+
+
+
+exports.aliasMetadata = _chunkPHJO5YALcjs.aliasMetadata; exports.help = _chunkPHJO5YALcjs.help; exports.metadata = _chunkPHJO5YALcjs.metadata;

package/dist/{help-GFQXNZOK.js → help-X3OAZ3CY.js}

@@ -2,8 +2,8 @@ import {
   aliasMetadata,
   help,
   metadata
-} from "./chunk-FTYY5JJD.js";
-import "./chunk-APIXPPMT.js";
+} from "./chunk-BFQDQRDE.js";
+import "./chunk-CBFH2J3O.js";
 import "./chunk-QGM4M3NI.js";
 export {
   aliasMetadata,

package/dist/history-6HOJSEMT.cjs

@@ -0,0 +1,14 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});
+
+
+
+
+var _chunkJ2K57QM7cjs = require('./chunk-J2K57QM7.cjs');
+require('./chunk-CHI52KFR.cjs');
+require('./chunk-3HT76LNN.cjs');
+
+
+
+
+
+exports.formatHistoryEntry = _chunkJ2K57QM7cjs.formatHistoryEntry; exports.history = _chunkJ2K57QM7cjs.history; exports.metadata = _chunkJ2K57QM7cjs.metadata; exports.paginateHistory = _chunkJ2K57QM7cjs.paginateHistory;

package/dist/{history-E3N6BJP7.js → history-YKFPHBJN.js}

@@ -3,8 +3,8 @@ import {
   history,
   metadata,
   paginateHistory
-} from "./chunk-AYS2ASM7.js";
-import "./chunk-APIXPPMT.js";
+} from "./chunk-OHWMWKJQ.js";
+import "./chunk-CBFH2J3O.js";
 import "./chunk-QGM4M3NI.js";
 export {
   formatHistoryEntry,

package/dist/hooks-7TA4PIIB.js

@@ -0,0 +1,18 @@
+import {
+  HOOK_EVENTS,
+  hooks,
+  metadata
+} from "./chunk-L4F7SUYL.js";
+import "./chunk-62RTC3XX.js";
+import "./chunk-DLP436GI.js";
+import "./chunk-NMQ47RCG.js";
+import "./chunk-5JFTY3VU.js";
+import "./chunk-NBGOIFKP.js";
+import "./chunk-JAQO6XDB.js";
+import "./chunk-CBFH2J3O.js";
+import "./chunk-QGM4M3NI.js";
+export {
+  HOOK_EVENTS,
+  hooks,
+  metadata
+};

package/dist/hooks-XVFU67T2.cjs

@@ -0,0 +1,18 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});
+
+
+
+var _chunkLDJQ5QHGcjs = require('./chunk-LDJQ5QHG.cjs');
+require('./chunk-7MU7LWF3.cjs');
+require('./chunk-CH2J4PVE.cjs');
+require('./chunk-KNTUI4TZ.cjs');
+require('./chunk-TQ33WBY5.cjs');
+require('./chunk-YWTIXHU6.cjs');
+require('./chunk-2VHB43IX.cjs');
+require('./chunk-CHI52KFR.cjs');
+require('./chunk-3HT76LNN.cjs');
+
+
+
+
+exports.HOOK_EVENTS = _chunkLDJQ5QHGcjs.HOOK_EVENTS; exports.hooks = _chunkLDJQ5QHGcjs.hooks; exports.metadata = _chunkLDJQ5QHGcjs.metadata;

package/dist/{i18n-SY7QRM22.js → i18n-2KBUU7XL.js}

@@ -13,7 +13,7 @@ import {
   normalizeLocale,
   onLanguageChange,
   t
-} from "./chunk-APIXPPMT.js";
+} from "./chunk-CBFH2J3O.js";
 import "./chunk-QGM4M3NI.js";
 export {
   LANGUAGE_DISPLAY_NAMES,

package/dist/i18n-MUJMKTFM.cjs

@@ -0,0 +1,33 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+var _chunkCHI52KFRcjs = require('./chunk-CHI52KFR.cjs');
+require('./chunk-3HT76LNN.cjs');
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+exports.LANGUAGE_DISPLAY_NAMES = _chunkCHI52KFRcjs.LANGUAGE_DISPLAY_NAMES; exports.SUPPORTED_LOCALES = _chunkCHI52KFRcjs.SUPPORTED_LOCALES; exports.buildLocaleInstruction = _chunkCHI52KFRcjs.buildLocaleInstruction; exports.changeLanguage = _chunkCHI52KFRcjs.changeLanguage; exports.detectLocale = _chunkCHI52KFRcjs.detectLocale; exports.exists = _chunkCHI52KFRcjs.exists; exports.getCurrentLocale = _chunkCHI52KFRcjs.getCurrentLocale; exports.initI18n = _chunkCHI52KFRcjs.initI18n; exports.injectLocaleIntoPrompt = _chunkCHI52KFRcjs.injectLocaleIntoPrompt; exports.isInitialized = _chunkCHI52KFRcjs.isInitialized; exports.isValidLocale = _chunkCHI52KFRcjs.isValidLocale; exports.normalizeLocale = _chunkCHI52KFRcjs.normalizeLocale; exports.onLanguageChange = _chunkCHI52KFRcjs.onLanguageChange; exports.t = _chunkCHI52KFRcjs.t;

package/dist/ide-CCQ33PGC.cjs

@@ -0,0 +1,15 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});
+
+
+var _chunkCWINVFRIcjs = require('./chunk-CWINVFRI.cjs');
+require('./chunk-CH2J4PVE.cjs');
+require('./chunk-KNTUI4TZ.cjs');
+require('./chunk-TQ33WBY5.cjs');
+require('./chunk-YWTIXHU6.cjs');
+require('./chunk-2VHB43IX.cjs');
+require('./chunk-CHI52KFR.cjs');
+require('./chunk-3HT76LNN.cjs');
+
+
+
+exports.ide = _chunkCWINVFRIcjs.ide; exports.metadata = _chunkCWINVFRIcjs.metadata;

package/dist/ide-VLVFBZ5F.js

@@ -0,0 +1,15 @@
+import {
+  ide,
+  metadata
+} from "./chunk-HXJEGMGB.js";
+import "./chunk-DLP436GI.js";
+import "./chunk-NMQ47RCG.js";
+import "./chunk-5JFTY3VU.js";
+import "./chunk-NBGOIFKP.js";
+import "./chunk-JAQO6XDB.js";
+import "./chunk-CBFH2J3O.js";
+import "./chunk-QGM4M3NI.js";
+export {
+  ide,
+  metadata
+};

package/dist/immediateCommandRouter-MTEHZXQX.js

@@ -0,0 +1,15 @@
+import {
+  createBufferedRouteOutput,
+  createImmediateShellCommandBlockWriter,
+  formatImmediateShellCommandHeader,
+  renderTerminalMarkdown,
+  routeOutput
+} from "./chunk-RAKO7UN7.js";
+import "./chunk-QGM4M3NI.js";
+export {
+  createBufferedRouteOutput,
+  createImmediateShellCommandBlockWriter,
+  formatImmediateShellCommandHeader,
+  renderTerminalMarkdown,
+  routeOutput
+};

package/dist/immediateCommandRouter-ROXU3MWT.cjs

@@ -0,0 +1,15 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});
+
+
+
+
+
+var _chunkZASDSY7Pcjs = require('./chunk-ZASDSY7P.cjs');
+require('./chunk-3HT76LNN.cjs');
+
+
+
+
+
+
+exports.createBufferedRouteOutput = _chunkZASDSY7Pcjs.createBufferedRouteOutput; exports.createImmediateShellCommandBlockWriter = _chunkZASDSY7Pcjs.createImmediateShellCommandBlockWriter; exports.formatImmediateShellCommandHeader = _chunkZASDSY7Pcjs.formatImmediateShellCommandHeader; exports.renderTerminalMarkdown = _chunkZASDSY7Pcjs.renderTerminalMarkdown; exports.routeOutput = _chunkZASDSY7Pcjs.routeOutput;

package/dist/{import-W7SVLSTC.js → import-4CHYLS4K.js}

@@ -24,7 +24,7 @@ var ALL_CATEGORIES = Object.freeze([
 
 // src/import/index.ts
 async function runImport(options) {
-  const { ImporterRegistry } = await import("./registry-PTHWERKC.js");
+  const { ImporterRegistry } = await import("./registry-34GL6BNJ.js");
   const registry = new ImporterRegistry();
   if (!options.source) {
     const available = await registry.detectAvailable();
@@ -34,7 +34,7 @@ async function runImport(options) {
       return;
     }
     if (process.stdout.isTTY && !options.all) {
-      const { showImportWizard } = await import("./ImportWizard-OHRKBANZ.js");
+      const { showImportWizard } = await import("./ImportWizard-QBKQEXDW.js");
       await showImportWizard(registry, options);
       return;
     }
@@ -92,7 +92,7 @@ Importing from ${importer2.displayName}...`));
       return;
     }
   } else if (process.stdout.isTTY) {
-    const { showImportWizard } = await import("./ImportWizard-OHRKBANZ.js");
+    const { showImportWizard } = await import("./ImportWizard-QBKQEXDW.js");
     await showImportWizard(registry, { ...options, source: options.source });
     return;
   } else {