@joshuafolkken/kit 1.3044.0 → 1.3092.0

package/dist/commands/chunk-VCPGFBMN.js

@@ -1,655 +0,0 @@
-import {
-  run_cut_report
-} from "./chunk-J66YBAAM.js";
-import {
-  implementation_cut
-} from "./chunk-7OQ56DVW.js";
-import {
-  tail_commands
-} from "./chunk-NDBX7LSS.js";
-import {
-  cost_pricing
-} from "./chunk-GW4UWR3O.js";
-import {
-  git_branch
-} from "./chunk-Q5Q2QYVU.js";
-import {
-  backlog_budget
-} from "./chunk-BYSPYVLD.js";
-import {
-  figure_format
-} from "./chunk-ZZXO6TFH.js";
-import {
-  session_cite
-} from "./chunk-22DVQCP6.js";
-import {
-  cost_transcript,
-  cost_usage
-} from "./chunk-6WKJ3GDA.js";
-import {
-  lane_paths
-} from "./chunk-YIA6FC3K.js";
-import {
-  issue_number_shape
-} from "./chunk-66NX6EXR.js";
-
-// tools/cost/cost-run-tree.ts
-import path from "node:path";
-
-// tools/cost/cost-run-cut.ts
-var { CUT_VERDICT, RESUME_VERDICT } = run_cut_report;
-function took_cut_text(text) {
-  return tail_commands.answered(text, implementation_cut.takes_the_impl_cut, CUT_VERDICT);
-}
-function is_ship_text(text) {
-  return tail_commands.answered(text, implementation_cut.resumes_a_cut, RESUME_VERDICT);
-}
-function lane_marks(file) {
-  const text = cost_transcript.read_raw(file);
-  return { took_cut: took_cut_text(text), is_ship: is_ship_text(text) };
-}
-var cost_run_cut = { is_ship_text, lane_marks, took_cut_text };
-
-// tools/cost/cost-run-nodes.ts
-var PARENT_DEPTH = 0;
-var LANE_DEPTH = 1;
-var FIRST = 0;
-function branch_issue(records) {
-  for (const record of records) {
-    const issue = git_branch.issue_from_branch(record.branch);
-    if (issue !== void 0) return issue;
-  }
-  return void 0;
-}
-function started_ms(records) {
-  const stamps = records.map((record) => record.at_ms).filter((ms) => ms !== void 0);
-  return stamps.length === FIRST ? Infinity : Math.min(...stamps);
-}
-function bucket_of(file, context) {
-  if (file.is_delegated) return "subs";
-  if (context.lane_issue(file) === void 0) return "mains";
-  return "lanes";
-}
-function split_files(files, context) {
-  const split = { mains: [], lanes: [], subs: [] };
-  for (const file of files) split[bucket_of(file, context)].push(file);
-  return split;
-}
-function order_mains(mains, context) {
-  return [...mains].toSorted(
-    (left, right) => started_ms(context.facts(left.session_id).records) - started_ms(context.facts(right.session_id).records)
-  );
-}
-function to_node(file, role, head, facts) {
-  return {
-    session_id: file.session_id,
-    role,
-    modified_ms: file.modified_ms,
-    records: facts.records,
-    baseline_tokens: facts.baseline_tokens,
-    is_readable: facts.is_readable,
-    took_cut: false,
-    is_ship: false,
-    ...head
-  };
-}
-function main_node(file, is_parent, root_id, context) {
-  return to_node(
-    file,
-    is_parent ? "parent" : "wake",
-    { issue: void 0, parent_id: is_parent ? void 0 : root_id, depth: PARENT_DEPTH },
-    context.facts(file.session_id)
-  );
-}
-function lane_node(file, root_id, context) {
-  const facts = context.facts(file.session_id);
-  const node = to_node(
-    file,
-    "lane",
-    {
-      issue: context.lane_issue(file) ?? branch_issue(facts.records),
-      parent_id: root_id,
-      depth: LANE_DEPTH
-    },
-    facts
-  );
-  return { ...node, ...context.lane_marks(file) };
-}
-function sub_node(file, lane_roots, context) {
-  const facts = context.facts(file.session_id);
-  const base = lane_roots.has(cost_transcript.owning_session_id(file)) ? LANE_DEPTH : PARENT_DEPTH;
-  return to_node(
-    file,
-    "subagent",
-    {
-      issue: branch_issue(facts.records),
-      parent_id: cost_transcript.parent_session_id(file),
-      depth: base + file.depth
-    },
-    facts
-  );
-}
-function build_nodes(files, context) {
-  const split = split_files(files, context);
-  const mains = order_mains(split.mains, context);
-  const root_id = mains[FIRST]?.session_id;
-  const lane_roots = new Set(split.lanes.map((file) => file.session_id));
-  return [
-    ...mains.map(
-      (file, index) => main_node(file, index === FIRST, root_id ?? file.session_id, context)
-    ),
-    ...split.lanes.map((file) => lane_node(file, root_id, context)),
-    ...split.subs.map((file) => sub_node(file, lane_roots, context))
-  ];
-}
-var cost_run_nodes = {
-  issue_from_branch: git_branch.issue_from_branch,
-  started_ms,
-  split_files,
-  order_mains,
-  build_nodes
-};
-
-// tools/cost/cost-run-tree.ts
-var RUN_GAP_MS = backlog_budget.DEFAULT_IDLE_MS + backlog_budget.OFFER_INTERVAL_MS;
-var FIRST2 = 0;
-var NONE = -1;
-function cluster_end(cluster) {
-  return Math.max(...cluster.files.map((file) => file.modified_ms));
-}
-function start_of(file, context) {
-  return cost_run_nodes.started_ms(context.facts(file.session_id).records);
-}
-function write_stamps(activity, context) {
-  const stamps = activity.sessions.flatMap(
-    (file) => context.facts(file.session_id).records.map((record) => record.at_ms)
-  );
-  return stamps.filter((ms) => ms !== void 0).toSorted((left, right) => left - right);
-}
-function writes_before(activity, context) {
-  const stamps = write_stamps(activity, context);
-  const before = /* @__PURE__ */ new Map();
-  let cursor = FIRST2;
-  for (const main of activity.mains) {
-    const start = start_of(main, context);
-    while ((stamps[cursor] ?? Infinity) < start) cursor += 1;
-    before.set(main.session_id, stamps[cursor - 1] ?? -Infinity);
-  }
-  return before;
-}
-function fits(last, quiet_ms) {
-  return last !== void 0 && quiet_ms <= RUN_GAP_MS;
-}
-function open_cluster(file, start) {
-  return { root_id: file.session_id, first_start: start, files: [file] };
-}
-function cluster_mains(activity, context) {
-  const clusters = [];
-  const before = writes_before(activity, context);
-  for (const file of activity.mains) {
-    const start = start_of(file, context);
-    const last = clusters.at(NONE);
-    if (fits(last, start - (before.get(file.session_id) ?? -Infinity))) last.files.push(file);
-    else clusters.push(open_cluster(file, start));
-  }
-  return clusters;
-}
-function cluster_for_start(clusters, start) {
-  return clusters.findLast((cluster) => cluster.first_start <= start) ?? clusters[FIRST2];
-}
-function attach_lanes(clusters, lanes, context) {
-  for (const file of lanes) {
-    const start = cost_run_nodes.started_ms(context.facts(file.session_id).records);
-    cluster_for_start(clusters, start)?.files.push(file);
-  }
-}
-function index_by_session(clusters) {
-  const by_session = /* @__PURE__ */ new Map();
-  for (const cluster of clusters) {
-    for (const file of cluster.files) by_session.set(file.session_id, cluster);
-  }
-  return by_session;
-}
-function attach_subs(clusters, subs, context) {
-  const by_session = index_by_session(clusters);
-  for (const file of subs) {
-    const owner = by_session.get(cost_transcript.owning_session_id(file));
-    const start = cost_run_nodes.started_ms(context.facts(file.session_id).records);
-    (owner ?? cluster_for_start(clusters, start))?.files.push(file);
-  }
-}
-function build_clusters(files, context) {
-  const split = cost_run_nodes.split_files(files, context);
-  const has_mains = split.mains.length > FIRST2;
-  const roots = has_mains ? split.mains : split.lanes;
-  const mains = cost_run_nodes.order_mains(roots, context);
-  const clusters = cluster_mains({ mains, sessions: [...split.mains, ...split.lanes] }, context);
-  if (has_mains) attach_lanes(clusters, split.lanes, context);
-  attach_subs(clusters, split.subs, context);
-  return clusters;
-}
-function last_cluster(clusters) {
-  return [...clusters].toSorted((left, right) => cluster_end(right) - cluster_end(left))[FIRST2];
-}
-function named_cluster(clusters, run_id) {
-  return clusters.find(
-    (cluster) => cluster.root_id === run_id || cluster.files.some((file) => file.session_id === run_id)
-  );
-}
-function select(clusters, run_id) {
-  return run_id === void 0 ? last_cluster(clusters) : named_cluster(clusters, run_id);
-}
-function to_tree(files, chosen, context, run_count) {
-  const nodes = cost_run_nodes.build_nodes(chosen.files, context);
-  return {
-    nodes,
-    files: chosen.files,
-    run_count,
-    unattributed_count: files.length - chosen.files.length
-  };
-}
-function build_tree(files, context, run_id) {
-  const clusters = build_clusters(files, context);
-  const chosen = select(clusters, run_id);
-  if (chosen === void 0) return void 0;
-  return to_tree(files, chosen, context, clusters.length);
-}
-function lane_prefix(cwd) {
-  return `${cost_transcript.project_slug(lane_paths.lane_root(cwd))}-`;
-}
-function slug_of(file_path, projects_root) {
-  return path.relative(projects_root, file_path).split(path.sep)[FIRST2] ?? "";
-}
-function lane_issue_of(file, projects_root, prefix) {
-  const slug = slug_of(file.path, projects_root);
-  if (!slug.startsWith(prefix)) return void 0;
-  const rest = slug.slice(prefix.length);
-  return issue_number_shape.ISSUE_NUMBER_PATTERN.test(rest) ? Number(rest) : void 0;
-}
-function to_context(files, cwd, projects_root) {
-  const prefix = lane_prefix(cwd);
-  const usage = new Map(files.map((file) => [file.session_id, cost_transcript.read_session(file)]));
-  return {
-    facts: (id) => usage.get(id) ?? { records: [], baseline_tokens: 0, is_readable: false },
-    lane_issue: (file) => lane_issue_of(file, projects_root, prefix),
-    lane_marks: (file) => cost_run_cut.lane_marks(file)
-  };
-}
-function load(cwd, run_id) {
-  const directories = cost_transcript.transcript_directories(cwd);
-  const files = cost_transcript.list_sessions_across(directories);
-  if (files.length === FIRST2) return void 0;
-  const projects_root = path.dirname(directories[FIRST2] ?? "");
-  return build_tree(files, to_context(files, cwd, projects_root), run_id);
-}
-var cost_run_tree = {
-  build_tree,
-  lane_issue_of,
-  load
-};
-
-// tools/cost/cost-run-issues.ts
-var NONE2 = 0;
-function sum(rows, pick) {
-  return rows.reduce((total, row) => total + pick(row), NONE2);
-}
-function totals_of(issue, rows) {
-  return {
-    issue,
-    session_count: rows.length,
-    cost_usd: sum(rows, (row) => row.cost_usd),
-    request_count: sum(rows, (row) => row.request_count),
-    elapsed_ms: sum(rows, (row) => row.elapsed_ms),
-    took_cut: rows.some((row) => row.took_cut),
-    is_measured: rows.every((row) => row.is_measured)
-  };
-}
-function group_by_issue(rows) {
-  const groups = /* @__PURE__ */ new Map();
-  for (const row of rows) {
-    if (row.issue !== void 0) groups.set(row.issue, [...groups.get(row.issue) ?? [], row]);
-  }
-  return groups;
-}
-function build(rows) {
-  return [...group_by_issue(rows)].map(([issue, members]) => totals_of(issue, members)).toSorted((left, right) => left.issue - right.issue);
-}
-var cost_run_issues = { build };
-
-// tools/cost/cost-dollar-composition.ts
-var ZERO = {
-  input_usd: 0,
-  cache_write_5m_usd: 0,
-  cache_write_1h_usd: 0,
-  cache_read_usd: 0,
-  output_usd: 0
-};
-function add(left, right) {
-  return {
-    input_usd: left.input_usd + right.input_usd,
-    cache_write_5m_usd: left.cache_write_5m_usd + right.cache_write_5m_usd,
-    cache_write_1h_usd: left.cache_write_1h_usd + right.cache_write_1h_usd,
-    cache_read_usd: left.cache_read_usd + right.cache_read_usd,
-    output_usd: left.output_usd + right.output_usd
-  };
-}
-function total_of(parts) {
-  return parts.input_usd + parts.cache_write_5m_usd + parts.cache_write_1h_usd + parts.cache_read_usd + parts.output_usd;
-}
-function build2(costs) {
-  let parts = ZERO;
-  const unpriced = [];
-  for (const entry of costs) {
-    const price = cost_pricing.resolve_price(entry.model);
-    if (price === void 0) {
-      unpriced.push(entry.model);
-      continue;
-    }
-    parts = add(parts, cost_pricing.estimate_composition(entry.totals, price));
-  }
-  return { ...parts, total_usd: total_of(parts), unpriced_models: unpriced };
-}
-var cost_dollar_composition = { build: build2 };
-
-// tools/cost/cost-run-roles.ts
-var NONE3 = 0;
-var WHOLE = 1;
-var TWO = 2;
-var ROLE_ORDER = ["parent", "wake", "lane", "subagent"];
-function records_of(nodes) {
-  return nodes.flatMap((node) => [...node.records]);
-}
-function cost_of(records) {
-  return cost_pricing.cost_of(records);
-}
-function elapsed_of(records) {
-  const stamps = records.map((record) => record.at_ms).filter((ms) => ms !== void 0);
-  return stamps.length < TWO ? NONE3 : Math.max(...stamps) - Math.min(...stamps);
-}
-function elapsed_of_nodes(nodes) {
-  return nodes.reduce((total, node) => total + elapsed_of(node.records), NONE3);
-}
-function preamble_of(nodes) {
-  return nodes.reduce((total, node) => total + node.baseline_tokens, NONE3);
-}
-function share(part, whole) {
-  return whole === NONE3 ? NONE3 : part / whole;
-}
-function role_totals(role, nodes, run2) {
-  const records = records_of(nodes);
-  const models = cost_pricing.cost_by_model(records);
-  const cost_usd = cost_pricing.total_cost(models).usd;
-  const elapsed_ms = elapsed_of_nodes(nodes);
-  return {
-    role,
-    session_count: nodes.length,
-    request_count: records.length,
-    output_tokens: cost_usage.sum_totals(records).output_tokens,
-    cost_usd,
-    composition: cost_dollar_composition.build(models),
-    preamble_tokens: preamble_of(nodes),
-    cost_share: share(cost_usd, run2.total_usd),
-    elapsed_ms,
-    elapsed_share: share(elapsed_ms, run2.total_elapsed_ms)
-  };
-}
-function nodes_in_role(nodes, role) {
-  return nodes.filter((node) => node.role === role);
-}
-function build_roles(nodes, run2) {
-  return ROLE_ORDER.map((role) => role_totals(role, nodes_in_role(nodes, role), run2)).filter(
-    (totals) => totals.session_count > NONE3
-  );
-}
-function to_row(node) {
-  return {
-    session_id: node.session_id,
-    role: node.role,
-    issue: node.issue,
-    parent_id: node.parent_id,
-    depth: node.depth,
-    is_readable: node.is_readable,
-    is_measured: node.is_readable && node.records.length > NONE3,
-    cost_usd: cost_of(node.records),
-    elapsed_ms: elapsed_of(node.records),
-    request_count: node.records.length,
-    output_tokens: cost_usage.sum_totals(node.records).output_tokens,
-    preamble_tokens: node.baseline_tokens,
-    took_cut: node.took_cut
-  };
-}
-function build_rows(nodes) {
-  return nodes.map((node) => to_row(node)).toSorted((left, right) => right.cost_usd - left.cost_usd);
-}
-function unreadable_of(nodes) {
-  return nodes.filter((node) => !node.is_readable).length;
-}
-function lane_issue_rows(rows, issue) {
-  return rows.filter((row) => row.role === "lane" && row.issue === issue);
-}
-function measure_lane_issue(rows, issue) {
-  const matching = lane_issue_rows(rows, issue);
-  if (matching.length === NONE3 || matching.some((row) => !row.is_measured)) return void 0;
-  return {
-    output_tokens: matching.reduce((total, row) => total + row.output_tokens, NONE3),
-    cost_usd: matching.reduce((total, row) => total + row.cost_usd, NONE3),
-    elapsed_ms: matching.reduce((total, row) => total + row.elapsed_ms, NONE3)
-  };
-}
-function build3(nodes) {
-  const run2 = { total_usd: cost_of(records_of(nodes)), total_elapsed_ms: elapsed_of_nodes(nodes) };
-  return {
-    roles: build_roles(nodes, run2),
-    sessions: build_rows(nodes),
-    total_usd: run2.total_usd,
-    total_elapsed_ms: run2.total_elapsed_ms,
-    unreadable_count: unreadable_of(nodes)
-  };
-}
-function shares_total(roles) {
-  return roles.reduce((total, role) => total + role.cost_share, NONE3);
-}
-var cost_run_roles = { ROLE_ORDER, WHOLE, build: build3, measure_lane_issue, shares_total };
-
-// tools/cost/cost-run-phase.ts
-var NONE4 = 0;
-var PHASE_PAD = 9;
-function totals_of2(phase, nodes) {
-  const lane = cost_run_roles.build(nodes).roles.find((totals) => totals.role === "lane");
-  if (lane === void 0) return { phase, session_count: NONE4, request_count: NONE4, cost_usd: NONE4 };
-  return {
-    phase,
-    session_count: lane.session_count,
-    request_count: lane.request_count,
-    cost_usd: lane.cost_usd
-  };
-}
-function build4(nodes) {
-  const lanes = nodes.filter((node) => node.role === "lane");
-  return [
-    totals_of2(
-      "implement",
-      lanes.filter((node) => !node.is_ship)
-    ),
-    totals_of2(
-      "ship",
-      lanes.filter((node) => node.is_ship)
-    )
-  ];
-}
-function phase_line(totals) {
-  const requests = `${String(totals.request_count)} request(s)`;
-  return `  ${totals.phase.padEnd(PHASE_PAD)} ${String(totals.session_count)} session(s) \xB7 ${requests} \xB7 ${figure_format.format_usd(totals.cost_usd)}`;
-}
-function format_lines(phases) {
-  if (phases.every((totals) => totals.session_count === NONE4)) return [];
-  return ["", "Worker by phase:", ...phases.map((totals) => phase_line(totals))];
-}
-var cost_run_phase = { build: build4, format_lines };
-
-// tools/cost/cost-run-split.ts
-var NONE5 = 0;
-var DENSITY_DIGITS = 1;
-var ROLE_PAD = 8;
-var NO_VALUE = "\u2014";
-function to_side(nodes) {
-  const roles = cost_run_roles.build(nodes);
-  return {
-    session_count: nodes.length,
-    total_usd: roles.total_usd,
-    total_elapsed_ms: roles.total_elapsed_ms,
-    roles: roles.roles
-  };
-}
-function build5(nodes, at_ms) {
-  const starts = nodes.map((node) => ({ node, start: cost_run_nodes.started_ms(node.records) }));
-  const stamped = starts.filter((entry) => Number.isFinite(entry.start));
-  return {
-    at: new Date(at_ms).toISOString(),
-    before: to_side(stamped.filter((entry) => entry.start < at_ms).map((entry) => entry.node)),
-    after: to_side(stamped.filter((entry) => entry.start >= at_ms).map((entry) => entry.node))
-  };
-}
-function side_line(label, side) {
-  const minutes = figure_format.format_minutes(side.total_elapsed_ms);
-  return `  ${label.padEnd(ROLE_PAD)} ${String(side.session_count)} session(s) \xB7 ${minutes} \xB7 ${figure_format.format_usd(side.total_usd)}`;
-}
-function role_of(side, role) {
-  return side.roles.find((totals) => totals.role === role);
-}
-function time_share(totals, side) {
-  if (totals === void 0) return NO_VALUE;
-  return figure_format.format_share(totals.elapsed_ms, side.total_elapsed_ms);
-}
-function cost_share(totals, side) {
-  if (totals === void 0) return NO_VALUE;
-  return figure_format.format_share(totals.cost_usd, side.total_usd);
-}
-function density(totals) {
-  if (totals === void 0 || totals.session_count === NONE5) return NO_VALUE;
-  return (totals.request_count / totals.session_count).toFixed(DENSITY_DIGITS);
-}
-function role_line(split, role) {
-  const before = role_of(split.before, role);
-  const after = role_of(split.after, role);
-  const time = `time ${time_share(before, split.before)} \u2192 ${time_share(after, split.after)}`;
-  const spent = `cost ${cost_share(before, split.before)} \u2192 ${cost_share(after, split.after)}`;
-  return `  ${role.padEnd(ROLE_PAD)} ${time} \xB7 ${spent} \xB7 req/session ${density(before)} \u2192 ${density(after)}`;
-}
-function has_role(split, role) {
-  return role_of(split.before, role) !== void 0 || role_of(split.after, role) !== void 0;
-}
-function format_lines2(split) {
-  const roles = cost_run_roles.ROLE_ORDER.filter((role) => has_role(split, role));
-  return [
-    "",
-    `Before \u2192 after ${split.at} (each session by its first request):`,
-    side_line("before", split.before),
-    side_line("after", split.after),
-    ...roles.map((role) => role_line(split, role))
-  ];
-}
-var cost_run_split = { build: build5, format_lines: format_lines2 };
-
-// tools/cost/cost-run-report.ts
-var FAILURE_EXIT_CODE = 1;
-var OK_EXIT_CODE = 0;
-var JSON_INDENT = 2;
-var NOT_MEASURED = "not measured";
-var ROLE_PAD2 = 8;
-var ISSUE_PAD = 6;
-var { format_minutes, format_share, format_tokens, format_usd } = figure_format;
-var DEFAULT_VIEW = { lead: [], split_at_ms: void 0 };
-function build6(run_count, unattributed_count, nodes, split_at_ms) {
-  const roles = cost_run_roles.build(nodes);
-  return {
-    scope: "run tree",
-    session_count: nodes.length,
-    run_count,
-    merged: void 0,
-    unattributed_count,
-    unreadable_count: roles.unreadable_count,
-    total_usd: roles.total_usd,
-    total_elapsed_ms: roles.total_elapsed_ms,
-    roles: roles.roles,
-    sessions: roles.sessions,
-    issues: cost_run_issues.build(roles.sessions),
-    worker_phases: cost_run_phase.build(nodes),
-    split: split_at_ms === void 0 ? void 0 : cost_run_split.build(nodes, split_at_ms)
-  };
-}
-function count_or_missing(count) {
-  return count === void 0 ? NOT_MEASURED : String(count);
-}
-function header_lines(report) {
-  return [
-    `run tree \u2014 ${String(report.session_count)} session(s), ${format_minutes(report.total_elapsed_ms)} active, ${format_usd(report.total_usd)}`,
-    `runs in store: ${String(report.run_count)} \xB7 merges: ${count_or_missing(report.merged)} \xB7 transcripts outside this run: ${String(report.unattributed_count)} \xB7 unreadable: ${String(report.unreadable_count)}`
-  ];
-}
-function role_line2(role, report) {
-  const spent = `${format_usd(role.cost_usd)} ${format_share(role.cost_usd, report.total_usd)}`;
-  const time = `${format_minutes(role.elapsed_ms)} ${format_share(role.elapsed_ms, report.total_elapsed_ms)}`;
-  const counts = `${String(role.session_count)} session(s) \xB7 ${String(role.request_count)} req \xB7 preamble ${format_tokens(role.preamble_tokens)}`;
-  return `  ${role.role.padEnd(ROLE_PAD2)} ${spent}  ${time}  ${counts}`;
-}
-function role_lines(report) {
-  return [
-    "",
-    "By role (cost-heaviest first):",
-    ...report.roles.map((role) => role_line2(role, report))
-  ];
-}
-function session_issue(issue) {
-  return issue === void 0 ? "\u2014" : session_cite.issue(issue);
-}
-function session_parent(parent_id) {
-  return parent_id === void 0 ? "" : ` \u2190 ${parent_id}`;
-}
-function session_line(row) {
-  const tag = `${row.role.padEnd(ROLE_PAD2)} d${String(row.depth)} ${session_issue(row.issue).padEnd(ISSUE_PAD)}`;
-  const identity = `  ${tag} ${row.session_id}`;
-  if (!row.is_measured) return `${identity}  ${NOT_MEASURED}${session_parent(row.parent_id)}`;
-  const usage = `${String(row.request_count)} req \xB7 output ${format_tokens(row.output_tokens)}`;
-  const spent = `${format_usd(row.cost_usd)} \xB7 ${format_minutes(row.elapsed_ms)} \xB7 ${usage} \xB7 preamble ${format_tokens(row.preamble_tokens)}`;
-  return `${identity}  ${spent}${session_parent(row.parent_id)}`;
-}
-function session_lines(report) {
-  return ["", "Sessions (cost-heaviest first):", ...report.sessions.map((row) => session_line(row))];
-}
-function format_report(report, lead = []) {
-  const split = report.split === void 0 ? [] : cost_run_split.format_lines(report.split);
-  const phases = cost_run_phase.format_lines(report.worker_phases);
-  const body = [
-    ...header_lines(report),
-    ...role_lines(report),
-    ...phases,
-    ...split,
-    ...session_lines(report)
-  ];
-  return (lead.length === 0 ? body : [...lead, "", ...body]).join("\n");
-}
-function print_report(report, is_json, lead) {
-  console.info(
-    is_json ? JSON.stringify(report, void 0, JSON_INDENT) : format_report(report, lead)
-  );
-}
-function report_empty(cwd) {
-  const searched = cost_transcript.searched_directories(cost_transcript.transcript_directories(cwd));
-  for (const line of cost_transcript.missing_message(searched, void 0)) console.error(line);
-  return FAILURE_EXIT_CODE;
-}
-function run(cwd, run_id, is_json, view = DEFAULT_VIEW) {
-  const tree = cost_run_tree.load(cwd, run_id);
-  if (tree === void 0) return report_empty(cwd);
-  const report = build6(tree.run_count, tree.unattributed_count, tree.nodes, view.split_at_ms);
-  print_report(report, is_json, view.lead);
-  return OK_EXIT_CODE;
-}
-var cost_run_report = { NOT_MEASURED, build: build6, format_report, run };
-
-export {
-  cost_run_nodes,
-  cost_run_tree,
-  cost_run_report
-};

