@codions/portta 0.1.0 → 0.2.0

package/dist/assets/workflows/multi-provider-review.workflow.js

@@ -1,169 +0,0 @@
-// Multi-provider review: the same change reviewed twice — once by Codex, once by Claude — each
-// over the ENTIRE feature/branch, then a synthesis pass merges both: consensus findings (both
-// providers saw it → highest confidence), unique catches, and disagreements called out.
-// Run with: portta flow run workflow multi-provider-review [--input-json '{"target": "<ref|path|diff>"}']
-//       or: portta flow workflows run multi-provider-review [--args '{"target": "<ref|path|diff>"}']
-
-export const meta = {
-  name: "multi-provider-review",
-  description:
-    "Dual-provider review — Codex and Claude each review the full feature/branch independently, then a synthesis merges both: consensus, unique catches, disagreements.",
-  defaultSandbox: "read-only",
-  workspace: {
-    default: "current_branch",
-    allowed: ["isolated_worktree", "new_branch", "current_branch"],
-    mutatesRepository: false,
-    reason: "Both reviewers inspect the active checkout read-only.",
-  },
-  phases: [
-    { title: "Review", detail: "Codex and Claude each review the entire change independently" },
-    { title: "Synthesize", detail: "merge both reviews: consensus, unique findings, ranked report" },
-  ],
-}
-
-const MAX_FINDINGS_PER_REVIEW = 15
-
-const REVIEWERS = [
-  { provider: "codex", model: "gpt-5.5", name: "Codex" },
-  { provider: "claude-code", model: "claude-fable-5", name: "Claude" },
-]
-
-const target =
-  typeof args === "string" && args.trim()
-    ? args.trim()
-    : args && typeof args === "object" && typeof args.target === "string" && args.target.trim()
-      ? args.target.trim()
-      : "the current branch in its entirety — every change relative to its merge-base with the " +
-        "repository's default branch (git merge-base, then git diff <base>...HEAD), plus any " +
-        "uncommitted changes; if already on the default branch, the most recent commit plus any " +
-        "uncommitted changes"
-
-const REVIEW_SCHEMA = {
-  type: "object",
-  required: ["assessment", "findings"],
-  properties: {
-    assessment: { type: "string" },
-    findings: {
-      type: "array",
-      items: {
-        type: "object",
-        required: ["file", "title", "why", "severity"],
-        properties: {
-          file: { type: "string" },
-          line: { type: "number" },
-          title: { type: "string" },
-          why: { type: "string" },
-          severity: { type: "string", enum: ["critical", "high", "medium", "low"] },
-        },
-      },
-    },
-  },
-}
-
-const SYNTHESIS_SCHEMA = {
-  type: "object",
-  required: ["report", "findings"],
-  properties: {
-    report: { type: "string" },
-    findings: {
-      type: "array",
-      items: {
-        type: "object",
-        required: ["file", "title", "why", "severity", "foundBy"],
-        properties: {
-          file: { type: "string" },
-          line: { type: "number" },
-          title: { type: "string" },
-          why: { type: "string" },
-          severity: { type: "string", enum: ["critical", "high", "medium", "low"] },
-          foundBy: { type: "array", items: { type: "string", enum: REVIEWERS.map((r) => r.name) } },
-        },
-      },
-    },
-  },
-}
-
-// ---------------------------------------------------------------------------
-// Review — both providers read the same full change, blind to each other.
-// The prompts are identical so differences in output reflect the models, not
-// the framing; neither is told another reviewer exists.
-// ---------------------------------------------------------------------------
-phase("Review")
-log(`dual-provider review of ${target}`)
-
-const reviewPrompt =
-  `You are conducting a complete, independent code review of ${target}. Review the WHOLE change, ` +
-  `not a slice of it: read the full diff and enough surrounding code to judge it in context. ` +
-  `Cover correctness, security, error handling, concurrency, resource handling, API contracts, ` +
-  `performance, and test coverage.\n\n` +
-  `Report up to ${MAX_FINDINGS_PER_REVIEW} concrete findings: file, line when you can pinpoint ` +
-  `it, a short title, why it is a real problem, and a severity (critical|high|medium|low). Only ` +
-  `report issues you can point to in the code — no speculation, no style nits. Also give an ` +
-  `overall assessment (2-4 sentences): the state of the change, its main risks, and whether it ` +
-  `looks ready to merge.`
-
-const reviews = (
-  await parallel(
-    REVIEWERS.map((r) => () =>
-      agent(reviewPrompt, {
-        provider: r.provider,
-        model: r.model,
-        label: `review: ${r.name}`,
-        phase: "Review",
-        schema: REVIEW_SCHEMA,
-      }).then((review) => ({
-        reviewer: r.name,
-        assessment: review.assessment,
-        findings: (review.findings || []).slice(0, MAX_FINDINGS_PER_REVIEW),
-      })),
-    ),
-  )
-).filter(Boolean)
-
-if (reviews.length === 0) throw new Error("both provider reviews failed — nothing to synthesize")
-if (reviews.length < REVIEWERS.length)
-  log(`warning: only ${reviews.map((r) => r.reviewer).join(", ")} completed — synthesis will lack cross-provider consensus`)
-for (const r of reviews) log(`${r.reviewer}: ${r.findings.length} findings`)
-
-// ---------------------------------------------------------------------------
-// Synthesize — one agent (run-default provider; override with --provider) sees
-// both labeled reviews and merges them into a single ranked picture.
-// ---------------------------------------------------------------------------
-phase("Synthesize")
-
-const synthesis = await agent(
-  `You are synthesizing ${reviews.length} independent full code reviews of ${target}, each from a ` +
-    `different model provider. Merge them into one picture:\n` +
-    `1. Match findings that describe the same underlying issue — even when worded differently or ` +
-    `pointing at slightly different lines — and merge them into one finding with foundBy listing ` +
-    `every reviewer that caught it. Consensus findings are the highest-confidence ones; rank them ` +
-    `first, then by severity.\n` +
-    `2. Keep findings only one reviewer caught, attributed via foundBy. Spot-check any that look ` +
-    `dubious against the actual code and drop clear false positives (say so in the report).\n` +
-    `3. Where the reviews DISAGREE — about the same code, or in their overall assessments — call ` +
-    `the disagreement out explicitly in the report rather than silently picking a side.\n\n` +
-    `The report should open with a 2-4 sentence overall verdict that synthesizes both assessments, ` +
-    `then note where the reviewers agreed and disagreed, then walk the merged findings in ranked ` +
-    `order (severity, foundBy, file:line, what is wrong, fix direction in a sentence).\n\n` +
-    `Reviews (JSON):\n${JSON.stringify(reviews, null, 2)}`,
-  { label: "synthesize", phase: "Synthesize", schema: SYNTHESIS_SCHEMA },
-)
-
-const SEVERITY_RANK = { critical: 0, high: 1, medium: 2, low: 3 }
-const findings = (synthesis.findings || [])
-  .slice()
-  .sort(
-    (a, b) =>
-      (b.foundBy || []).length - (a.foundBy || []).length ||
-      SEVERITY_RANK[a.severity] - SEVERITY_RANK[b.severity] ||
-      a.file.localeCompare(b.file),
-  )
-
-const consensus = findings.filter((f) => (f.foundBy || []).length > 1).length
-log(`${findings.length} merged findings (${consensus} consensus)`)
-
-return {
-  reviews: reviews.map((r) => ({ reviewer: r.reviewer, assessment: r.assessment, findingCount: r.findings.length })),
-  findings,
-  report: synthesis.report,
-}

