@poetic-ai/poetic 1.42.0

package/dist/chunk-MF5HP6XV.js

@@ -0,0 +1,221 @@
+// src/cli/commands/package.ts
+import fs from "fs/promises";
+import os from "os";
+import path from "path";
+import { fileURLToPath } from "url";
+import { Command } from "commander";
+var REQUIRED_RUNTIME_PATHS = [
+  "dist",
+  "templates",
+  "package.json",
+  "package-lock.json",
+  "schemas",
+  ".poetic/providers",
+  ".poetic/providers/catalog.json",
+  "scripts/preinstall-node-check.mjs",
+  "scripts/assert-node-runtime.mjs",
+  "scripts/preflight-native.mjs",
+  "scripts/write-node-launcher.sh",
+  "scripts/setup-git-hooks.mjs",
+  "scripts/sync.sh",
+  "src/resources",
+  ".nvmrc"
+];
+var OPTIONAL_RUNTIME_PATHS = [
+  "README.md",
+  "INSTALL.md",
+  "LICENSE",
+  "CHANGELOG.md",
+  "CONTRIBUTING.md",
+  "CODE_OF_CONDUCT.md",
+  // Optional BB visual experience package used by `poetic provider setup --bb`.
+  "integrations/bb-plugin-poetic"
+];
+async function pathExists(targetPath) {
+  try {
+    await fs.access(targetPath);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function isSameOrAncestorPath(candidateAncestor, targetPath) {
+  const relative = path.relative(candidateAncestor, targetPath);
+  return relative === "" || !relative.startsWith("..") && !path.isAbsolute(relative);
+}
+function isBroadOutputPath(outputRoot) {
+  const parsed = path.parse(outputRoot);
+  if (outputRoot === parsed.root) return true;
+  const home = os.homedir();
+  return Boolean(home) && outputRoot === path.resolve(home);
+}
+async function isExistingLocalDistPackage(outputRoot) {
+  const manifest = await readJsonFile(
+    path.join(outputRoot, "poetic-package.json")
+  );
+  const isPoeticBundle = manifest?.name === "@poetic-ai/poetic" || manifest?.name === "@poetic/cli";
+  return isPoeticBundle && manifest?.env?.POETIC_PACKAGE_ROOT === outputRoot;
+}
+async function validateOutputRootForWrite(input) {
+  const { outputRoot, sourceRoot, force } = input;
+  if (isBroadOutputPath(outputRoot)) {
+    throw new Error(`Refusing to use broad package output path: ${outputRoot}`);
+  }
+  if (isSameOrAncestorPath(outputRoot, sourceRoot)) {
+    throw new Error(
+      `Refusing to use package output path that is the Poetic source root or one of its ancestors: ${outputRoot}`
+    );
+  }
+  if (force && await pathExists(outputRoot) && !await isExistingLocalDistPackage(outputRoot)) {
+    throw new Error(
+      `Refusing to replace non-Poetic local-dist directory: ${outputRoot}. Choose an empty/new output path or remove it manually after inspection.`
+    );
+  }
+}
+async function readJsonFile(targetPath) {
+  try {
+    return JSON.parse(await fs.readFile(targetPath, "utf8"));
+  } catch {
+    return null;
+  }
+}
+async function findPackageRoot(startFile) {
+  let current = path.dirname(startFile);
+  while (true) {
+    const packageJsonPath = path.join(current, "package.json");
+    const packageJson = await readJsonFile(packageJsonPath);
+    if (packageJson?.name === "@poetic-ai/poetic") {
+      return current;
+    }
+    const parent = path.dirname(current);
+    if (parent === current) {
+      throw new Error("Unable to resolve Poetic package root");
+    }
+    current = parent;
+  }
+}
+async function copyRequiredPath(sourceRoot, outputRoot, relativePath) {
+  const source = path.join(sourceRoot, relativePath);
+  const destination = path.join(outputRoot, relativePath);
+  if (!await pathExists(source)) {
+    throw new Error(`Required runtime path is missing: ${relativePath}`);
+  }
+  await fs.mkdir(path.dirname(destination), { recursive: true });
+  await fs.cp(source, destination, {
+    recursive: true,
+    force: true,
+    errorOnExist: false,
+    preserveTimestamps: true,
+    verbatimSymlinks: true
+  });
+}
+async function copyOptionalPath(sourceRoot, outputRoot, relativePath) {
+  const source = path.join(sourceRoot, relativePath);
+  if (!await pathExists(source)) return;
+  await copyRequiredPath(sourceRoot, outputRoot, relativePath);
+}
+function formatTextReport(manifest) {
+  const dependencyLine = manifest.dependencyMode.type === "copied-node-modules" ? `Dependencies: copied to ${manifest.dependencyMode.path}` : `Dependencies: install with \`${manifest.dependencyMode.command}\``;
+  return [
+    `Package root: ${manifest.packageRoot}`,
+    `Entry: ${manifest.entry}`,
+    `Set: POETIC_PACKAGE_ROOT=${manifest.packageRoot}`,
+    dependencyLine,
+    `Manifest: ${path.join(manifest.packageRoot, "poetic-package.json")}`
+  ].join("\n");
+}
+async function createLocalDistPackage(options, deps = {}) {
+  const outputRoot = path.resolve(options.output);
+  const moduleUrl = deps.moduleUrl ?? import.meta.url;
+  const sourceRoot = await findPackageRoot(fileURLToPath(moduleUrl));
+  await validateOutputRootForWrite({
+    outputRoot,
+    sourceRoot,
+    force: options.force
+  });
+  if (await pathExists(outputRoot) && !options.force) {
+    throw new Error(`Output already exists: ${outputRoot}. Re-run with --force to replace it.`);
+  }
+  if (options.force) {
+    await fs.rm(outputRoot, { recursive: true, force: true });
+  }
+  await fs.mkdir(outputRoot, { recursive: true });
+  for (const relativePath of REQUIRED_RUNTIME_PATHS) {
+    await copyRequiredPath(sourceRoot, outputRoot, relativePath);
+  }
+  for (const relativePath of OPTIONAL_RUNTIME_PATHS) {
+    await copyOptionalPath(sourceRoot, outputRoot, relativePath);
+  }
+  const packageJson = await readJsonFile(path.join(sourceRoot, "package.json")) ?? {};
+  const buildMeta = await readJsonFile(
+    path.join(sourceRoot, "dist/.poetic-build-meta.json")
+  );
+  const shouldCopyNodeModules = options.copyNodeModules !== false;
+  const sourceNodeModules = path.join(sourceRoot, "node_modules");
+  const outputNodeModules = path.join(outputRoot, "node_modules");
+  let dependencyMode;
+  if (shouldCopyNodeModules && await pathExists(sourceNodeModules)) {
+    await fs.cp(sourceNodeModules, outputNodeModules, {
+      recursive: true,
+      force: true,
+      errorOnExist: false,
+      preserveTimestamps: true,
+      verbatimSymlinks: true
+    });
+    dependencyMode = { type: "copied-node-modules", path: outputNodeModules };
+  } else {
+    dependencyMode = {
+      type: "install-required",
+      command: "npm install --omit=dev"
+    };
+  }
+  const manifest = {
+    name: packageJson.name ?? "@poetic-ai/poetic",
+    version: packageJson.version ?? "unknown",
+    packageRoot: outputRoot,
+    entry: path.join(outputRoot, "dist/entry.js"),
+    createdAt: (deps.now ?? (() => /* @__PURE__ */ new Date()))().toISOString(),
+    sourcePackageRoot: sourceRoot,
+    sourceGitHead: buildMeta?.gitHead ?? null,
+    dependencyMode,
+    env: {
+      POETIC_PACKAGE_ROOT: outputRoot
+    }
+  };
+  await fs.writeFile(
+    path.join(outputRoot, "poetic-package.json"),
+    `${JSON.stringify(manifest, null, 2)}
+`,
+    "utf8"
+  );
+  await fs.writeFile(
+    path.join(outputRoot, "POETIC_PACKAGE_ROOT.env"),
+    `POETIC_PACKAGE_ROOT=${outputRoot}
+`,
+    "utf8"
+  );
+  return manifest;
+}
+function createPackageCommand() {
+  const command = new Command("package").description("Create local Poetic runtime packages");
+  command.command("local-dist").description("Create a frozen runnable local dist bundle for dogfood and release checks").requiredOption("--output <dir>", "Output directory for the local dist bundle").option("--force", "Replace output directory if it already exists").option("--json", "Print package metadata as JSON").option(
+    "--no-copy-node-modules",
+    "Do not copy node_modules; write install instructions instead"
+  ).action(async (options) => {
+    const manifest = await createLocalDistPackage(options);
+    if (options.json) {
+      process.stdout.write(`${JSON.stringify(manifest, null, 2)}
+`);
+    } else {
+      process.stdout.write(`${formatTextReport(manifest)}
+`);
+    }
+  });
+  return command;
+}
+
+export {
+  createLocalDistPackage,
+  createPackageCommand
+};
+//# sourceMappingURL=chunk-MF5HP6XV.js.map

package/dist/chunk-MHLCBZJB.js

@@ -0,0 +1,328 @@
+import {
+  readCostMetricsUnavailableReason
+} from "./chunk-XUXVDPSZ.js";
+import {
+  isTelemetryPersistenceEnabled
+} from "./chunk-H6G7QRMQ.js";
+import {
+  formatVariantIdentifierFromResult
+} from "./chunk-CP7H3HSP.js";
+import {
+  TelemetryPathResolver
+} from "./chunk-ZDTGECTN.js";
+import {
+  redactPersistedTelemetryString
+} from "./chunk-6Y5U7UFY.js";
+
+// src/telemetry/execution-data-writer.ts
+import { execFileSync } from "child_process";
+import { createHash, randomUUID } from "crypto";
+import path from "path";
+function resolvePersistedVariantCostUsd(costMetrics) {
+  if (!costMetrics) return void 0;
+  if (readCostMetricsUnavailableReason(costMetrics)) return void 0;
+  const total = costMetrics.totalCost;
+  if (typeof total !== "number" || !Number.isFinite(total)) return void 0;
+  return total;
+}
+function resolveLocalBuilderId(repoRoot) {
+  try {
+    const email = execFileSync("git", ["config", "user.email"], {
+      encoding: "utf-8",
+      cwd: repoRoot,
+      timeout: 2e3
+    }).trim();
+    if (email) {
+      const salt = `poetic-builder-v1:${path.resolve(repoRoot)}`;
+      return `local-${createHash("sha256").update(salt + email).digest("hex").slice(0, 16)}`;
+    }
+  } catch {
+  }
+  return "local-unknown";
+}
+function resolveProjectId(poeticDir) {
+  return TelemetryPathResolver.getInstance().getProjectId(poeticDir, { register: false });
+}
+var BASIC_COMPETE_SCAFFOLD_SCHEMA_VERSION = "basic-compete-v1";
+var BASIC_COMPETE_PROMPT_ASSEMBLY_VERSION = "basic-compete-v1";
+var BASIC_COMPETE_VERIFICATION_PROFILE = "basic-compete-deterministic";
+var BASIC_COMPETE_VERIFICATION_PROFILE_VERSION = "v1";
+function resolveVariantReasoningEffortTelemetry(variant) {
+  if (!variant.requestedReasoningEffort) {
+    return { reasoning_effort_outcome: "not_requested" };
+  }
+  return {
+    requested_reasoning_effort: variant.requestedReasoningEffort,
+    effective_reasoning_effort: variant.effectiveReasoningEffort,
+    reasoning_effort_outcome: variant.reasoningEffortOutcome
+  };
+}
+function resolveVariantModelTelemetry(variant) {
+  const requested = variant.modelInput?.trim() || void 0;
+  const effective = variant.resolvedModel?.trim() || variant.model?.trim() || void 0;
+  if (!requested) {
+    return effective ? { effective_model: effective, model_resolution_outcome: "default_resolved" } : { model_resolution_outcome: "default_unrecorded" };
+  }
+  if (!effective) {
+    return {
+      requested_model: requested,
+      effective_model: requested,
+      model_resolution_outcome: "requested_unconfirmed"
+    };
+  }
+  return {
+    requested_model: requested,
+    effective_model: effective,
+    // A difference means an alias or normalization rewrote the user's token; it
+    // does not identify which, so the label does not claim "alias".
+    model_resolution_outcome: effective === requested ? "explicit" : "resolved_from_input"
+  };
+}
+function buildTreatmentBundleId(variant, specHarnessEnabled) {
+  const scaffoldFields = {
+    provider: variant.provider,
+    model: variant.resolvedModel ?? variant.model ?? "default",
+    strategy: variant.strategy,
+    executionMode: variant.executionMode ?? "local",
+    requestedWorkspaceMode: variant.workspaceModeRequested ?? variant.workspaceMode ?? null,
+    effectiveWorkspaceMode: variant.workspaceMode ?? null,
+    observedWorkspaceMode: variant.workspaceMode ?? null,
+    specHarness: specHarnessEnabled ? "v1" : "none"
+  };
+  return createHash("sha256").update(JSON.stringify(scaffoldFields)).digest("hex").slice(0, 16);
+}
+function buildJudgeRegimeId(judgeType, options) {
+  const rubricVersion = options?.rubricVersion ?? "v1";
+  return `${judgeType}:${rubricVersion}`;
+}
+function writeVerificationRunForVariant(store, stageRunId, variantExecutionId, variant) {
+  const verification = variant.verification;
+  if (!verification) return;
+  const findings = Array.isArray(verification.findings) ? verification.findings : [];
+  const byKind = (kind) => findings.filter((finding) => finding.kind === kind);
+  const buildFindings = byKind("build");
+  const lintFindings = byKind("lint");
+  const testFindings = byKind("test");
+  const verificationIncompleteWithoutFailure = verification.passed === false && findings.length === 0 && variant.verificationLoop?.enabled === true && variant.verificationLoop.passedBaseline === true;
+  const verificationRunId = randomUUID();
+  store.insertVerificationRun({
+    verification_run_id: verificationRunId,
+    stage_run_id: stageRunId,
+    variant_execution_id: variantExecutionId,
+    verification_profile: BASIC_COMPETE_VERIFICATION_PROFILE,
+    verification_profile_version: BASIC_COMPETE_VERIFICATION_PROFILE_VERSION,
+    scope: "smoke",
+    build_pass: buildFindings.length > 0 ? buildFindings.every((finding) => finding.exitCode === 0) ? 1 : 0 : void 0,
+    test_pass: testFindings.length > 0 ? testFindings.every((finding) => finding.exitCode === 0) ? 1 : 0 : void 0,
+    lint_errors: lintFindings.reduce(
+      (count, finding) => count + (finding.exitCode === 0 ? 0 : 1),
+      0
+    ),
+    empty_edits: variant.emptyChanges ? 1 : 0,
+    timeout_crashes: variant.timedOut ? 1 : 0,
+    skipped_reasons: verification.passed ? void 0 : verificationIncompleteWithoutFailure ? "verification_incomplete" : findings[0]?.command || "verification_failed"
+  });
+  for (const finding of findings) {
+    store.insertVerificationCommand({
+      verification_command_id: randomUUID(),
+      verification_run_id: verificationRunId,
+      command: redactPersistedTelemetryString(finding.command),
+      exit_code: finding.exitCode,
+      output_tail: redactPersistedTelemetryString(finding.outputTail ?? ""),
+      scope: finding.kind
+    });
+  }
+}
+function writeCompetitionStart(store, taskId, projectId, builderId) {
+  const competitionId = taskId;
+  const stageRunId = `${taskId}-stage-0`;
+  const startedAt = (/* @__PURE__ */ new Date()).toISOString();
+  store.transaction(() => {
+    store.insertCompetitionRun({
+      competition_id: competitionId,
+      task_id: taskId,
+      builder_id: builderId,
+      project_id: projectId,
+      started_at: startedAt,
+      status: "running",
+      data_quality_tier: 2
+      // local-hash identity
+    });
+    store.insertStageRun({
+      stage_run_id: stageRunId,
+      competition_id: competitionId,
+      stage_type: "competition",
+      stage_order: 0,
+      status: "running",
+      started_at: startedAt
+    });
+  });
+  return { competitionId, stageRunId, startedAt };
+}
+function writeVariantExecutionsV2(store, competitionId, stageRunId, variants, options) {
+  if (!isTelemetryPersistenceEnabled()) {
+    return /* @__PURE__ */ new Map();
+  }
+  const executionIdByVariant = /* @__PURE__ */ new Map();
+  const specHarnessEnabled = options?.specHarnessEnabled === true;
+  const linkageTaskId = options?.taskId ?? competitionId;
+  const variantFailures = [];
+  for (const variant of variants) {
+    const variantExecutionId = randomUUID();
+    const treatmentBundleId = buildTreatmentBundleId(variant, specHarnessEnabled);
+    try {
+      store.transaction(() => {
+        store.insertVariantExecution({
+          variant_execution_id: variantExecutionId,
+          stage_run_id: stageRunId,
+          competition_id: competitionId,
+          task_id: linkageTaskId,
+          variant_key: formatVariantIdentifierFromResult(variant),
+          provider: variant.provider,
+          model: variant.resolvedModel ?? variant.model,
+          ...resolveVariantModelTelemetry(variant),
+          strategy: variant.strategy,
+          task_type: variant.taskType,
+          complexity_score: options?.complexityScore,
+          complexity_band: options?.complexityBand,
+          routing_mode: options?.routingMode,
+          task_intent: options?.taskIntent,
+          capability_tier: options?.capabilityTier,
+          routing_confidence: options?.routingConfidence,
+          ambiguous: options?.ambiguous ? 1 : 0,
+          steering_hash: variant.steering?.hash,
+          steering_sources_json: variant.steering ? JSON.stringify({
+            version: variant.steering.version,
+            applied: variant.steering.applied
+          }) : void 0,
+          steering_bytes_system: variant.steering?.bytesByChannel.system,
+          steering_bytes_preamble: variant.steering?.bytesByChannel.preamble,
+          steering_bytes_policy: variant.steering?.bytesByChannel.policy,
+          requested_workspace_mode: variant.workspaceModeRequested ?? variant.workspaceMode,
+          effective_workspace_mode: variant.workspaceMode,
+          observed_workspace_mode: variant.workspaceMode,
+          requested_spec_harness: specHarnessEnabled ? "v1" : "none",
+          effective_spec_harness: specHarnessEnabled ? "v1" : "none",
+          observed_spec_harness: specHarnessEnabled ? "v1" : "none",
+          ...resolveVariantReasoningEffortTelemetry(variant),
+          treatment_bundle_id: treatmentBundleId,
+          scaffold_schema_version: BASIC_COMPETE_SCAFFOLD_SCHEMA_VERSION,
+          prompt_assembly_version: BASIC_COMPETE_PROMPT_ASSEMBLY_VERSION,
+          prompt_fingerprint: variant.promptFingerprint,
+          // Metrics
+          prompt_tokens: variant.costMetrics?.inputTokens,
+          output_tokens: variant.costMetrics?.outputTokens,
+          duration_ms: variant.executionDurationMs ?? (variant.duration != null ? Math.round(variant.duration * 1e3) : void 0),
+          // Known zero requires available pricing; unavailable structural 0 → null.
+          cost_usd: resolvePersistedVariantCostUsd(variant.costMetrics),
+          data_quality_tier: 2,
+          identity_confidence: "local-hash"
+        });
+        const statusLines = variant.worktreeSummary?.statusLines ?? [];
+        const touches = [];
+        for (const line of statusLines) {
+          const touch = parseGitStatusLine(line, variantExecutionId);
+          if (touch) touches.push(touch);
+        }
+        if (touches.length > 0) {
+          store.insertFileTouches(touches);
+        }
+        writeVerificationRunForVariant(store, stageRunId, variantExecutionId, variant);
+      });
+      executionIdByVariant.set(variant, variantExecutionId);
+    } catch (e) {
+      variantFailures.push(
+        `${variant.provider}:${variant.strategy}: ${e instanceof Error ? e.message : String(e)}`
+      );
+    }
+  }
+  if (variantFailures.length > 0) {
+    throw new VariantExecutionWriteError(executionIdByVariant, variantFailures);
+  }
+  return executionIdByVariant;
+}
+var VariantExecutionWriteError = class extends Error {
+  constructor(persistedExecutionIds, failures) {
+    super(
+      `Failed to persist ${failures.length} variant execution(s): ${redactPersistedTelemetryString(failures.join("; "))}`
+    );
+    this.persistedExecutionIds = persistedExecutionIds;
+    this.name = "VariantExecutionWriteError";
+  }
+  persistedExecutionIds;
+};
+function updateCompetitionV2(store, competitionId, stageRunId, competitionStatus, completedAt) {
+  const stageStatus = competitionStatus === "completed" ? "completed" : "failed";
+  store.updateCompetitionRun(competitionId, {
+    status: competitionStatus,
+    completed_at: completedAt
+  });
+  store.updateStageRun(stageRunId, { status: stageStatus, completed_at: completedAt });
+}
+function writeJudgeRunV2(store, stageRunId, winner, variants, executionIdByVariant, judgeType, options) {
+  const judgeRunId = randomUUID();
+  const rubricVersion = options?.rubricVersion ?? "v1";
+  const winnerExecutionId = winner ? executionIdByVariant.get(winner) : void 0;
+  store.transaction(() => {
+    store.insertJudgeRun({
+      judge_run_id: judgeRunId,
+      stage_run_id: stageRunId,
+      judge_type: judgeType,
+      judge_model: options?.judgeModel,
+      rubric_version: rubricVersion,
+      judge_regime_id: buildJudgeRegimeId(judgeType, {
+        rubricVersion
+      }),
+      judge_feature_flags: void 0,
+      winner_variant_execution_id: winnerExecutionId
+    });
+    for (const variant of variants) {
+      if (variant.judgeScore == null) continue;
+      const executionId = executionIdByVariant.get(variant);
+      if (!executionId) continue;
+      store.insertJudgeVariantScore({
+        judge_variant_score_id: randomUUID(),
+        judge_run_id: judgeRunId,
+        variant_execution_id: executionId,
+        score: variant.judgeScore
+      });
+    }
+  });
+}
+function parseGitStatusLine(line, variantExecutionId) {
+  const trimmed = line.trim();
+  if (!trimmed) return null;
+  const match = trimmed.match(/^([MADRCU?! ]{1,2})\s+(.+)$/);
+  if (!match) return null;
+  const status = (match[1] ?? "").trim();
+  let filePath = (match[2] ?? "").trim();
+  let fromPath;
+  if (status.startsWith("R")) {
+    const arrowIdx = filePath.indexOf(" -> ");
+    if (arrowIdx !== -1) {
+      fromPath = filePath.slice(0, arrowIdx).trim();
+      filePath = filePath.slice(arrowIdx + 4).trim();
+    }
+  }
+  const op = status === "D" ? "delete" : status.startsWith("R") ? "rename" : "write";
+  const dirPath = path.dirname(filePath);
+  return {
+    variant_execution_id: variantExecutionId,
+    path: filePath,
+    dir_path: dirPath === "." ? "" : dirPath,
+    path_depth: filePath.split("/").length - 1,
+    op,
+    from_path: fromPath
+  };
+}
+
+export {
+  resolveLocalBuilderId,
+  resolveProjectId,
+  writeCompetitionStart,
+  writeVariantExecutionsV2,
+  VariantExecutionWriteError,
+  updateCompetitionV2,
+  writeJudgeRunV2
+};
+//# sourceMappingURL=chunk-MHLCBZJB.js.map

package/dist/chunk-MN6PL4AN.js

@@ -0,0 +1,120 @@
+// src/core/git/parse-git-status.ts
+function parseGitStatus(output) {
+  return output.split("\n").filter((line) => line.trim().length > 0).map((line) => {
+    const indexStatus = line[0] ?? " ";
+    const worktreeStatus = line[1] ?? " ";
+    const pathPart = line.length > 3 ? line.slice(3) : "";
+    const { path, originalPath } = parsePathPart(pathPart);
+    return {
+      indexStatus,
+      worktreeStatus,
+      path,
+      originalPath,
+      raw: line
+    };
+  }).filter((entry) => entry.path.length > 0);
+}
+function parseGitStatusPaths(output, options = {}) {
+  const paths = /* @__PURE__ */ new Set();
+  for (const entry of parseGitStatus(output)) {
+    paths.add(entry.path);
+    if (options.includeOriginalPaths && entry.originalPath) {
+      paths.add(entry.originalPath);
+    }
+  }
+  return Array.from(paths);
+}
+function parsePathPart(pathPart) {
+  const trimmed = pathPart.trim();
+  if (!trimmed) {
+    return { path: "" };
+  }
+  const renameParts = splitRenamePath(trimmed);
+  if (renameParts) {
+    const originalPath = decodePorcelainPath(renameParts.originalPath);
+    const newPath = decodePorcelainPath(renameParts.newPath);
+    return { path: newPath, originalPath };
+  }
+  return { path: decodePorcelainPath(trimmed) };
+}
+function splitRenamePath(input) {
+  let inQuotes = false;
+  let escaped = false;
+  for (let index = 0; index < input.length; index++) {
+    const char = input[index];
+    if (escaped) {
+      escaped = false;
+      continue;
+    }
+    if (char === "\\") {
+      escaped = true;
+      continue;
+    }
+    if (char === '"') {
+      inQuotes = !inQuotes;
+      continue;
+    }
+    if (!inQuotes && input.startsWith(" -> ", index)) {
+      return {
+        originalPath: input.slice(0, index),
+        newPath: input.slice(index + 4)
+      };
+    }
+  }
+  return null;
+}
+function decodePorcelainPath(input) {
+  const trimmed = input.trim();
+  if (!(trimmed.startsWith('"') && trimmed.endsWith('"'))) {
+    return trimmed;
+  }
+  const body = trimmed.slice(1, -1);
+  const bytes = [];
+  for (let index = 0; index < body.length; index++) {
+    const char = body.charAt(index);
+    if (char !== "\\") {
+      bytes.push(char.codePointAt(0) ?? 0);
+      continue;
+    }
+    const next = body[index + 1];
+    if (!next) {
+      bytes.push("\\".codePointAt(0) ?? 92);
+      continue;
+    }
+    if (/[0-7]/.test(next)) {
+      const octal = body.slice(index + 1, index + 4);
+      const match = octal.match(/^[0-7]{1,3}/);
+      if (match) {
+        bytes.push(Number.parseInt(match[0], 8));
+        index += match[0].length;
+        continue;
+      }
+    }
+    index += 1;
+    switch (next) {
+      case '"':
+      case "\\":
+        bytes.push(next.codePointAt(0) ?? 0);
+        break;
+      case "t":
+        bytes.push(9);
+        break;
+      case "n":
+        bytes.push(10);
+        break;
+      case "r":
+        bytes.push(13);
+        break;
+      default:
+        bytes.push(next.codePointAt(0) ?? 0);
+        break;
+    }
+  }
+  return Buffer.from(bytes).toString("utf8");
+}
+
+export {
+  parseGitStatus,
+  parseGitStatusPaths
+};
+//# sourceMappingURL=chunk-MN6PL4AN.js.map