package/dist/commands/chunk-VGPIQNDB.js

@@ -1,24 +0,0 @@
-import {
-  time_format
-} from "./chunk-5RG4S66L.js";
-
-// scripts/lint/lint-timing.ts
-var MARK = " timing \u2014 ";
-var SEPARATOR = " \xB7 ";
-function line(timing) {
-  const tools = [
-    `prettier ${time_format.format_seconds(timing.prettier_ms)}`,
-    `eslint ${time_format.format_seconds(timing.eslint_ms)}`
-  ];
-  return `${timing.label}${MARK}${[...tools, ...timing.facts].join(SEPARATOR)}
-`;
-}
-function detail_of(label, output) {
-  const prefix = `${label}${MARK}`;
-  return output.split("\n").find((text) => text.startsWith(prefix))?.slice(prefix.length);
-}
-var lint_timing = { detail_of, line };
-
-export {
-  lint_timing
-};

package/dist/commands/chunk-VJE3RJAX.js

@@ -1,23 +0,0 @@
-// scripts/git/git-execa-error.ts
-function get_exit_code(error) {
-  if (typeof error !== "object" || error === null || !("exitCode" in error)) return void 0;
-  const { exitCode: exit_code } = error;
-  return typeof exit_code === "number" ? exit_code : void 0;
-}
-function has_timed_out(error) {
-  if (typeof error !== "object" || error === null || !("timedOut" in error)) return false;
-  return error.timedOut === true;
-}
-var TIMEOUT_EXIT_CODE = "timeout";
-function create_spawn_error(command, exit_code) {
-  const exit_code_string = exit_code === void 0 ? "unknown" : String(exit_code);
-  const error_message = `git ${command} exited with code ${exit_code_string}`;
-  return new Error(error_message, { cause: { exit_code: exit_code_string } });
-}
-
-export {
-  get_exit_code,
-  has_timed_out,
-  TIMEOUT_EXIT_CODE,
-  create_spawn_error
-};