aihand 0.0.1 → 0.1.1

package/dist/chunk-VEKYRKPF.cjs

@@ -0,0 +1,399 @@
+"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(); } } 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; }// src/read/refactor.ts
+var _fs = require('fs');
+var _path = require('path');
+var _process = require('process'); var _process2 = _interopRequireDefault(_process);
+var _tsmorph = require('ts-morph');
+async function openProject() {
+  const { Project, QuoteKind } = await Promise.resolve().then(() => _interopRequireWildcard(require("ts-morph")));
+  const tsConfigFilePath = ["tsconfig.app.json", "tsconfig.json"].map((f) => _path.resolve.call(void 0, f)).find(_fs.existsSync);
+  if (!tsConfigFilePath) {
+    console.error("refactor: no tsconfig.json (or tsconfig.app.json) found in cwd");
+    _process2.default.exit(1);
+  }
+  return new Project({ tsConfigFilePath, manipulationSettings: { quoteKind: QuoteKind.Single } });
+}
+function aliasPrefixes(project) {
+  const opts = project.getCompilerOptions();
+  const base = _nullishCoalesce(opts.baseUrl, () => ( _process2.default.cwd()));
+  const out = [];
+  for (const [pattern, targets] of Object.entries(_nullishCoalesce(opts.paths, () => ( {})))) {
+    if (!pattern.endsWith("/*") || !_optionalChain([targets, 'access', _ => _[0], 'optionalAccess', _2 => _2.endsWith, 'call', _3 => _3("/*")]))
+      continue;
+    out.push({ alias: pattern.slice(0, -2), target: _path.resolve.call(void 0, base, targets[0].slice(0, -2)) });
+  }
+  return out;
+}
+function stripExt(p) {
+  const ext = [".tsx", ".ts", ".jsx", ".js"].find((e) => p.endsWith(e));
+  return ext ? p.slice(0, -ext.length) : p;
+}
+function toAlias(absPath, prefixes) {
+  const noExt = stripExt(absPath);
+  for (const { alias, target } of prefixes) {
+    if (noExt === target || noExt.startsWith(`${target}/`))
+      return `${alias}/${noExt.slice(target.length + 1)}`;
+  }
+  return null;
+}
+function aliasSpecToAbs(spec, prefixes) {
+  for (const { alias, target } of prefixes) {
+    if (spec === alias)
+      return target;
+    if (spec.startsWith(`${alias}/`))
+      return `${target}/${spec.slice(alias.length + 1)}`;
+  }
+  return null;
+}
+function moveInProject(project, srcAbs, destAbs) {
+  const sf = project.getSourceFile(srcAbs);
+  if (!sf)
+    throw new Error(`${srcAbs} not in project`);
+  if (srcAbs !== destAbs && project.getSourceFile(destAbs))
+    throw new Error(`destination ${destAbs} already exists; move to a fresh path or delete it first`);
+  const prefixes = aliasPrefixes(project);
+  const srcNoExt = stripExt(srcAbs);
+  const pointsAtSrc = (spec) => {
+    const resolved = aliasSpecToAbs(spec, prefixes);
+    return resolved !== null && stripExt(resolved) === srcNoExt;
+  };
+  const declFixups = [];
+  const litFixups = [];
+  const changed = /* @__PURE__ */ new Set();
+  for (const ref of project.getSourceFiles()) {
+    if (ref === sf)
+      continue;
+    for (const d of ref.getImportDeclarations()) {
+      if (pointsAtSrc(d.getModuleSpecifierValue())) {
+        changed.add(ref);
+        declFixups.push({ decl: d, file: ref });
+      }
+    }
+    for (const d of ref.getExportDeclarations()) {
+      const spec = d.getModuleSpecifierValue();
+      if (spec && pointsAtSrc(spec)) {
+        changed.add(ref);
+        declFixups.push({ decl: d, file: ref });
+      }
+    }
+    for (const call of ref.getDescendantsOfKind(_tsmorph.SyntaxKind.CallExpression)) {
+      if (call.getExpression().getKind() !== _tsmorph.SyntaxKind.ImportKeyword)
+        continue;
+      const arg = call.getArguments()[0];
+      if (arg && _tsmorph.Node.isStringLiteral(arg) && pointsAtSrc(arg.getLiteralValue())) {
+        changed.add(ref);
+        litFixups.push({ lit: arg, file: ref });
+      }
+    }
+  }
+  for (const ref of sf.getReferencingSourceFiles())
+    changed.add(ref);
+  sf.move(destAbs);
+  changed.add(sf);
+  for (const { decl, file } of declFixups)
+    decl.setModuleSpecifier(specifierFrom(file, destAbs, prefixes));
+  for (const { lit, file } of litFixups)
+    lit.setLiteralValue(specifierFrom(file, destAbs, prefixes));
+  return [...changed];
+}
+function findNamedDecl(sf, name) {
+  return _nullishCoalesce(_nullishCoalesce(_nullishCoalesce(_nullishCoalesce(_nullishCoalesce(_nullishCoalesce(sf.getVariableDeclaration(name), () => ( sf.getFunction(name))), () => ( sf.getClass(name))), () => ( sf.getInterface(name))), () => ( sf.getTypeAlias(name))), () => ( sf.getEnum(name))), () => ( null));
+}
+function renameInProject(project, fileAbs, oldName, newName) {
+  const sf = project.getSourceFile(fileAbs);
+  if (!sf)
+    throw new Error(`${fileAbs} not in project`);
+  const decl = findNamedDecl(sf, oldName);
+  if (!decl)
+    throw new Error(`no top-level declaration named '${oldName}' in ${fileAbs}`);
+  for (const exp of sf.getExportDeclarations()) {
+    for (const spec of exp.getNamedExports()) {
+      if (spec.getAliasNode() && spec.getNameNode().getText() === oldName)
+        throw new Error(`'${oldName}' is exported under the alias '${spec.getAliasNode().getText()}' (export { ${oldName} as ${spec.getAliasNode().getText()} }); renaming the local name would corrupt importers that reference the public name. Rename '${spec.getAliasNode().getText()}' instead, or rewrite the export by hand.`);
+    }
+  }
+  const changed = /* @__PURE__ */ new Set([sf]);
+  for (const ref of decl.findReferences()) {
+    for (const r of ref.getReferences())
+      changed.add(r.getSourceFile());
+  }
+  decl.rename(newName);
+  return [...changed];
+}
+function specifierFrom(from, toAbs, prefixes) {
+  const alias = toAlias(toAbs, prefixes);
+  if (alias)
+    return alias;
+  const to = _nullishCoalesce(from.getProject().getSourceFile(toAbs), () => ( from.getProject().addSourceFileAtPath(toAbs)));
+  return from.getRelativePathAsModuleSpecifierTo(to);
+}
+function bindingNodeOf(ni) {
+  return _nullishCoalesce(ni.getAliasNode(), () => ( ni.getNameNode()));
+}
+function scopeUsesBinding(scope, bindingNode) {
+  const target = bindingNode.getSymbol();
+  if (!target)
+    return false;
+  let used = false;
+  scope.forEachDescendant((node, traversal) => {
+    if (used) {
+      traversal.stop();
+      return;
+    }
+    if (!_tsmorph.Node.isIdentifier(node))
+      return;
+    if (node === bindingNode)
+      return;
+    const parent = node.getParent();
+    if (_tsmorph.Node.isPropertyAccessExpression(parent) && parent.getNameNode() === node)
+      return;
+    if (_tsmorph.Node.isPropertyAssignment(parent) && parent.getNameNode() === node)
+      return;
+    if (node.getSymbol() === target)
+      used = true;
+  });
+  return used;
+}
+function moveSymbolInProject(project, fromAbs, name, toAbs) {
+  const from = project.getSourceFile(fromAbs);
+  if (!from)
+    throw new Error(`${fromAbs} not in project`);
+  const decl = findNamedDecl(from, name);
+  if (!decl)
+    throw new Error(`no top-level declaration named '${name}' in ${fromAbs}`);
+  if (fromAbs === toAbs)
+    throw new Error(`source and destination are the same file (${fromAbs}); nothing to move`);
+  const to = _nullishCoalesce(project.getSourceFile(toAbs), () => ( project.createSourceFile(toAbs, "")));
+  if (to !== from && findNamedDecl(to, name))
+    throw new Error(`${toAbs} already declares '${name}'`);
+  const guardScope = decl.getKindName() === "VariableDeclaration" ? decl.getVariableStatementOrThrow() : decl;
+  const siblingDeps = /* @__PURE__ */ new Set();
+  for (const id of guardScope.getDescendantsOfKind(
+    80
+    /* Identifier */
+  )) {
+    const parent = id.getParent();
+    if (_tsmorph.Node.isPropertyAccessExpression(parent) && parent.getNameNode() === id)
+      continue;
+    const sym = id.getSymbol();
+    if (!sym)
+      continue;
+    for (const d of sym.getDeclarations()) {
+      if (d.getSourceFile() !== from || d === decl)
+        continue;
+      const stmt = _tsmorph.Node.isVariableDeclaration(d) ? d.getVariableStatementOrThrow() : d;
+      if (_optionalChain([stmt, 'access', _4 => _4.getParent, 'call', _5 => _5(), 'optionalAccess', _6 => _6.getKindName, 'call', _7 => _7()]) !== "SourceFile")
+        continue;
+      const exported = _tsmorph.Node.isExportable(stmt) && stmt.isExported();
+      if (!exported)
+        throw new Error(`'${name}' depends on local symbol '${id.getText()}' (not exported); export it or move them together`);
+      siblingDeps.add(id.getText());
+    }
+  }
+  for (const ref of from.getReferencingSourceFiles()) {
+    for (const ed of ref.getExportDeclarations()) {
+      if (ed.getModuleSpecifierSourceFile() === from && ed.getNamedExports().some((ne) => ne.getName() === name))
+        throw new Error(`'${name}' is re-exported by ${ref.getFilePath()}; update the barrel first or move it manually`);
+    }
+  }
+  for (const r of decl.findReferences()) {
+    for (const ref of r.getReferences()) {
+      const node = ref.getNode();
+      const parent = node.getParent();
+      if (_tsmorph.Node.isPropertyAccessExpression(parent) && parent.getNameNode() === node && ref.getSourceFile() !== from)
+        throw new Error(`'${name}' is accessed via a namespace import in ${ref.getSourceFile().getFilePath()}; move it manually`);
+    }
+  }
+  if (_tsmorph.Node.isExportable(guardScope) && guardScope.isDefaultExport())
+    throw new Error(`'${name}' is the default export of ${fromAbs}; default importers bind arbitrary local names that can't be rewritten. Make it a named export first, or move it manually.`);
+  for (const ed of from.getExportDeclarations()) {
+    for (const ne of ed.getNamedExports()) {
+      if (ed.getModuleSpecifierValue()) continue;
+      if (ne.getNameNode().getText() === name && _optionalChain([ne, 'access', _8 => _8.getAliasNode, 'call', _9 => _9(), 'optionalAccess', _10 => _10.getText, 'call', _11 => _11()]) === "default")
+        throw new Error(`'${name}' is the default export of ${fromAbs} (export { ${name} as default }); default importers bind arbitrary local names that can't be rewritten. Make it a named export first, or move it manually.`);
+    }
+  }
+  for (const ed of from.getExportDeclarations()) {
+    if (ed.getModuleSpecifierValue()) continue;
+    for (const ne of ed.getNamedExports()) {
+      const alias = _optionalChain([ne, 'access', _12 => _12.getAliasNode, 'call', _13 => _13(), 'optionalAccess', _14 => _14.getText, 'call', _15 => _15()]);
+      if (ne.getNameNode().getText() === name && alias && alias !== "default")
+        throw new Error(`'${name}' is exported under the alias '${alias}' (export { ${name} as ${alias} }); the public name '${alias}' that importers reference can't survive a plain move. Rewrite the export, or move it manually.`);
+    }
+  }
+  const prefixes = aliasPrefixes(project);
+  const varStmt = decl.getKindName() === "VariableDeclaration" ? decl.getVariableStatementOrThrow() : null;
+  const sharedDeclarators = varStmt ? varStmt.getDeclarations().length > 1 : false;
+  const declText = varStmt ? sharedDeclarators ? `${varStmt.isExported() ? "export " : ""}${varStmt.getDeclarationKind()} ${decl.getText()}` : varStmt.getText(true) : decl.getText(true);
+  const depScope = _nullishCoalesce(varStmt, () => ( decl));
+  const carried = [];
+  for (const imp of from.getImportDeclarations()) {
+    const struct = imp.getStructure();
+    const keptNamed = imp.getNamedImports().filter((n) => scopeUsesBinding(depScope, bindingNodeOf(n)));
+    const dflt = imp.getDefaultImport();
+    const ns = imp.getNamespaceImport();
+    const keepDflt = dflt ? scopeUsesBinding(depScope, dflt) : false;
+    const keepNs = ns ? scopeUsesBinding(depScope, ns) : false;
+    if (!keptNamed.length && !keepDflt && !keepNs)
+      continue;
+    let spec = struct.moduleSpecifier;
+    if (spec.startsWith(".")) {
+      const target = imp.getModuleSpecifierSourceFile();
+      if (target)
+        spec = specifierFrom(to, target.getFilePath(), prefixes);
+    }
+    carried.push({
+      ...struct,
+      moduleSpecifier: spec,
+      defaultImport: keepDflt ? struct.defaultImport : void 0,
+      namespaceImport: keepNs ? struct.namespaceImport : void 0,
+      namedImports: keptNamed.map((n) => n.getStructure())
+    });
+  }
+  const refFiles = /* @__PURE__ */ new Set();
+  const rewrites = [];
+  for (const ref of decl.findReferences()) {
+    for (const r of ref.getReferences()) {
+      const rf = r.getSourceFile();
+      if (rf !== from)
+        refFiles.add(rf);
+    }
+  }
+  for (const rf of refFiles) {
+    for (const imp of rf.getImportDeclarations()) {
+      if (imp.getModuleSpecifierSourceFile() !== from)
+        continue;
+      const ni = imp.getNamedImports().find((n) => n.getName() === name);
+      if (ni)
+        rewrites.push({ rf, imp, moved: ni.getStructure(), typeOnly: imp.isTypeOnly() });
+    }
+  }
+  const aStillUses = decl.findReferences().some((ref) => ref.getReferences().some((r) => r.getSourceFile() === from && r.getNode() !== _optionalChain([decl, 'access', _16 => _16.getNameNode, 'optionalCall', _17 => _17()])));
+  const existing = to.getFullText();
+  const lead = existing.length && !existing.endsWith("\n") ? "\n" : "";
+  to.insertText(existing.length, `${lead}${declText}
+`);
+  for (const c of carried) {
+    const existingImp = to.getImportDeclarations().find((d) => d.getModuleSpecifierValue() === c.moduleSpecifier);
+    if (existingImp && !c.defaultImport && !c.namespaceImport && Array.isArray(c.namedImports)) {
+      for (const ni of c.namedImports)
+        existingImp.addNamedImport(ni);
+    } else {
+      to.insertImportDeclaration(0, c);
+    }
+  }
+  if (to !== from && siblingDeps.size) {
+    const aSpec = specifierFrom(to, fromAbs, prefixes);
+    const existingA = to.getImportDeclarations().find((d) => d.getModuleSpecifierValue() === aSpec && !d.isTypeOnly());
+    if (existingA) {
+      const have = new Set(existingA.getNamedImports().map((n) => n.getName()));
+      for (const s of siblingDeps)
+        if (!have.has(s))
+          existingA.addNamedImport(s);
+    } else {
+      to.insertImportDeclaration(0, { moduleSpecifier: aSpec, namedImports: [...siblingDeps] });
+    }
+  }
+  if (sharedDeclarators)
+    decl.remove();
+  else
+    (_nullishCoalesce(varStmt, () => ( decl))).remove();
+  for (const imp of from.getImportDeclarations()) {
+    for (const ni of imp.getNamedImports()) {
+      if (!scopeUsesBinding(from, bindingNodeOf(ni)))
+        ni.remove();
+    }
+    const dflt = imp.getDefaultImport();
+    if (dflt && !scopeUsesBinding(from, dflt))
+      imp.removeDefaultImport();
+    const ns = imp.getNamespaceImport();
+    if (ns && !scopeUsesBinding(from, ns))
+      imp.removeNamespaceImport();
+    if (!imp.getNamedImports().length && !imp.getDefaultImport() && !imp.getNamespaceImport())
+      imp.remove();
+  }
+  const toSpecFor = (f) => specifierFrom(f, toAbs, prefixes);
+  for (const { rf, imp, moved, typeOnly } of rewrites) {
+    const bSpec = toSpecFor(rf);
+    const ni = imp.getNamedImports().find((n) => n.getName() === name);
+    if (ni) {
+      ni.remove();
+      if (imp.getNamedImports().length === 0 && !imp.getDefaultImport() && !imp.getNamespaceImport())
+        imp.remove();
+    }
+    const existingB = rf.getImportDeclarations().find((d) => d.getModuleSpecifierValue() === bSpec && d.isTypeOnly() === typeOnly);
+    if (existingB)
+      existingB.addNamedImport(moved);
+    else
+      rf.addImportDeclaration({ moduleSpecifier: bSpec, namedImports: [moved], isTypeOnly: typeOnly });
+  }
+  if (aStillUses)
+    from.addImportDeclaration({ moduleSpecifier: specifierFrom(from, toAbs, prefixes), namedImports: [name] });
+  return [.../* @__PURE__ */ new Set([from, to, ...refFiles])];
+}
+async function moveFile(src, dest, dry = false) {
+  const project = await openProject();
+  const root = _process2.default.cwd();
+  let changed;
+  try {
+    changed = moveInProject(project, _path.resolve.call(void 0, src), _path.resolve.call(void 0, dest));
+  } catch (e2) {
+    console.error(`refactor: ${src} not in tsconfig project (check include globs)`);
+    _process2.default.exit(1);
+  }
+  console.log(`move ${_path.relative.call(void 0, root, src)} \u2192 ${_path.relative.call(void 0, root, dest)}`);
+  console.log(`${changed.length} file(s) ${dry ? "would change" : "changed"}:`);
+  for (const f of changed)
+    console.log(`  ${_path.relative.call(void 0, root, f.getFilePath())}`);
+  if (dry)
+    return;
+  await project.save();
+  console.log("saved. verify: tsc --noEmit");
+}
+async function moveSymbol(from, name, to, dry = false) {
+  const project = await openProject();
+  const root = _process2.default.cwd();
+  let changed;
+  try {
+    changed = moveSymbolInProject(project, _path.resolve.call(void 0, from), name, _path.resolve.call(void 0, to));
+  } catch (e) {
+    console.error(`refactor: ${e.message}`);
+    _process2.default.exit(1);
+  }
+  console.log(`move-symbol ${name}: ${_path.relative.call(void 0, root, from)} \u2192 ${_path.relative.call(void 0, root, to)}`);
+  console.log(`${changed.length} file(s) ${dry ? "would change" : "changed"}:`);
+  for (const f of changed)
+    console.log(`  ${_path.relative.call(void 0, root, f.getFilePath())}`);
+  if (dry)
+    return;
+  await project.save();
+  console.log("saved. verify: tsc --noEmit");
+}
+async function renameSymbol(file, oldName, newName, dry = false) {
+  const project = await openProject();
+  const root = _process2.default.cwd();
+  let changed;
+  try {
+    changed = renameInProject(project, _path.resolve.call(void 0, file), oldName, newName);
+  } catch (e) {
+    console.error(`refactor: ${e.message}`);
+    _process2.default.exit(1);
+  }
+  console.log(`rename ${oldName} \u2192 ${newName} (in ${_path.relative.call(void 0, root, file)})`);
+  console.log(`${changed.length} file(s) ${dry ? "would change" : "changed"}:`);
+  for (const f of changed)
+    console.log(`  ${_path.relative.call(void 0, root, f.getFilePath())}`);
+  if (dry)
+    return;
+  await project.save();
+  console.log("saved. verify: tsc --noEmit");
+}
+
+
+
+
+
+
+
+
+
+exports.toAlias = toAlias; exports.moveInProject = moveInProject; exports.renameInProject = renameInProject; exports.moveSymbolInProject = moveSymbolInProject; exports.moveFile = moveFile; exports.moveSymbol = moveSymbol; exports.renameSymbol = renameSymbol;