package/dist/assets/workflows/provider-debate.workflow.js

@@ -1,141 +0,0 @@
-// Provider debate: one provider proposes a position, the other attacks it, the proposer rebuts
-// or concedes, for N rounds — then a judge rules on what actually survived. The cross-provider
-// attacker is the point: a model is measurably worse at finding holes in its own reasoning than
-// another model is.
-// Run with: portta flow run workflow provider-debate --input '<question>'
-//       or: portta flow workflows run provider-debate --args '"<question>"'
-//           (or --args '{"question": "...", "rounds": 2, "proposer": "codex" | "claude-code"}')
-
-export const meta = {
-  name: "provider-debate",
-  description:
-    "Adversarial debate — one provider proposes, the other attacks, N rounds of rebuttal, then a judge rules on what survived, what was conceded, and what to actually do.",
-  defaultSandbox: "read-only",
-  workspace: {
-    default: "current_branch",
-    allowed: ["isolated_worktree", "new_branch", "current_branch"],
-    mutatesRepository: false,
-    reason: "The debate is read-only and normally needs no Git isolation.",
-  },
-  phases: [
-    { title: "Propose", detail: "the proposer takes a concrete position" },
-    { title: "Debate", detail: "attack and rebuttal, one exchange per round" },
-    { title: "Verdict", detail: "a judge rules: survived, conceded, open, recommendation" },
-  ],
-}
-
-const PROVIDERS = {
-  codex: { provider: "codex", model: "gpt-5.5", name: "Codex" },
-  "claude-code": { provider: "claude-code", model: "claude-fable-5", name: "Claude" },
-}
-
-const question =
-  typeof args === "string" && args.trim()
-    ? args.trim()
-    : args && typeof args === "object" && typeof args.question === "string" && args.question.trim()
-      ? args.question.trim()
-      : null
-if (!question) {
-  throw new Error(`provider-debate needs a question — pass --args '"<question>"' or --args '{"question": "..."}'`)
-}
-
-const proposerId = args && typeof args === "object" && args.proposer !== undefined ? args.proposer : "codex"
-const proposer = PROVIDERS[proposerId]
-if (!proposer) throw new Error(`unknown proposer "${proposerId}" — expected "codex" or "claude-code"`)
-const attacker = proposer === PROVIDERS.codex ? PROVIDERS["claude-code"] : PROVIDERS.codex
-
-const rawRounds = args && typeof args === "object" && typeof args.rounds === "number" ? args.rounds : 2
-const rounds = Math.max(1, Math.min(5, Math.floor(rawRounds)))
-
-const VERDICT_SCHEMA = {
-  type: "object",
-  required: ["recommendation", "survived", "conceded", "open", "report"],
-  properties: {
-    recommendation: { type: "string" },
-    survived: { type: "array", items: { type: "string" } },
-    conceded: { type: "array", items: { type: "string" } },
-    open: { type: "array", items: { type: "string" } },
-    report: { type: "string" },
-  },
-}
-
-const transcriptText = (transcript) =>
-  transcript
-    .map((t) => `--- Round ${t.round} ---\nObjections:\n${t.critique}\n\nRebuttal:\n${t.rebuttal}`)
-    .join("\n\n")
-
-// ---------------------------------------------------------------------------
-// Propose — a concrete, attackable position.
-// ---------------------------------------------------------------------------
-phase("Propose")
-log(`debate: ${question} (${proposer.name} proposes, ${attacker.name} attacks, ${rounds} round${rounds === 1 ? "" : "s"})`)
-
-const proposal = await agent(
-  `Take a clear position on the following and propose a concrete answer or design:\n\n${question}\n\n` +
-    `If this concerns the repository you are in, read the relevant code first and ground your ` +
-    `position in it. Make your reasoning, assumptions, and tradeoffs explicit — this proposal will ` +
-    `be scrutinized line by line, so vagueness counts against it.`,
-  { provider: proposer.provider, model: proposer.model, label: `propose: ${proposer.name}`, phase: "Propose" },
-)
-
-// ---------------------------------------------------------------------------
-// Debate — each round is one attack/rebuttal exchange. The rebuttal ends with
-// the full current proposal, which becomes the target of the next attack.
-// ---------------------------------------------------------------------------
-phase("Debate")
-
-const transcript = []
-let current = proposal
-
-for (let round = 1; round <= rounds; round++) {
-  const history = transcript.length > 0 ? `\n\nDebate so far:\n${transcriptText(transcript)}` : ""
-
-  const critique = await agent(
-    `You are the adversarial examiner in round ${round} of ${rounds} of a structured debate.\n\n` +
-      `Question:\n${question}\n\n` +
-      `Current proposal:\n${current}${history}\n\n` +
-      `Attack the proposal with the strongest objections you can ground in evidence: flaws in ` +
-      `reasoning, missing considerations, risks, and concretely better alternatives. Where the ` +
-      `question concerns this repository, verify your objections against the actual code — a ` +
-      `refuted attack weakens your side. Do not be agreeable, and do not repeat objections that ` +
-      `earlier rebuttals already answered; move to stronger ground instead.`,
-    { provider: attacker.provider, model: attacker.model, label: `attack: round ${round}`, phase: "Debate" },
-  )
-
-  const rebuttal = await agent(
-    `You are the proposer in round ${round} of ${rounds} of a structured debate, defending your proposal.\n\n` +
-      `Question:\n${question}\n\n` +
-      `Your current proposal:\n${current}${history}\n\n` +
-      `New objections:\n${critique}\n\n` +
-      `Respond to each objection in turn: defend it with reasoning and evidence (check the code ` +
-      `where it applies), or concede it explicitly and revise. Conceding a weak point is better ` +
-      `than defending it badly. End with your full current proposal, revised where you conceded.`,
-    { provider: proposer.provider, model: proposer.model, label: `rebut: round ${round}`, phase: "Debate" },
-  )
-
-  transcript.push({ round, critique, rebuttal })
-  current = rebuttal
-}
-
-// ---------------------------------------------------------------------------
-// Verdict — the judge runs on the run-default provider (override with
-// --provider); it rules on the merits, not on who argued better.
-// ---------------------------------------------------------------------------
-phase("Verdict")
-
-const verdict = await agent(
-  `You are the judge of a structured debate. Rule on the merits of the arguments, not the rhetoric.\n\n` +
-    `Question:\n${question}\n\n` +
-    `Initial proposal:\n${proposal}\n\n` +
-    `Full debate:\n${transcriptText(transcript)}\n\n` +
-    `Where a decisive claim about this repository can be checked, check it yourself rather than ` +
-    `taking either side's word. Deliver:\n` +
-    `- recommendation: the position the asker should act on (it may differ from both sides),\n` +
-    `- survived: the claims that withstood attack,\n` +
-    `- conceded: the points the proposer gave up or clearly lost,\n` +
-    `- open: unresolved questions worth investigating before committing,\n` +
-    `- report: a concise walkthrough of how you weighed it.`,
-  { label: "verdict", phase: "Verdict", schema: VERDICT_SCHEMA },
-)
-
-return { question, proposer: proposer.name, attacker: attacker.name, proposal, transcript, verdict }

