project-athena 0.2.1 → 0.4.0

package/dist/chunk-XDCKZ5TV.js

@@ -0,0 +1,436 @@
+#!/usr/bin/env node
+import {
+  HR,
+  PALETTE,
+  box,
+  columns,
+  footer,
+  gradient,
+  mix,
+  padEnd,
+  paint,
+  printHeader,
+  termWidth,
+  truncate,
+  width
+} from "./chunk-SHKXELUX.js";
+import {
+  bullet,
+  c,
+  dim,
+  isJson,
+  isQuiet,
+  isTTY,
+  json,
+  line,
+  ok,
+  sym,
+  unicode,
+  warn
+} from "./chunk-Z6QWMJLK.js";
+import {
+  resolveCwd
+} from "./chunk-XFN7UZCS.js";
+import {
+  runPipeline
+} from "./chunk-GGXPG6OE.js";
+import {
+  ADAPTERS,
+  resolveAdapters
+} from "./chunk-YRIS7ZS6.js";
+import {
+  KNOWLEDGE_DOCS
+} from "./chunk-FQEGEVLY.js";
+import {
+  readState
+} from "./chunk-2DY4PUR4.js";
+import {
+  AthenaError
+} from "./chunk-AD4OZCU2.js";
+
+// src/cli/commands/init.ts
+import path from "path";
+
+// src/cli/ui/dashboard.ts
+import pc from "picocolors";
+var C = PALETTE;
+var accent = (s) => paint(PALETTE.amber, s, true);
+var warnText = (s) => paint(PALETTE.amber, s);
+function sectionTitle(title) {
+  const total = termWidth();
+  const head = `  ${paint(PALETTE.violet, unicode ? "\u2726" : "*", true)} ${gradient(title, [PALETTE.cyan, PALETTE.violet], true)} `;
+  const rest = Math.max(0, total - width(head) - 2);
+  return [head + paint(PALETTE.blue, HR.repeat(rest))];
+}
+function rows(items) {
+  const labelW = Math.max(...items.map(([l]) => l.length)) + 2;
+  return (w) => items.map(([label, value]) => pc.dim(padEnd(label, labelW)) + padEnd(value ? paint(PALETTE.cyan, value) : pc.dim("Not detected"), w - labelW));
+}
+function fileTree(root, files) {
+  const nameW = Math.max(...files.map((f) => f.name.length)) + 2;
+  return (w) => [
+    pc.bold(root),
+    ...files.map((f, i) => {
+      const branch = unicode ? i === files.length - 1 ? "\u2514\u2500\u2500 " : "\u251C\u2500\u2500 " : i === files.length - 1 ? "`-- " : "|-- ";
+      const name = f.highlight ? paint(PALETTE.amber, padEnd(f.name, nameW)) : padEnd(f.name, nameW);
+      return padEnd(pc.dim(branch) + name + pc.dim(f.note ? `# ${f.note}` : ""), w);
+    })
+  ];
+}
+function wrapCode(text, w) {
+  const out = [];
+  let cur = "";
+  for (const word of text.split(" ")) {
+    if (cur && cur.length + 1 + word.length > w) {
+      out.push(cur);
+      cur = word;
+    } else cur = cur ? `${cur} ${word}` : word;
+  }
+  if (cur) out.push(cur);
+  let inCode = false;
+  return out.map(
+    (l) => l.split("`").map((part, i) => {
+      if (i > 0) inCode = !inCode;
+      return inCode ? paint(PALETTE.cyan, part) : part;
+    }).join("")
+  );
+}
+function wrapLines(text, indent = 2) {
+  const w = Math.max(20, termWidth() - 1);
+  const out = [];
+  let cur = "";
+  for (const word of text.split(" ")) {
+    if (cur && cur.length + 1 + word.length > w) {
+      out.push(cur);
+      cur = " ".repeat(indent) + word;
+    } else cur = cur ? `${cur} ${word}` : word;
+  }
+  if (cur) out.push(cur);
+  return out;
+}
+function numbered(steps) {
+  return (w) => steps.flatMap((s, i) => {
+    const badge = paint(PALETTE.green, ` ${i + 1} `, true);
+    const [first = "", ...rest] = wrapCode(s, Math.max(10, w - 5));
+    return [`${badge}  ${first}`, ...rest.map((r) => `     ${r}`)];
+  });
+}
+function quote(text) {
+  return (w) => {
+    const lines = wrapCode(`\u201C${text}\u201D`, Math.max(10, w - 6)).map((l) => pc.italic(l));
+    return box([...lines, paint(PALETTE.cyan, `\u2014 Sabarivasan`)], Math.min(w, Math.max(...lines.map(width)) + 6), { color: PALETTE.slate, padX: 2 });
+  };
+}
+function renderBody(body, w) {
+  const parts = Array.isArray(body) && body.length && typeof body[0] !== "string" ? body : [body];
+  return parts.flatMap((p) => typeof p === "function" ? p(w) : p);
+}
+function panels(list) {
+  const total = termWidth();
+  const title = (p) => `${paint(p.color, unicode ? p.icon : "*", true)} ${paint(p.color, p.title, true)}`;
+  if (total >= 120) {
+    const gap = 2;
+    const avail = total - gap * (list.length - 1) - 1;
+    const weights = [0.36, 0.32, 0.32];
+    const widths = list.map((_, i) => Math.floor(avail * (weights[i] ?? 1 / list.length)));
+    const bodies = list.map((p, i) => renderBody(p.body, widths[i] - 4));
+    const h = Math.max(...bodies.map((b) => b.length));
+    const boxes = list.map((p, i) => box([title(p), "", ...bodies[i], ...Array(h - bodies[i].length).fill("")], widths[i], { color: p.color, padX: 1 }));
+    return columns(boxes, widths, gap);
+  }
+  const w = Math.min(total - 1, 100);
+  return list.flatMap((p, i) => [...i ? [""] : [], ...box([title(p), "", ...renderBody(p.body, w - 4)], w, { color: p.color })]);
+}
+
+// src/cli/ui/stages.ts
+import pc2 from "picocolors";
+var STAGES = [
+  { id: "scan", label: "Scanning project structure" },
+  { id: "detect", label: "Detecting stack, database, API & auth" },
+  { id: "git", label: "Reading Git metadata" },
+  { id: "finalize", label: "Redacting secrets & validating" },
+  { id: "write", label: "Generating documentation" },
+  { id: "agents", label: "Configuring AI agents" }
+];
+var STAGE_ALIASES = { analyze: "scan" };
+var FRAMES = unicode ? ["\u280B", "\u2819", "\u2839", "\u2838", "\u283C", "\u2834", "\u2826", "\u2827", "\u2807", "\u280F"] : ["-", "\\", "|", "/"];
+var BAR_STOPS = [PALETTE.green, PALETTE.cyan, PALETTE.blue, PALETTE.violet];
+var StageBoard = class {
+  state = new Map(STAGES.map((s) => [s.id, "pending"]));
+  started = /* @__PURE__ */ new Map();
+  elapsed = /* @__PURE__ */ new Map();
+  results = /* @__PURE__ */ new Map();
+  current = null;
+  frame = 0;
+  drawn = 0;
+  timer = null;
+  live = isTTY && !isJson() && !isQuiet();
+  enabled = !isJson() && !isQuiet();
+  restoreCursor = () => process.stdout.write("\x1B[?25h");
+  start() {
+    if (!this.live) return;
+    process.stdout.write("\x1B[?25l");
+    process.once("exit", this.restoreCursor);
+    this.render();
+    this.timer = setInterval(() => {
+      this.frame++;
+      this.render();
+    }, 80);
+    this.timer.unref();
+  }
+  /** Accepts raw pipeline stage names; unknown names are ignored. */
+  enter(raw) {
+    const id = STAGE_ALIASES[raw] ?? raw;
+    if (!this.state.has(id) || this.current === id) return;
+    this.closeCurrent("done");
+    this.current = id;
+    this.state.set(id, "running");
+    this.started.set(id, performance.now());
+  }
+  finish(results) {
+    this.closeCurrent("done");
+    for (const [id, st] of this.state) if (st === "pending") this.state.set(id, "skipped");
+    for (const [id, r] of Object.entries(results)) this.results.set(id, r);
+    this.stop();
+  }
+  fail() {
+    this.closeCurrent("failed");
+    this.stop();
+  }
+  closeCurrent(to) {
+    if (!this.current) return;
+    this.state.set(this.current, to);
+    this.elapsed.set(this.current, performance.now() - this.started.get(this.current));
+    this.current = null;
+  }
+  stop() {
+    if (this.timer) clearInterval(this.timer);
+    this.timer = null;
+    if (!this.enabled) return;
+    if (this.live) {
+      this.render();
+      this.restoreCursor();
+      process.removeListener("exit", this.restoreCursor);
+    } else for (const l of this.lines()) line(l);
+  }
+  render() {
+    const rows2 = this.lines();
+    let s = this.drawn ? `\x1B[${this.drawn}F` : "";
+    for (const r of rows2) s += `\x1B[2K${r}
+`;
+    process.stdout.write(s);
+    this.drawn = rows2.length;
+  }
+  lines() {
+    const total = termWidth();
+    const showBar = total >= 100;
+    const barW = total >= 130 ? 26 : 18;
+    return STAGES.map((s, i) => {
+      const st = this.state.get(s.id);
+      const icon = st === "done" ? paint(PALETTE.green, sym.ok, true) : st === "running" ? paint(PALETTE.cyan, FRAMES[this.frame % FRAMES.length]) : st === "failed" ? pc2.red(sym.err) : pc2.dim(st === "skipped" ? "\u2013" : sym.ring);
+      const label = st === "pending" || st === "skipped" ? pc2.dim(s.label) : s.label;
+      const ms = this.elapsed.get(s.id) ?? (st === "running" ? performance.now() - this.started.get(s.id) : void 0);
+      const time = st === "skipped" ? pc2.dim("skipped") : ms === void 0 ? "" : pc2.dim(ms < 1e3 ? `${Math.max(1, Math.round(ms))}ms` : `${(ms / 1e3).toFixed(1)}s`);
+      const r = this.results.get(s.id);
+      const result = r ? r.tone === "warn" ? paint(PALETTE.amber, `${sym.warn} ${r.text}`) : r.tone === "dim" ? pc2.dim(r.text) : `${paint(PALETTE.green, sym.ok)} ${r.text}` : "";
+      const bar = showBar ? `${this.bar(st, barW, i)}  ` : "";
+      return truncate(`  ${icon}  ${padEnd(label, 40)}${bar}${padEnd(time, 8)}${result}`, total - 1);
+    });
+  }
+  bar(st, w, row) {
+    const fill = unicode ? "\u2501" : "#";
+    const track = unicode ? "\u2500" : "-";
+    if (st === "done") return paint(mix(BAR_STOPS, row / (STAGES.length - 1)), fill.repeat(w));
+    if (st === "failed") return pc2.red(fill.repeat(w));
+    if (st !== "running") return pc2.dim(track.repeat(w));
+    const seg = 6;
+    const span = w - seg;
+    const t = this.frame % (span * 2);
+    const pos = t <= span ? t : span * 2 - t;
+    return pc2.dim(track.repeat(pos)) + paint(PALETTE.cyan, fill.repeat(seg)) + pc2.dim(track.repeat(w - pos - seg));
+  }
+};
+
+// src/cli/commands/init.ts
+function parseAgentsOption(value, disabled) {
+  if (disabled) return [];
+  if (value === void 0) return void 0;
+  if (value.trim().toLowerCase() === "all") return [...ADAPTERS];
+  if (value.trim().toLowerCase() === "none") return [];
+  try {
+    return resolveAdapters(value.split(","));
+  } catch (err) {
+    throw new AthenaError(err.message);
+  }
+}
+async function initCommand(opts) {
+  const root = await resolveCwd(opts);
+  const existing = await readState(path.join(root, ".athena"));
+  if (existing.kind === "ok") {
+    throw new AthenaError("Athena is already initialized in this project.", "Run `athena analyze` to refresh knowledge, or `athena clean` to start over.");
+  }
+  const agents = parseAgentsOption(opts.agents, opts.noAgents);
+  printHeader();
+  const result = await runWithProgress(root, { mode: "init", dryRun: opts.dryRun, agents, signal: opts.signal });
+  if (isJson()) {
+    json(summarize(result, root, Boolean(opts.dryRun)));
+    return;
+  }
+  printSummary(result, Boolean(opts.dryRun), "init");
+}
+async function runWithProgress(root, o) {
+  const board = new StageBoard();
+  board.start();
+  try {
+    const result = await runPipeline({
+      root,
+      mode: o.mode,
+      dryRun: o.dryRun,
+      force: o.force,
+      agents: o.agents,
+      signal: o.signal,
+      onStage: (stage) => board.enter(stage)
+    });
+    board.finish(stageResults(result, o.mode, Boolean(o.dryRun)));
+    return result;
+  } catch (err) {
+    board.fail();
+    throw err;
+  }
+}
+var plural = (n, word) => `${n} ${word}${n === 1 ? "" : "s"}`;
+function stageResults(result, mode, dryRun) {
+  const m = result.analysis.model;
+  const skipped = m.stats.skippedBinary + m.stats.skippedLarge + m.stats.skippedUnreadable;
+  const found = [
+    m.frameworks.length && plural(new Set(m.frameworks.map((f) => f.name)).size, "framework"),
+    m.dbEntities.length && plural(m.dbEntities.length, "entity").replace("entitys", "entities"),
+    m.routes.length && plural(m.routes.length, "route"),
+    m.auth.length && "auth"
+  ].filter(Boolean);
+  const changed = result.docs.filter((d) => d.status !== "unchanged").length;
+  const agents = result.agentChanges.map((a) => a.adapter.displayName);
+  return {
+    scan: { text: `Found ${plural(m.stats.filesScanned, "file")}${skipped ? ` \xB7 ${skipped} skipped` : ""}` },
+    detect: found.length ? { text: found.join(" \xB7 ") } : { text: "No frameworks detected", tone: "dim" },
+    git: m.git.isRepo ? { text: `On ${m.git.branch ?? "detached HEAD"}${m.git.head ? ` @ ${m.git.head.slice(0, 7)}` : ""}` } : { text: m.git.available ? "Not a Git repository" : "Git not installed", tone: "dim" },
+    finalize: m.security.secrets.length ? { text: `${plural(m.security.secrets.length, "potential secret")} (values redacted)`, tone: "warn" } : { text: "No likely secrets found" },
+    write: dryRun ? { text: "Dry run \u2014 nothing written", tone: "dim" } : { text: mode === "init" ? `${plural(result.docs.length, "document")} generated` : changed ? `${changed} updated \xB7 ${result.docs.length - changed} unchanged` : "Already up to date" },
+    agents: agents.length ? { text: agents.join(", ") } : { text: "None configured", tone: "dim" }
+  };
+}
+var DOC_NOTES = {
+  "project.md": "Project overview",
+  "architecture.md": "System architecture",
+  "database.md": "Database schema",
+  "api.md": "API reference",
+  "auth.md": "Authentication flow",
+  "security.md": "Security analysis",
+  "testing.md": "Testing strategy",
+  "debugging.md": "Debugging guide",
+  "performance.md": "Performance notes",
+  "code-review.md": "Review checklist",
+  "deployment.md": "Deployment guide",
+  "rules.md": "Your project rules"
+};
+function printSummary(result, dryRun, mode) {
+  const m = result.analysis.model;
+  if (isQuiet()) {
+    for (const w of m.warnings) warn(w);
+    for (const n of result.notes) warn(n);
+    for (const d of result.docs.filter((x) => x.preservedModified.length)) warn(`${d.file}: kept your edits in ${d.preservedModified.join(", ")}`);
+    const changed = result.docs.filter((d) => d.status !== "unchanged").map((d) => d.file);
+    line(dryRun ? "Dry run: nothing written." : changed.length ? `Updated: ${changed.join(", ")}` : "Knowledge up to date.");
+    return;
+  }
+  const uniq = (xs) => [...new Set(xs)];
+  const list = (xs, n = 4) => uniq(xs).slice(0, n).join(" \xB7 ");
+  line();
+  for (const l of sectionTitle(dryRun ? "Dry Run Complete" : "Analysis Complete!")) line(l);
+  line(`  Analyzed ${accent(String(m.stats.filesScanned))} files in ${accent(`${(result.analysis.durationMs / 1e3).toFixed(1)}s`)}`);
+  line();
+  const overview = [
+    ["Project", `${m.name}${m.languages[0] ? ` \xB7 ${list(m.languages.map((l) => l.name), 3)}` : ""}`],
+    ["Frameworks", list(m.frameworks.map((f) => f.name), 5)],
+    ["Workspace", m.workspace.isMonorepo ? `monorepo \xB7 ${plural(m.workspace.packages.length, "package")}` : ""],
+    ["Database", m.databases.length + m.dbEntities.length ? [list(m.databases.map((d) => d.name), 3), m.dbEntities.length ? plural(m.dbEntities.length, "entity").replace("entitys", "entities") : ""].filter(Boolean).join(" \xB7 ") : ""],
+    ["API", m.routes.length + m.apiSpecs.length ? [m.routes.length ? plural(m.routes.length, "route") : "", m.apiSpecs.length ? plural(m.apiSpecs.length, "spec") : ""].filter(Boolean).join(" \xB7 ") : ""],
+    ["Auth", list(m.auth.map((a) => a.name), 3)],
+    ["Testing", m.tests.frameworks.length + m.tests.testFileCount ? [list(m.tests.frameworks.map((f) => f.name), 3), plural(m.tests.testFileCount, "test file")].filter(Boolean).join(" \xB7 ") : ""],
+    ["Deployment", [m.containers.dockerfiles.length ? "Docker" : "", ...uniq(m.ci.map((j) => j.system)), ...uniq(m.infrastructure.filter((i) => i.kind === "hosting").map((i) => i.name))].filter(Boolean).slice(0, 4).join(" \xB7 ")],
+    ["Security", m.security.secrets.length ? warnText(`${plural(m.security.secrets.length, "potential secret")} \u2014 see security.md`) : "No likely secrets matched"]
+  ];
+  const files = dryRun ? ["Would create .athena/ with:", ...[...KNOWLEDGE_DOCS.map((d) => d.file), "model.json", "state.json"].map((f) => `  ${f}`)] : fileTree(
+    ".athena/",
+    result.docs.map((d) => ({ name: d.file, note: mode === "init" ? DOC_NOTES[d.file] ?? "" : d.status, highlight: mode === "analyze" && d.status !== "unchanged" }))
+  );
+  const configured = result.agentChanges.length > 0;
+  const steps = dryRun ? ["Run `athena init` without --dry-run to write the files"] : mode === "init" ? [
+    "Review `.athena/rules.md` and enable the rules that apply",
+    "Run `athena open` to browse and edit in the web UI",
+    configured ? "Your agents now read `.athena/` \u2014 watch with `athena activity`" : "Connect an agent: `athena agents add claude-code`",
+    "After code changes run `athena sync` to keep docs current",
+    "Guides and docs: https://athena.sabari.me \xB7 star us on GitHub \u2605"
+  ] : ["Review changes with `git diff .athena/`", "Run `athena open` to browse in the web UI", "Use `athena sync --watch` to stay current"];
+  for (const l of panels([
+    { title: "Project Overview", icon: "\u25C6", color: C.blue, body: rows(overview) },
+    { title: mode === "init" ? "Generated Files" : "Knowledge Files", icon: "\u25A4", color: C.violet, body: files },
+    { title: "Next Steps", icon: "\u279C", color: C.green, body: mode === "init" && !dryRun ? [numbered(steps), [""], quote("Better documentation leads to better software.")] : numbered(steps) }
+  ]))
+    line(l);
+  const preserved = result.docs.filter((d) => d.preservedModified.length);
+  const notes = [
+    ...m.warnings.slice(0, 5).map((w) => () => warn(c.yellow(w))),
+    ...m.warnings.length > 5 ? [() => line(dim(`  +${m.warnings.length - 5} more warnings (see .athena/project.md)`))] : [],
+    ...preserved.map((d) => () => warn(`${d.file}: kept your edits in ${d.preservedModified.join(", ")} ${dim("(use --force to regenerate)")}`)),
+    ...(dryRun ? [] : result.agentChanges).map(({ adapter, changes }) => () => {
+      const touched = changes.filter((c2) => c2.action !== "unchanged").map((c2) => `${c2.path} (${c2.action})`);
+      ok(`${adapter.displayName} integration${dim(` \u2014 ${touched.length ? touched.join(", ") : changes.map((c2) => c2.path).join(", ") + " (unchanged)"}`)}`);
+    }),
+    ...mode === "init" && !dryRun ? (() => {
+      const unconfigured = ADAPTERS.filter((a) => !result.agentChanges.some((c2) => c2.adapter.id === a.id));
+      const text = `Not configured (not detected in this project): ${unconfigured.map((a) => a.id).join(", ")}. Add one with \`athena agents add <id>\`.`;
+      return unconfigured.length ? [() => wrapLines(text).forEach((l) => line(dim(l)))] : [];
+    })() : [],
+    ...dryRun ? result.agentChanges.flatMap(({ adapter, changes }) => changes.map((ch) => () => bullet(`${adapter.displayName}: would ${ch.action} ${ch.path}`))) : [],
+    ...result.notes.map((n) => () => warn(n))
+  ];
+  if (notes.length) {
+    line();
+    for (const print of notes) print();
+  }
+  line();
+  const lines = dryRun ? footer("Dry run \u2014 nothing was written.", "Re-run without --dry-run to create .athena/", "warn") : mode === "init" ? footer("Athena is ready!", `Your project intelligence is ready in ${accent(".athena/")}`) : footer("Analysis complete.", `Knowledge in ${accent(".athena/")} is up to date with your code`);
+  for (const l of lines) line(l);
+}
+function summarize(result, root, dryRun) {
+  const m = result.analysis.model;
+  return {
+    root,
+    dryRun,
+    project: m.name,
+    filesScanned: m.stats.filesScanned,
+    durationMs: result.analysis.durationMs,
+    languages: m.languages.slice(0, 5).map((l) => l.name),
+    frameworks: [...new Set(m.frameworks.map((f) => f.name))],
+    monorepo: m.workspace.isMonorepo,
+    databases: m.databases.map((d) => d.name),
+    entities: m.dbEntities.length,
+    routes: m.routes.length,
+    testFiles: m.tests.testFileCount,
+    potentialSecrets: m.security.secrets.length,
+    documents: result.docs.map((d) => ({ file: d.file, status: d.status, preservedModified: d.preservedModified })),
+    agents: result.agentChanges.map((a) => ({ id: a.adapter.id, files: a.changes.map((c2) => ({ path: c2.path, action: c2.action })) })),
+    warnings: m.warnings,
+    notes: result.notes
+  };
+}
+
+export {
+  parseAgentsOption,
+  initCommand,
+  runWithProgress,
+  printSummary,
+  summarize
+};
+//# sourceMappingURL=chunk-XDCKZ5TV.js.map

