@poetic-ai/poetic 1.42.1-bootstrap.0

package/dist/chunk-VVGEPBPS.js

@@ -0,0 +1,218 @@
+// src/core/judge/json-output-parser.ts
+function extractBalancedJson(text) {
+  return extractBalancedJsonObjects(text)[0] ?? null;
+}
+function extractBalancedJsonObjects(text) {
+  const objects = [];
+  let start = -1;
+  let depth = 0;
+  let inString = false;
+  let escaping = false;
+  for (let i = 0; i < text.length; i++) {
+    const ch = text[i];
+    if (ch === void 0) continue;
+    if (inString) {
+      if (escaping) {
+        escaping = false;
+      } else if (ch === "\\") {
+        escaping = true;
+      } else if (ch === '"') {
+        inString = false;
+      }
+      continue;
+    }
+    if (ch === '"') {
+      inString = true;
+      continue;
+    }
+    if (ch === "{") {
+      if (depth === 0) {
+        start = i;
+      }
+      depth++;
+      continue;
+    }
+    if (ch === "}") {
+      if (depth === 0) continue;
+      depth--;
+      if (depth === 0 && start >= 0) {
+        objects.push(text.slice(start, i + 1));
+        start = -1;
+      }
+    }
+  }
+  return objects;
+}
+function stripMarkdownCodeFences(text) {
+  return text.replace(/^\s*```[^\n]*$/gm, "");
+}
+function collectJsonCandidates(text) {
+  const candidates = [];
+  const seen = /* @__PURE__ */ new Set();
+  const push = (candidate) => {
+    const trimmed = candidate?.trim();
+    if (!trimmed || seen.has(trimmed)) {
+      return;
+    }
+    seen.add(trimmed);
+    candidates.push(trimmed);
+  };
+  push(text);
+  for (const match of text.matchAll(/```(?:json)?\s*\n?([\s\S]*?)\n?```/gi)) {
+    push(match[1]);
+  }
+  const stripped = stripMarkdownCodeFences(text).trim();
+  push(stripped);
+  for (const balanced of extractBalancedJsonObjects(stripped)) {
+    push(balanced);
+  }
+  for (const balanced of extractBalancedJsonObjects(text)) {
+    push(balanced);
+  }
+  for (const line of stripped.split("\n")) {
+    const trimmed = line.trim();
+    if (trimmed.startsWith("{") || trimmed.startsWith("[")) {
+      push(trimmed);
+    }
+  }
+  push(extractBalancedJson(stripped));
+  push(extractBalancedJson(text));
+  return candidates;
+}
+function isStandaloneMalformedJsonCandidate(response) {
+  const trimmed = response.trim();
+  if (!trimmed.startsWith("{") && !trimmed.startsWith("[")) return false;
+  try {
+    JSON.parse(trimmed);
+    return false;
+  } catch {
+    return /[{[]/.test(trimmed);
+  }
+}
+function parseJsonCandidate(candidate) {
+  try {
+    return JSON.parse(candidate);
+  } catch {
+    const repairCandidates = /* @__PURE__ */ new Set();
+    const balanced = extractBalancedJson(candidate);
+    if (balanced) {
+      repairCandidates.add(balanced);
+    }
+    repairCandidates.add(candidate);
+    for (const repairCandidate of repairCandidates) {
+      const repaired = repairMalformedJsonCandidate(repairCandidate);
+      if (!repaired) continue;
+      try {
+        return JSON.parse(repaired);
+      } catch {
+      }
+    }
+    return null;
+  }
+}
+var MALFORMED_SIBLING_WRAPPER_PATTERN = /\{\s*"(correctness|quality|dimensions|limitation|os)"\s*:/y;
+function repairMalformedJsonCandidate(candidate) {
+  if (!candidate) return null;
+  const output = [];
+  const stack = [];
+  let inString = false;
+  let escaping = false;
+  let changed = false;
+  let lastSignificantOutputChar = "";
+  const append = (value) => {
+    output.push(value);
+    if (!/\s/.test(value)) {
+      lastSignificantOutputChar = value;
+    }
+  };
+  const nextNonWhitespaceChar = (start) => {
+    for (let i = start; i < candidate.length; i++) {
+      const ch = candidate[i];
+      if (ch && !/\s/.test(ch)) {
+        return ch;
+      }
+    }
+    return "";
+  };
+  const startsMalformedSiblingWrapper = (start) => {
+    if (stack[stack.length - 1] !== "{" || lastSignificantOutputChar !== ",") return false;
+    MALFORMED_SIBLING_WRAPPER_PATTERN.lastIndex = start;
+    return MALFORMED_SIBLING_WRAPPER_PATTERN.test(candidate);
+  };
+  for (let i = 0; i < candidate.length; i++) {
+    const ch = candidate[i];
+    if (ch === void 0) continue;
+    if (inString) {
+      append(ch);
+      if (escaping) {
+        escaping = false;
+      } else if (ch === "\\") {
+        escaping = true;
+      } else if (ch === '"') {
+        inString = false;
+      } else if (ch === "\n") {
+        output[output.length - 1] = "\\n";
+        changed = true;
+      }
+      continue;
+    }
+    if (ch === '"') {
+      inString = true;
+      append(ch);
+      continue;
+    }
+    if (ch === "{" || ch === "[") {
+      if (ch === "{" && startsMalformedSiblingWrapper(i)) {
+        changed = true;
+        continue;
+      }
+      if ((lastSignificantOutputChar === "}" || lastSignificantOutputChar === "]") && ch === "{") {
+        append(",");
+        changed = true;
+      }
+      stack.push(ch);
+      append(ch);
+      continue;
+    }
+    if (ch === "}" || ch === "]") {
+      const expectedOpen = ch === "}" ? "{" : "[";
+      const actualOpen = stack[stack.length - 1];
+      if (actualOpen === expectedOpen) {
+        stack.pop();
+        if (lastSignificantOutputChar === ",") {
+          output.pop();
+          changed = true;
+        }
+        append(ch);
+      } else {
+        changed = true;
+      }
+      continue;
+    }
+    if (ch === ",") {
+      const next = nextNonWhitespaceChar(i + 1);
+      if (next === "}" || next === "]" || next === "") {
+        changed = true;
+        continue;
+      }
+    }
+    append(ch);
+  }
+  while (stack.length > 0) {
+    const open = stack.pop();
+    append(open === "{" ? "}" : "]");
+    changed = true;
+  }
+  const repaired = output.join("").trim();
+  return changed && repaired ? repaired : null;
+}
+
+export {
+  extractBalancedJson,
+  extractBalancedJsonObjects,
+  stripMarkdownCodeFences,
+  collectJsonCandidates,
+  isStandaloneMalformedJsonCandidate,
+  parseJsonCandidate
+};
+//# sourceMappingURL=chunk-VVGEPBPS.js.map

package/dist/chunk-VXF4Q3FW.js

@@ -0,0 +1,20 @@
+// src/core/variant-strategies.ts
+var BUILT_IN_VARIANT_STRATEGIES = [
+  "conservative",
+  "innovative",
+  "hybrid",
+  "fast",
+  // Neutral equal-peer analysis profile used by the fusion synthesis panel.
+  "fusion"
+];
+var NON_COMPETITION_STRATEGIES = /* @__PURE__ */ new Set(["fusion"]);
+var COMPETITION_VARIANT_STRATEGIES = BUILT_IN_VARIANT_STRATEGIES.filter(
+  (strategy) => !NON_COMPETITION_STRATEGIES.has(strategy)
+);
+
+export {
+  BUILT_IN_VARIANT_STRATEGIES,
+  NON_COMPETITION_STRATEGIES,
+  COMPETITION_VARIANT_STRATEGIES
+};
+//# sourceMappingURL=chunk-VXF4Q3FW.js.map

package/dist/chunk-W3ZGW3C5.js

@@ -0,0 +1,331 @@
+import {
+  ExitCodeError
+} from "./chunk-FUVP64ER.js";
+import {
+  listRegisteredVariantStrategies,
+  validateStrategy
+} from "./chunk-LWTN3WRV.js";
+import {
+  registry
+} from "./chunk-GOAQ2I7Y.js";
+import {
+  validateModel
+} from "./chunk-TIBZPAD2.js";
+import {
+  resolveConfig
+} from "./chunk-IZZK3H6I.js";
+import {
+  clearActiveProfile,
+  createProfile,
+  deleteProfile,
+  listProfiles,
+  readActiveProfileName,
+  readProfile,
+  setActiveProfile
+} from "./chunk-SZ7DL357.js";
+
+// src/cli/commands/profile.ts
+import { Command } from "commander";
+function printJson(data) {
+  console.log(JSON.stringify(data, null, 2));
+}
+var MODEL_VALIDATABLE_PROVIDERS = /* @__PURE__ */ new Set([
+  "codex",
+  "cursor",
+  "copilot",
+  "claude",
+  "gemini",
+  "openai"
+]);
+function validateProfileProvider(provider) {
+  if (registry.has(provider)) {
+    return;
+  }
+  const available = registry.getAllIds().join(", ");
+  console.error(`Error: Unknown provider "${provider}".`);
+  console.error(`Valid providers: ${available}`);
+  throw new ExitCodeError(1);
+}
+function resolveProviderContextForModelValidation(provider, fromProfile) {
+  if (provider) {
+    return provider;
+  }
+  if (!fromProfile) {
+    return void 0;
+  }
+  try {
+    return readProfile(fromProfile).defaults?.provider;
+  } catch {
+    return void 0;
+  }
+}
+function validateProfileModel(provider, model) {
+  if (!model) {
+    return;
+  }
+  if (!provider) {
+    console.error("Error: --model requires --provider (or --from a profile with a provider).");
+    throw new ExitCodeError(1);
+  }
+  validateProfileProvider(provider);
+  if (!MODEL_VALIDATABLE_PROVIDERS.has(provider)) {
+    return;
+  }
+  const result = validateModel({ provider, model });
+  if (result.valid) {
+    return;
+  }
+  const detail = result.warnings.join(" ");
+  console.error(`Error: Invalid model "${model}" for provider "${provider}".`);
+  if (detail) {
+    console.error(detail);
+  }
+  if (result.suggestion) {
+    console.error(`Did you mean "${result.suggestion}"?`);
+  }
+  console.error(
+    "Run `poetic provider show <id> --json` or `poetic provider refresh <id> --models` to inspect available model data."
+  );
+  throw new ExitCodeError(1);
+}
+function validateProfileStrategy(strategy) {
+  if (!strategy) {
+    return;
+  }
+  try {
+    validateStrategy(strategy, "fail");
+  } catch (error) {
+    const registered = listRegisteredVariantStrategies().join(", ");
+    const message = error instanceof Error ? error.message : String(error);
+    console.error(`Error: Invalid strategy "${strategy}".`);
+    console.error(message);
+    console.error(`Valid strategies: ${registered}`);
+    throw new ExitCodeError(1);
+  }
+}
+function formatProfile(data, active) {
+  const lines = [];
+  lines.push(`name: ${data.name}${active ? " (active)" : ""}`);
+  if (data.description) lines.push(`description: ${data.description}`);
+  lines.push(`created: ${data.createdAt}`);
+  lines.push(`updated: ${data.updatedAt}`);
+  if (data.defaults && Object.keys(data.defaults).length > 0) {
+    lines.push("defaults:");
+    const d = data.defaults;
+    if (d.provider) lines.push(`  provider: ${d.provider}`);
+    if (d.model) lines.push(`  model: ${d.model}`);
+    if (d.strategy) lines.push(`  strategy: ${d.strategy}`);
+    if (d.routingPolicy) lines.push(`  routingPolicy: ${d.routingPolicy}`);
+    if (d.judge?.type) lines.push(`  judge.type: ${d.judge.type}`);
+    if (d.judge?.provider) lines.push(`  judge.provider: ${d.judge.provider}`);
+    if (d.judge?.model) lines.push(`  judge.model: ${d.judge.model}`);
+    if (d.synthesis?.provider) lines.push(`  synthesis.provider: ${d.synthesis.provider}`);
+    if (d.synthesis?.model) lines.push(`  synthesis.model: ${d.synthesis.model}`);
+    if (d.providers && Object.keys(d.providers).length > 0) {
+      lines.push("  providers:");
+      for (const [prov, cfg] of Object.entries(d.providers)) {
+        if (cfg?.model) lines.push(`    ${prov}.model: ${cfg.model}`);
+        if (cfg?.strategy) lines.push(`    ${prov}.strategy: ${cfg.strategy}`);
+      }
+    }
+  }
+  if (data.telemetry && Object.keys(data.telemetry).length > 0) {
+    lines.push("telemetry:");
+    if (data.telemetry.enabled !== void 0) lines.push(`  enabled: ${data.telemetry.enabled}`);
+    if (data.telemetry.silent !== void 0) lines.push(`  silent: ${data.telemetry.silent}`);
+  }
+  return lines.join("\n");
+}
+function createListSubcommand() {
+  return new Command("list").description("List all profiles").option("--json", "Output as JSON").action((opts) => {
+    const profiles = listProfiles();
+    if (opts.json) {
+      printJson(profiles);
+      return;
+    }
+    if (profiles.length === 0) {
+      console.log("No profiles found.");
+      return;
+    }
+    for (const p of profiles) {
+      const activeMarker = p.active ? " *" : "  ";
+      const desc = p.description ? `  ${p.description}` : "";
+      console.log(`${activeMarker} ${p.name}${desc}`);
+    }
+  });
+}
+function createUseSubcommand() {
+  return new Command("use").description("Set the active profile").argument("<name>", "Profile name to activate").action((name) => {
+    setActiveProfile(name);
+    console.log(`Active profile: ${name}`);
+  });
+}
+function createShowSubcommand() {
+  return new Command("show").description("Show profile contents (defaults to active profile)").argument("[name]", "Profile name (defaults to active)").option("--json", "Output as JSON").action((name, opts) => {
+    const activeName = readActiveProfileName();
+    const profileName = name ?? activeName;
+    if (!profileName) {
+      console.error(
+        "Error: No active profile. Specify a profile name or set one with: poetic profile use <name>"
+      );
+      throw new ExitCodeError(1);
+    }
+    const data = readProfile(profileName);
+    const isActive = profileName === activeName;
+    if (opts.json) {
+      printJson({ ...data, active: isActive });
+      return;
+    }
+    console.log(formatProfile(data, isActive));
+  });
+}
+function createCreateSubcommand() {
+  return new Command("create").description("Create a new profile").argument("<name>", "Profile name").option("--from <other>", "Clone settings from another profile").option("--description <text>", "Profile description").option("--provider <id>", "Default provider for this profile").option("--model <id>", "Default model for this profile").option("--strategy <name>", "Default strategy for this profile").option("--json", "Output as JSON").action(
+    (name, opts) => {
+      if (opts.provider) {
+        validateProfileProvider(opts.provider);
+      }
+      const providerForModel = resolveProviderContextForModelValidation(opts.provider, opts.from);
+      validateProfileModel(providerForModel, opts.model);
+      validateProfileStrategy(opts.strategy);
+      const defaults = opts.provider || opts.model || opts.strategy ? {
+        provider: opts.provider,
+        model: opts.model,
+        strategy: opts.strategy
+      } : void 0;
+      const profile = createProfile(name, {
+        fromProfile: opts.from,
+        description: opts.description,
+        defaults
+      });
+      if (opts.json) {
+        printJson(profile);
+        return;
+      }
+      const fromNote = opts.from ? ` (cloned from ${opts.from})` : "";
+      console.log(`Created profile: ${name}${fromNote}`);
+      if (opts.description) console.log(`  description: ${opts.description}`);
+      if (profile.defaults?.provider) console.log(`  provider: ${profile.defaults.provider}`);
+      if (profile.defaults?.model) console.log(`  model: ${profile.defaults.model}`);
+      if (profile.defaults?.strategy) console.log(`  strategy: ${profile.defaults.strategy}`);
+    }
+  );
+}
+function createDeleteSubcommand() {
+  return new Command("delete").description("Delete a profile").argument("<name>", "Profile name").option("--force", "Force delete even if this is the active profile").option("--json", "Output as JSON").action((name, opts) => {
+    deleteProfile(name, opts.force);
+    if (opts.json) {
+      printJson({ deleted: name });
+      return;
+    }
+    console.log(`Deleted profile: ${name}`);
+  });
+}
+function createExplainSubcommand() {
+  return new Command("explain").description("Show the active profile and how it interacts with configuration resolution").option("--json", "Output as JSON").action((opts) => {
+    const activeName = readActiveProfileName();
+    const profiles = listProfiles();
+    let activeProfileData = null;
+    if (activeName) {
+      try {
+        activeProfileData = readProfile(activeName);
+      } catch {
+      }
+    }
+    const resolved = resolveConfig();
+    if (opts.json) {
+      printJson({
+        activeProfile: activeName ?? null,
+        profileData: activeProfileData,
+        availableProfiles: profiles.map((p) => p.name),
+        resolution: {
+          provider: {
+            value: resolved.defaultProvider.value,
+            source: resolved.defaultProvider.source
+          },
+          model: {
+            value: resolved.defaultModel.value,
+            source: resolved.defaultModel.source
+          },
+          strategy: {
+            value: resolved.defaultStrategy.value,
+            source: resolved.defaultStrategy.source
+          },
+          judgeType: {
+            value: resolved.judge.type.value,
+            source: resolved.judge.type.source
+          }
+        }
+      });
+      return;
+    }
+    console.log("Profile resolution:");
+    console.log("");
+    if (activeName && activeProfileData) {
+      console.log(`Active profile: ${activeName}`);
+      if (activeProfileData.description) {
+        console.log(`  ${activeProfileData.description}`);
+      }
+    } else if (activeName) {
+      console.log(`Active profile: ${activeName} (missing \u2014 file not found)`);
+    } else {
+      console.log("Active profile: none");
+    }
+    console.log("");
+    console.log("Precedence order (highest to lowest):");
+    console.log("  1. CLI flags");
+    console.log("  2. Env vars (POETIC_DEFAULT_PROVIDER, POETIC_ACTIVE_PROFILE, ...)");
+    console.log(`  3. Active profile  ${activeName ? `[${activeName}]` : "[none set]"}`);
+    console.log("  4. Project config  (.poetic/config/poetic.config.jsonc)");
+    console.log("  5. User config     (~/.config/poetic/poetic.config.jsonc)");
+    console.log("  6. Registry defaults");
+    console.log("  7. Hardcoded fallback");
+    console.log("");
+    console.log("Effective values:");
+    console.log(
+      `  provider: ${resolved.defaultProvider.value}  [from: ${resolved.defaultProvider.source}]`
+    );
+    console.log(
+      `  model:    ${resolved.defaultModel.value}  [from: ${resolved.defaultModel.source}]`
+    );
+    console.log(
+      `  strategy: ${resolved.defaultStrategy.value}  [from: ${resolved.defaultStrategy.source}]`
+    );
+    console.log(
+      `  judge:    ${resolved.judge.type.value}  [from: ${resolved.judge.type.source}]`
+    );
+    if (profiles.length > 1) {
+      console.log("");
+      console.log("Available profiles:");
+      for (const p of profiles) {
+        console.log(`  ${p.active ? "*" : " "} ${p.name}`);
+      }
+    }
+  });
+}
+function createClearSubcommand() {
+  return new Command("clear").description("Clear the active profile (use system defaults)").option("--json", "Output as JSON").action((opts) => {
+    clearActiveProfile();
+    if (opts.json) {
+      printJson({ activeProfile: null });
+      return;
+    }
+    console.log("Active profile cleared.");
+  });
+}
+function createProfileCommand() {
+  const cmd = new Command("profile").description("Manage named user-level configuration profiles");
+  cmd.addCommand(createListSubcommand());
+  cmd.addCommand(createUseSubcommand());
+  cmd.addCommand(createShowSubcommand());
+  cmd.addCommand(createCreateSubcommand());
+  cmd.addCommand(createDeleteSubcommand());
+  cmd.addCommand(createExplainSubcommand());
+  cmd.addCommand(createClearSubcommand());
+  return cmd;
+}
+
+export {
+  createProfileCommand
+};
+//# sourceMappingURL=chunk-W3ZGW3C5.js.map