package/dist/assets/workflows/second-opinion.workflow.js

@@ -1,176 +0,0 @@
-// Second opinion: ask both providers cheaply; if they agree, merge and return — if they
-// disagree, escalate both to deep effort with the other's answer in hand, then adjudicate.
-// Disagreement-triggered escalation: consensus-grade confidence at roughly half the cost of
-// always running the full panel.
-// Run with: portta flow run workflow second-opinion --input '<question>'
-//       or: portta flow workflows run second-opinion --args '"<question>"'
-
-export const meta = {
-  name: "second-opinion",
-  description:
-    "Cheap consensus check — Codex and Claude answer at low effort; agreement returns a merged answer, disagreement escalates both to deep effort and adjudicates.",
-  defaultSandbox: "read-only",
-  workspace: {
-    default: "current_branch",
-    allowed: ["isolated_worktree", "new_branch", "current_branch"],
-    mutatesRepository: false,
-    reason: "The comparison is read-only and normally needs no Git isolation.",
-  },
-  phases: [
-    { title: "Ask", detail: "both providers answer independently at low effort" },
-    { title: "Compare", detail: "do the answers materially agree?" },
-    { title: "Escalate", detail: "deep reconsideration of the disagreements — only on a split" },
-    { title: "Answer", detail: "merge the consensus, or adjudicate the split" },
-  ],
-}
-
-const PROVIDERS = [
-  { provider: "codex", model: "gpt-5.5", name: "Codex" },
-  { provider: "claude-code", model: "claude-fable-5", name: "Claude" },
-]
-
-const question =
-  typeof args === "string" && args.trim()
-    ? args.trim()
-    : args && typeof args === "object" && typeof args.question === "string" && args.question.trim()
-      ? args.question.trim()
-      : null
-if (!question) {
-  throw new Error(`second-opinion needs a question — pass --args '"<question>"' or --args '{"question": "..."}'`)
-}
-
-const ANSWER_SCHEMA = {
-  type: "object",
-  required: ["answer", "keyPoints"],
-  properties: { answer: { type: "string" }, keyPoints: { type: "array", items: { type: "string" } } },
-}
-
-// ---------------------------------------------------------------------------
-// Ask — identical prompts, low effort, blind to each other.
-// ---------------------------------------------------------------------------
-phase("Ask")
-log(`asking both providers: ${question}`)
-
-const asked = (
-  await parallel(
-    PROVIDERS.map((p) => () =>
-      agent(
-        `Answer this question concretely and commit to a position:\n\n${question}\n\n` +
-          `If it concerns the repository you are in, ground your answer in the actual code. Give ` +
-          `your answer plus the key points it rests on.`,
-        { provider: p.provider, model: p.model, effort: "low", label: `ask: ${p.name}`, phase: "Ask", schema: ANSWER_SCHEMA },
-      ).then((a) => ({ name: p.name, provider: p.provider, model: p.model, answer: a.answer, keyPoints: a.keyPoints })),
-    ),
-  )
-).filter(Boolean)
-
-if (asked.length === 0) throw new Error("both providers failed to answer")
-if (asked.length === 1) {
-  log(`warning: only ${asked[0].name} answered — no second opinion to compare`)
-  return { answer: asked[0].answer, agreed: null, escalated: false, answers: asked }
-}
-
-// ---------------------------------------------------------------------------
-// Compare — agreement on substance, not wording. A failed comparator counts
-// as disagreement: escalating needlessly costs tokens, trusting a missing
-// comparison costs correctness.
-// ---------------------------------------------------------------------------
-phase("Compare")
-
-const cmp = await agent(
-  `Two independent answers to the same question:\n\nQuestion:\n${question}\n\n` +
-    `Answer 1 (${asked[0].name}):\n${asked[0].answer}\nKey points: ${asked[0].keyPoints.join("; ")}\n\n` +
-    `Answer 2 (${asked[1].name}):\n${asked[1].answer}\nKey points: ${asked[1].keyPoints.join("; ")}\n\n` +
-    `Do they reach the same substantive conclusion? Ignore wording, structure, and depth — flag ` +
-    `only material disagreements that would change what the asker does.`,
-  {
-    effort: "low",
-    label: "compare",
-    phase: "Compare",
-    schema: {
-      type: "object",
-      required: ["agree", "disagreements"],
-      properties: { agree: { type: "boolean" }, disagreements: { type: "array", items: { type: "string" } } },
-    },
-  },
-)
-
-const agree = cmp ? cmp.agree : false
-const disagreements = cmp ? cmp.disagreements : ["comparison agent failed — treating the answers as unverified"]
-
-if (agree) {
-  phase("Answer")
-  log("answers agree — merging")
-  const merged = await agent(
-    `Two independent analyses of this question reached the same conclusion. Merge them into one ` +
-      `answer — keep the strongest specifics of each, no filler.\n\nQuestion:\n${question}\n\n` +
-      `${asked.map((a) => `Answer (${a.name}):\n${a.answer}`).join("\n\n")}`,
-    { effort: "low", label: "merge", phase: "Answer" },
-  )
-  return { answer: merged, agreed: true, escalated: false, answers: asked }
-}
-
-// ---------------------------------------------------------------------------
-// Escalate — each provider reconsiders at deep effort with the other's answer
-// and the specific disagreements in hand.
-// ---------------------------------------------------------------------------
-phase("Escalate")
-log(`answers disagree — escalating: ${disagreements.join("; ")}`)
-
-const finals = (
-  await parallel(
-    asked.map((a, i) => () => {
-      const other = asked[1 - i]
-      return agent(
-        `You previously answered this question:\n\n${question}\n\nYour answer:\n${a.answer}\n\n` +
-          `An equally capable independent analysis disagreed. Its answer:\n${other.answer}\n\n` +
-          `The material disagreements:\n${disagreements.map((d) => `- ${d}`).join("\n")}\n\n` +
-          `Reconsider at full depth: verify the contested points yourself (read the code, check the ` +
-          `claims) rather than restating your position. Then either defend your answer with ` +
-          `evidence or change it. Changing your mind on the evidence is success, not failure. ` +
-          `State your final answer.`,
-        { provider: a.provider, model: a.model, effort: "xhigh", label: `reconsider: ${a.name}`, phase: "Escalate", schema: { type: "object", required: ["answer", "changed"], properties: { answer: { type: "string" }, changed: { type: "boolean" } } } },
-      ).then((f) => ({ name: a.name, answer: f.answer, changed: f.changed }))
-    }),
-  )
-).filter(Boolean)
-
-// ---------------------------------------------------------------------------
-// Answer — adjudicate what remains. Runs on the run-default provider
-// (override with --provider).
-// ---------------------------------------------------------------------------
-phase("Answer")
-
-const adj = await agent(
-  `You are the final adjudicator. Two analyses answered the same question, disagreed, and each ` +
-    `reconsidered at full depth with the other's answer in hand.\n\nQuestion:\n${question}\n\n` +
-    `Initial disagreements:\n${disagreements.map((d) => `- ${d}`).join("\n")}\n\n` +
-    `Final positions:\n${finals.map((f) => `${f.name}${f.changed ? " (revised)" : " (held)"}:\n${f.answer}`).join("\n\n")}\n\n` +
-    `Write the single answer the asker should act on. If the deep passes converged, merge them; if ` +
-    `not, decide on the merits — verify the decisive points yourself where feasible. Note anything ` +
-    `that remains genuinely unresolved.`,
-  {
-    effort: "xhigh",
-    label: "adjudicate",
-    phase: "Answer",
-    schema: {
-      type: "object",
-      required: ["answer", "resolution", "unresolved"],
-      properties: {
-        answer: { type: "string" },
-        resolution: { type: "string", enum: ["consensus", "adjudicated"] },
-        unresolved: { type: "array", items: { type: "string" } },
-      },
-    },
-  },
-)
-
-return {
-  answer: adj.answer,
-  agreed: false,
-  escalated: true,
-  resolution: adj.resolution,
-  unresolved: adj.unresolved,
-  disagreements,
-  positions: finals,
-}