package/dist/chunk-XFN7UZCS.js

@@ -0,0 +1,35 @@
+#!/usr/bin/env node
+import {
+  findProjectRoot
+} from "./chunk-KBO7XRBW.js";
+import {
+  AthenaError,
+  EXIT
+} from "./chunk-AD4OZCU2.js";
+
+// src/cli/context.ts
+import { promises as fs } from "fs";
+import path from "path";
+async function resolveCwd(opts) {
+  const dir = path.resolve(opts.cwd ?? process.cwd());
+  try {
+    const st = await fs.stat(dir);
+    if (!st.isDirectory()) throw new AthenaError(`Not a directory: ${dir}`);
+    return await fs.realpath(dir);
+  } catch (err) {
+    if (err instanceof AthenaError) throw err;
+    throw new AthenaError(`Directory not accessible: ${dir}`, "Check the path and your permissions.");
+  }
+}
+async function requireProjectRoot(opts) {
+  const cwd = await resolveCwd(opts);
+  const root = await findProjectRoot(cwd);
+  if (!root) throw new AthenaError("Athena is not initialized in this project.", "Run `athena init` in the project root.", EXIT.NOT_INITIALIZED);
+  return root;
+}
+
+export {
+  resolveCwd,
+  requireProjectRoot
+};
+//# sourceMappingURL=chunk-XFN7UZCS.js.map

package/dist/chunk-XW3MLHI2.js

@@ -0,0 +1,32 @@
+#!/usr/bin/env node
+
+// src/core/util/paths.ts
+import path from "path";
+function toPosix(p) {
+  return p.split(path.sep).join("/").replace(/\\/g, "/");
+}
+function resolveInside(root, candidate) {
+  if (candidate.includes("\0")) return null;
+  const resolvedRoot = path.resolve(root);
+  const resolved = path.resolve(resolvedRoot, candidate);
+  const rel = path.relative(resolvedRoot, resolved);
+  if (rel === "") return resolved;
+  if (rel.startsWith("..") || path.isAbsolute(rel)) return null;
+  return resolved;
+}
+function dirOf(posixPath) {
+  const i = posixPath.lastIndexOf("/");
+  return i === -1 ? "." : posixPath.slice(0, i);
+}
+function baseName(posixPath) {
+  const i = posixPath.lastIndexOf("/");
+  return i === -1 ? posixPath : posixPath.slice(i + 1);
+}
+
+export {
+  toPosix,
+  resolveInside,
+  dirOf,
+  baseName
+};
+//# sourceMappingURL=chunk-XW3MLHI2.js.map