package/dist/chunk-3EZNE4MC.js

@@ -1,6 +0,0 @@
-#!/usr/bin/env node
-import { createRequire as __createRequire } from "node:module"; const require = __createRequire(import.meta.url);
-import{q as a,t as m,v as d}from"./chunk-OPVZAG2C.js";import{a as c}from"./chunk-4TGTGGMK.js";import{c as u}from"./chunk-UX7P3YHF.js";import{a as i}from"./chunk-T3TSZO4I.js";import{a as o}from"./chunk-6J5HN4ZN.js";import{realpathSync as v}from"node:fs";import{dirname as P,resolve as g}from"node:path";var s=class extends Error{static{o(this,"CommandUsageError")}};function B(t){if(!t||t.length===0)return;let e={};for(let r of t){let n=r.indexOf("=");if(n<=0)throw new s("--env must use KEY=VALUE");e[r.slice(0,n)]=r.slice(n+1)}return e}o(B,"parseEnvOverrides");function x(t,e){return t instanceof Error?t.message.startsWith("HTTP")?t.message:t.message.includes("fetch")||t.message.includes("Unable to connect")?d(e):t.message:String(t)}o(x,"formatServerError");async function H(t,e){try{return await e()}catch(r){
-throw new Error(x(r,t))}}o(H,"withServerConnection");function y(t=process.cwd()){try{let e=c("git",["rev-parse","--git-common-dir"],{cwd:t});if(e.success){let n=e.stdout.toString().trim();if(n)return P(g(t,n))}let r=c("git",["rev-parse","--show-toplevel"],{cwd:t});return r.success?r.stdout.toString().trim():null}catch{return null}}o(y,"resolveProjectRoot");function p(t){try{return v(t)}catch{return g(t)}}o(p,"canonicalizePath");async function b(t,e=process.cwd()){let r=a(t),n=y(e);if(!n)throw new s(
-`Not inside a git repository, so ${i} can't tell which project this command targets. cd into a project served by ${i} (\`${u()} project ls\` lists them) and try again.`);let{projects:l}=await m(r).fetchProjects(),h=p(n),f=l.find(w=>p(w.path)===h);if(!f)throw new s(`This project (${n}) isn't served by ${i} on port ${t}. Run \`${u()} project add\` in it first.`);return`${r}/${f.prefix}`}o(b,"resolveProjectBaseUrl");async function I(t,e=process.cwd()){try{return(await b(t,e)).slice(a(t).length).replace(
-/^\/+|\/+$/g,"")||void 0}catch{return}}o(I,"resolveProjectPrefix");export{s as a,B as b,x as c,H as d,b as e,I as f};

package/dist/chunk-4TGTGGMK.js

@@ -1,4 +0,0 @@
-#!/usr/bin/env node
-import { createRequire as __createRequire } from "node:module"; const require = __createRequire(import.meta.url);
-import{c as s}from"./chunk-EH7H7D7J.js";import{a as r}from"./chunk-6J5HN4ZN.js";import{spawnSync as i}from"node:child_process";import{existsSync as c,readFileSync as l}from"node:fs";import{basename as f,join as a}from"node:path";function p(t,e,n){let u=s(t)??t,o=i(u,e,{...n,encoding:"buffer",stdio:["ignore","pipe","pipe"]});return{success:o.status===0&&!o.error,stdout:o.stdout??Buffer.alloc(0),stderr:o.stderr??Buffer.alloc(0)}}r(p,"run");function g(t){return s(t)}r(g,"resolveExecutablePath");function b(t){return g(t)!==null}r(b,"which");function v(){let t=p("git",["rev-parse","--show-toplevel"]);return t.success?t.stdout.toString().trim():null}r(v,"getGitRoot");function S(t){let e=a(t,"package.json");if(c(e))try{let n=JSON.
-parse(l(e,"utf-8"));if(n.name)return n.name}catch{}return f(t)}r(S,"detectProjectName");export{p as a,g as b,b as c,v as d,S as e};