@poetic-ai/poetic 1.42.0

package/dist/chunk-R35PEUKH.js

@@ -0,0 +1,511 @@
+import {
+  checkVerifyCommandSafety,
+  runVerifyCommands
+} from "./chunk-LO23NABI.js";
+import {
+  buildPackageScriptCommand,
+  detectProjectCapabilities
+} from "./chunk-FHOWVDF5.js";
+import {
+  isValidPath
+} from "./chunk-3G6FZCRF.js";
+import {
+  describeVerificationCommand
+} from "./chunk-2QLYTVYX.js";
+import {
+  resolveCliRepoRoot
+} from "./chunk-L7JZLXQL.js";
+import {
+  isRealPathWithin
+} from "./chunk-XZE4XARH.js";
+
+// src/planning/completion-contracts.ts
+import { existsSync } from "fs";
+import * as fs from "fs/promises";
+import * as path from "path";
+import { z } from "zod";
+
+// src/automation/flywheel-check-path.ts
+import { normalize } from "path";
+function isValidCheckPath(checkPath) {
+  if (!isValidPath(checkPath, { allowAbsolute: false })) {
+    if (checkPath.startsWith("/") || /^[a-zA-Z]:/.test(checkPath)) {
+      return { valid: false, error: `Absolute paths not allowed: ${checkPath}` };
+    }
+    const normalizedPath = normalize(checkPath);
+    if (normalizedPath.startsWith("..") || normalizedPath.includes("/..")) {
+      return { valid: false, error: `Path traversal not allowed: ${checkPath}` };
+    }
+    return { valid: false, error: `Invalid path: ${checkPath}` };
+  }
+  if (/[*?[\]]/.test(checkPath)) {
+    return { valid: false, error: `Glob patterns not allowed: ${checkPath}` };
+  }
+  return { valid: true };
+}
+
+// src/planning/completion-contracts.ts
+var DETERMINISTIC_COMPLETION_CONTRACT_TYPES = [
+  "path_exists",
+  "file_contains",
+  "glob_exists",
+  "command_passes",
+  "test_passes"
+];
+var COMPLETION_CONTRACT_TYPES = [
+  ...DETERMINISTIC_COMPLETION_CONTRACT_TYPES,
+  "llm_judge"
+];
+var PathExistsContractSchema = z.object({
+  type: z.literal("path_exists"),
+  paths: z.array(z.string().min(1)).min(1)
+});
+var FileContainsContractSchema = z.object({
+  type: z.literal("file_contains"),
+  path: z.string().min(1),
+  content: z.string().min(1),
+  regex: z.boolean().optional()
+});
+var GlobExistsContractSchema = z.object({
+  type: z.literal("glob_exists"),
+  pattern: z.string().min(1)
+});
+var CommandPassesContractSchema = z.object({
+  type: z.literal("command_passes"),
+  command: z.string().min(1)
+});
+var TestPassesContractSchema = z.object({
+  type: z.literal("test_passes"),
+  profile: z.string().min(1)
+});
+var LlmJudgeContractSchema = z.object({
+  type: z.literal("llm_judge"),
+  prompt: z.string().min(1),
+  target: z.string().min(1).optional()
+});
+var CompletionContractSchema = z.discriminatedUnion("type", [
+  PathExistsContractSchema,
+  FileContainsContractSchema,
+  GlobExistsContractSchema,
+  CommandPassesContractSchema,
+  TestPassesContractSchema,
+  LlmJudgeContractSchema
+]);
+function validateRepoRelativePath(value, field, errors, options = {}) {
+  if (!options.allowGlob) {
+    const pathResult = isValidCheckPath(value);
+    if (!pathResult.valid) {
+      errors.push({
+        field,
+        message: pathResult.error ?? `Invalid path: ${value}`
+      });
+    }
+    return;
+  }
+  if (value.includes("\0") || path.isAbsolute(value)) {
+    errors.push({
+      field,
+      message: `Glob pattern must be repo-relative: ${value}`
+    });
+    return;
+  }
+  const normalized = path.normalize(value);
+  if (normalized.startsWith("..") || normalized.includes(`${path.sep}..`)) {
+    errors.push({
+      field,
+      message: `Path traversal not allowed: ${value}`
+    });
+  }
+}
+function validateCommandContract(command, field, errors) {
+  const safety = checkVerifyCommandSafety(command);
+  if (!safety.safe) {
+    errors.push({
+      field,
+      message: safety.error
+    });
+  }
+}
+function toRawCompletionContracts(input) {
+  if (input === void 0 || input === null) return [];
+  if (Array.isArray(input)) return input;
+  return [input];
+}
+function validateCompletionContracts(input) {
+  const errors = [];
+  const rawContracts = toRawCompletionContracts(input);
+  if (rawContracts.length === 0) {
+    return { valid: true, errors: [] };
+  }
+  const parsedContracts = [];
+  for (const [index, rawContract] of rawContracts.entries()) {
+    const parsed = CompletionContractSchema.safeParse(rawContract);
+    if (!parsed.success) {
+      const issue = parsed.error.issues[0];
+      errors.push({
+        field: `completionContract[${index}]`,
+        message: issue?.message ?? "Invalid completion contract"
+      });
+      continue;
+    }
+    const contract = parsed.data;
+    parsedContracts.push(contract);
+    const prefix = `completionContract[${index}]`;
+    switch (contract.type) {
+      case "path_exists":
+        for (const [pathIndex, repoPath] of contract.paths.entries()) {
+          validateRepoRelativePath(repoPath, `${prefix}.paths[${pathIndex}]`, errors);
+        }
+        break;
+      case "file_contains":
+        validateRepoRelativePath(contract.path, `${prefix}.path`, errors);
+        if (contract.regex) {
+          try {
+            RegExp(contract.content);
+          } catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            errors.push({
+              field: `${prefix}.content`,
+              message: `Invalid regex pattern: ${message}`
+            });
+          }
+        }
+        break;
+      case "glob_exists":
+        validateRepoRelativePath(contract.pattern, `${prefix}.pattern`, errors, {
+          allowGlob: true
+        });
+        break;
+      case "command_passes":
+        validateCommandContract(contract.command, `${prefix}.command`, errors);
+        break;
+      case "test_passes":
+        if (!contract.profile.includes(" ")) {
+          break;
+        }
+        validateCommandContract(contract.profile, `${prefix}.profile`, errors);
+        break;
+      default:
+        break;
+    }
+  }
+  if (errors.length === 0 && parsedContracts.length > 0 && parsedContracts.every((contract) => contract.type === "llm_judge")) {
+    errors.push({
+      field: "completionContract",
+      message: `llm_judge is advisory/non-gating and cannot be the only completion contract type. Include at least one deterministic contract: ${DETERMINISTIC_COMPLETION_CONTRACT_TYPES.join(", ")}.`
+    });
+  }
+  return {
+    valid: errors.length === 0,
+    errors
+  };
+}
+function normalizeCompletionContracts(input) {
+  if (!input) return [];
+  if (Array.isArray(input)) {
+    return input.map((entry) => CompletionContractSchema.safeParse(entry)).filter((result) => result.success).map((result) => result.data);
+  }
+  const parsed = CompletionContractSchema.safeParse(input);
+  return parsed.success ? [parsed.data] : [];
+}
+function isDeterministicCompletionContract(contract) {
+  return DETERMINISTIC_COMPLETION_CONTRACT_TYPES.includes(contract.type);
+}
+function getDeterministicCompletionContracts(contracts) {
+  return contracts.filter(isDeterministicCompletionContract);
+}
+function resolveCheckPath(inputPath, workingDir) {
+  if (typeof inputPath !== "string" || inputPath.length === 0) {
+    return { ok: false, reason: "empty path" };
+  }
+  if (inputPath.includes("\0")) {
+    return { ok: false, reason: "null byte in path" };
+  }
+  if (path.isAbsolute(inputPath)) {
+    return { ok: false, reason: "absolute path not allowed" };
+  }
+  const baseResolved = path.resolve(workingDir);
+  const fullResolved = path.resolve(baseResolved, inputPath);
+  if (!isRealPathWithin(fullResolved, baseResolved)) {
+    return { ok: false, reason: "path escapes working directory" };
+  }
+  return { ok: true, full: fullResolved };
+}
+async function pathExists(repoPath, workingDir) {
+  const resolved = resolveCheckPath(repoPath, workingDir);
+  if (!resolved.ok) {
+    return {
+      type: "path_exists",
+      passed: false,
+      message: `Rejected path: ${repoPath} (${resolved.reason})`
+    };
+  }
+  try {
+    await fs.access(resolved.full);
+    return {
+      type: "path_exists",
+      passed: true,
+      message: `Path exists: ${repoPath}`
+    };
+  } catch {
+    return {
+      type: "path_exists",
+      passed: false,
+      message: `Missing path: ${repoPath}`
+    };
+  }
+}
+async function fileContains(contract, workingDir) {
+  const resolved = resolveCheckPath(contract.path, workingDir);
+  if (!resolved.ok) {
+    return {
+      type: "file_contains",
+      passed: false,
+      message: `Rejected path: ${contract.path} (${resolved.reason})`
+    };
+  }
+  try {
+    const content = await fs.readFile(resolved.full, "utf-8");
+    const matched = contract.regex ? new RegExp(contract.content).test(content) : content.includes(contract.content);
+    return {
+      type: "file_contains",
+      passed: matched,
+      message: matched ? `File contains expected content: ${contract.path}` : `File missing expected content: ${contract.path}`
+    };
+  } catch {
+    return {
+      type: "file_contains",
+      passed: false,
+      message: `File not found: ${contract.path}`
+    };
+  }
+}
+async function loadMinimatch() {
+  const minimatchModule = await import("minimatch");
+  const minimatch = typeof minimatchModule.minimatch === "function" ? minimatchModule.minimatch : typeof minimatchModule.default === "function" ? minimatchModule.default : null;
+  if (!minimatch) {
+    throw new Error("Failed to load minimatch for glob_exists contract evaluation");
+  }
+  return minimatch;
+}
+async function walkRepoFiles(dir, rootDir, files) {
+  const entries = await fs.readdir(dir, { withFileTypes: true });
+  for (const entry of entries) {
+    if (entry.name === ".git" || entry.name === "node_modules") continue;
+    const fullPath = path.join(dir, entry.name);
+    if (entry.isDirectory()) {
+      await walkRepoFiles(fullPath, rootDir, files);
+      continue;
+    }
+    if (entry.isFile()) {
+      files.push(path.relative(rootDir, fullPath));
+    }
+  }
+}
+async function globExists(pattern, workingDir) {
+  const resolved = resolveCheckPath(pattern, workingDir);
+  if (!resolved.ok) {
+    return {
+      type: "glob_exists",
+      passed: false,
+      message: `Rejected glob: ${pattern} (${resolved.reason})`
+    };
+  }
+  const minimatch = await loadMinimatch();
+  const files = [];
+  await walkRepoFiles(workingDir, workingDir, files);
+  const matched = files.some((file) => minimatch(file, pattern));
+  return {
+    type: "glob_exists",
+    passed: matched,
+    message: matched ? `Glob matched: ${pattern}` : `No files matched glob: ${pattern}`
+  };
+}
+var TEST_PROFILE_BUCKETS = {
+  test: "test",
+  lint: "lint",
+  typecheck: "typecheck",
+  "type-check": "typecheck",
+  build: "build",
+  format: "format",
+  fmt: "format"
+};
+function hasRootPackageJson(root) {
+  try {
+    return existsSync(path.join(root, "package.json"));
+  } catch {
+    return false;
+  }
+}
+function isNodeProjectLanguage(language) {
+  return language === "node" || language === "typescript" || language === "javascript";
+}
+function isNodeOnlyRoot(root, languages) {
+  return hasRootPackageJson(root) && languages.length > 0 && languages.every(isNodeProjectLanguage);
+}
+function selectProfileVerificationCommand(commands, languages) {
+  const hasNonNodeLanguage = languages.some((language) => !isNodeProjectLanguage(language));
+  if (!hasNonNodeLanguage) return commands[0];
+  return commands.find((candidate) => describeVerificationCommand(candidate).language !== "node");
+}
+function resolveTestProfileCommand(profile, workingDir) {
+  if (profile.includes(" ")) {
+    return { kind: "command", command: profile };
+  }
+  const bucket = TEST_PROFILE_BUCKETS[profile];
+  if (!bucket) {
+    try {
+      const capabilities = detectProjectCapabilities(workingDir);
+      const isNodeRoot2 = isNodeOnlyRoot(workingDir, capabilities.languages);
+      if (isNodeRoot2) {
+        return { kind: "command", command: buildPackageScriptCommand(workingDir, profile) };
+      }
+    } catch {
+    }
+    return {
+      kind: "unavailable",
+      message: `verification unavailable for profile "${profile}" on this target language (no resolver verification bucket maps to it)`
+    };
+  }
+  let command;
+  let isNodeRoot = false;
+  try {
+    const capabilities = detectProjectCapabilities(workingDir);
+    command = selectProfileVerificationCommand(
+      capabilities.verification[bucket],
+      capabilities.languages
+    );
+    isNodeRoot = isNodeOnlyRoot(workingDir, capabilities.languages);
+  } catch (error) {
+    return {
+      kind: "unavailable",
+      message: `verification unavailable for profile "${profile}": project capabilities could not be resolved (${error instanceof Error ? error.message : String(error)})`
+    };
+  }
+  if (command) {
+    return { kind: "command", command };
+  }
+  if (isNodeRoot) {
+    return { kind: "command", command: buildPackageScriptCommand(workingDir, profile) };
+  }
+  return {
+    kind: "unavailable",
+    message: `verification unavailable for profile "${profile}" on this target language (resolver has no ${bucket} command)`
+  };
+}
+async function runCommandContract(type, command, workingDir) {
+  const safety = checkVerifyCommandSafety(command);
+  if (!safety.safe) {
+    return {
+      type,
+      passed: false,
+      message: safety.error
+    };
+  }
+  const result = await runVerifyCommands({
+    cwd: workingDir,
+    commands: [command],
+    commandProvenance: "workflow-config"
+  });
+  const failed = result.results.find((entry) => entry.exitCode !== 0);
+  if (!result.passed || failed) {
+    const failedCommand = failed?.command ?? command;
+    const exitCode = failed?.exitCode ?? 1;
+    return {
+      type,
+      passed: false,
+      message: `Command failed: ${failedCommand} (exit ${exitCode})`
+    };
+  }
+  return {
+    type,
+    passed: true,
+    message: `Command passed: ${command}`
+  };
+}
+async function evaluateCompletionContracts(contracts, workingDir = resolveCliRepoRoot()) {
+  const deterministic = getDeterministicCompletionContracts(contracts);
+  const results = [];
+  for (const contract of deterministic) {
+    let result;
+    switch (contract.type) {
+      case "path_exists": {
+        for (const repoPath of contract.paths) {
+          const pathResult = await pathExists(repoPath, workingDir);
+          results.push(pathResult);
+          if (!pathResult.passed) {
+            return { passed: false, results, failedCheck: pathResult };
+          }
+        }
+        continue;
+      }
+      case "file_contains":
+        result = await fileContains(contract, workingDir);
+        break;
+      case "glob_exists":
+        result = await globExists(contract.pattern, workingDir);
+        break;
+      case "command_passes":
+        result = await runCommandContract("command_passes", contract.command, workingDir);
+        break;
+      case "test_passes": {
+        const resolved = resolveTestProfileCommand(contract.profile, workingDir);
+        if (resolved.kind === "unavailable") {
+          result = {
+            type: "test_passes",
+            passed: false,
+            message: resolved.message
+          };
+          break;
+        }
+        result = await runCommandContract("test_passes", resolved.command, workingDir);
+        break;
+      }
+      default:
+        continue;
+    }
+    results.push(result);
+    if (!result.passed) {
+      return { passed: false, results, failedCheck: result };
+    }
+  }
+  return { passed: true, results };
+}
+function formatCompletionContractFailure(result) {
+  const failed = result.failedCheck ?? result.results.find((entry) => !entry.passed);
+  if (!failed) {
+    return "Completion contract check failed";
+  }
+  return `Completion contract not met (${failed.type}): ${failed.message}`;
+}
+async function assertCompletionContractsMet(options) {
+  if (options.bypassReason?.trim()) {
+    return;
+  }
+  const contracts = options.contracts ?? [];
+  if (contracts.length === 0) {
+    return;
+  }
+  const deterministic = getDeterministicCompletionContracts(contracts);
+  if (deterministic.length === 0) {
+    return;
+  }
+  const evaluation = await evaluateCompletionContracts(
+    contracts,
+    options.workingDir ?? resolveCliRepoRoot()
+  );
+  if (!evaluation.passed) {
+    throw new Error(formatCompletionContractFailure(evaluation));
+  }
+}
+
+export {
+  isValidCheckPath,
+  CompletionContractSchema,
+  validateCompletionContracts,
+  normalizeCompletionContracts,
+  getDeterministicCompletionContracts,
+  evaluateCompletionContracts,
+  assertCompletionContractsMet
+};
+//# sourceMappingURL=chunk-R35PEUKH.js.map

package/dist/chunk-R4UWBC35.js

@@ -0,0 +1,200 @@
+// src/utils/resolve-cli-binary.ts
+import fs from "fs";
+import os from "os";
+import path from "path";
+function resolveUserHomeDirectory() {
+  try {
+    const homedir = os.userInfo().homedir;
+    return homedir && homedir.trim().length > 0 ? homedir : void 0;
+  } catch {
+    try {
+      return os.homedir?.();
+    } catch {
+      return void 0;
+    }
+  }
+}
+function expandHomeTokens(value) {
+  const homeDirectory = resolveUserHomeDirectory();
+  if (!homeDirectory) return value;
+  return value.replace(/\$HOME/g, homeDirectory).replace(/%USERPROFILE%/g, homeDirectory).replace(/\$env:USERPROFILE/g, homeDirectory);
+}
+function isExplicitPath(command) {
+  return command.startsWith("~") || command.includes("/") || command.includes("\\");
+}
+var InvalidExplicitCliPathError = class extends Error {
+  constructor(commandPath) {
+    super(`Explicit CLI path is missing or not executable: ${commandPath}`);
+    this.commandPath = commandPath;
+    this.name = "InvalidExplicitCliPathError";
+  }
+  commandPath;
+  code = "POETIC_INVALID_EXPLICIT_CLI_PATH";
+};
+function expandTildePath(command) {
+  if (!command.startsWith("~")) return command;
+  const homeDirectory = resolveUserHomeDirectory();
+  if (!homeDirectory) return command;
+  if (command === "~") return homeDirectory;
+  if (command.startsWith("~/") || command.startsWith("~\\")) {
+    return path.join(homeDirectory, command.slice(2));
+  }
+  return command;
+}
+function isExecutableFile(candidate) {
+  try {
+    fs.accessSync(candidate, fs.constants.X_OK);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function binaryCandidates(binaryName) {
+  if (process.platform === "win32") {
+    return [`${binaryName}.cmd`, `${binaryName}.exe`, binaryName];
+  }
+  return [binaryName];
+}
+function resolveFromPathEnv(binaryName) {
+  const pathEnv = process.env.PATH;
+  if (!pathEnv) return void 0;
+  const searchDirs = pathEnv.split(path.delimiter).filter(Boolean);
+  if (searchDirs.length === 0) return void 0;
+  const candidates = binaryCandidates(binaryName);
+  for (const dir of searchDirs) {
+    for (const name of candidates) {
+      const fullPath = path.join(dir, name);
+      if (isExecutableFile(fullPath)) {
+        return fullPath;
+      }
+    }
+  }
+  return void 0;
+}
+function resolveFromNodeBin(binaryName) {
+  try {
+    const nodeDir = path.dirname(process.execPath);
+    const candidates = binaryCandidates(binaryName);
+    for (const name of candidates) {
+      const fullPath = path.join(nodeDir, name);
+      if (isExecutableFile(fullPath)) {
+        return fullPath;
+      }
+    }
+  } catch {
+  }
+  return void 0;
+}
+function parseNvmVersionToken(token) {
+  const trimmed = token.trim();
+  if (!trimmed) return void 0;
+  const normalized = trimmed.startsWith("v") ? trimmed : `v${trimmed}`;
+  if (/^v\d+\.\d+\.\d+$/.test(normalized)) {
+    return { exact: normalized };
+  }
+  const majorMatch = normalized.match(/^v(\d+)$/);
+  if (majorMatch) {
+    return { major: Number(majorMatch[1]) };
+  }
+  return void 0;
+}
+function resolveFromNvm(binaryName) {
+  if (process.platform === "win32") return void 0;
+  const homeDirectory = resolveUserHomeDirectory();
+  const nvmDirRaw = process.env.NVM_DIR || (homeDirectory ? path.join(homeDirectory, ".nvm") : "");
+  const nvmDir = expandHomeTokens(expandTildePath(nvmDirRaw));
+  if (!nvmDir) return void 0;
+  const versionsDir = path.join(nvmDir, "versions", "node");
+  const candidates = binaryCandidates(binaryName);
+  const aliasPath = path.join(nvmDir, "alias", "default");
+  try {
+    const token = fs.readFileSync(aliasPath, "utf8").trim();
+    const parsed = parseNvmVersionToken(token);
+    if (parsed?.exact) {
+      for (const name of candidates) {
+        const fullPath = path.join(versionsDir, parsed.exact, "bin", name);
+        if (isExecutableFile(fullPath)) {
+          return fullPath;
+        }
+      }
+    }
+  } catch {
+  }
+  try {
+    const entries = fs.readdirSync(versionsDir, { withFileTypes: true });
+    const versionDirs = entries.filter((entry) => entry.isDirectory() && /^v\d+\.\d+\.\d+$/.test(entry.name)).map((entry) => entry.name);
+    if (versionDirs.length === 0) return void 0;
+    const parsed = versionDirs.map((dirName) => {
+      const match = dirName.match(/^v(\d+)\.(\d+)\.(\d+)$/);
+      if (!match) return null;
+      return {
+        dirName,
+        major: Number(match[1]),
+        minor: Number(match[2]),
+        patch: Number(match[3])
+      };
+    }).filter((value) => value !== null).sort(
+      (a, b) => a.major !== b.major ? b.major - a.major : a.minor !== b.minor ? b.minor - a.minor : b.patch - a.patch
+    );
+    for (const version of parsed) {
+      for (const name of candidates) {
+        const fullPath = path.join(versionsDir, version.dirName, "bin", name);
+        if (isExecutableFile(fullPath)) {
+          return fullPath;
+        }
+      }
+    }
+  } catch {
+  }
+  return void 0;
+}
+function resolveCliBinary(rawCommand, binaryName) {
+  const command = rawCommand.trim();
+  if (!command) return rawCommand;
+  if (isExplicitPath(command)) {
+    const explicitPath = expandHomeTokens(expandTildePath(command));
+    if (isExecutableFile(explicitPath)) {
+      return explicitPath;
+    }
+    throw new InvalidExplicitCliPathError(explicitPath);
+  }
+  const searchName = command === binaryName ? binaryName : command;
+  const fromPath = resolveFromPathEnv(searchName);
+  if (fromPath) return fromPath;
+  const fromNode = resolveFromNodeBin(searchName);
+  if (fromNode) return fromNode;
+  const fromNvm = resolveFromNvm(searchName);
+  if (fromNvm) return fromNvm;
+  return rawCommand;
+}
+
+// src/core/providers/copilot/resolve-cli.ts
+import { existsSync } from "fs";
+import path2 from "path";
+var DEFAULT_RUNTIME = {
+  execPath: process.execPath,
+  platform: process.platform,
+  existsSync
+};
+function resolveCopilotCliBinary(rawCommand, runtime = DEFAULT_RUNTIME) {
+  if (rawCommand !== "copilot") {
+    return rawCommand;
+  }
+  if (!runtime.execPath) return rawCommand;
+  const binDir = path2.dirname(runtime.execPath);
+  const isWin = runtime.platform === "win32";
+  const candidates = isWin ? ["copilot.cmd", "copilot.exe", "copilot"] : ["copilot"];
+  for (const candidate of candidates) {
+    const candidatePath = path2.join(binDir, candidate);
+    if (runtime.existsSync(candidatePath)) {
+      return candidatePath;
+    }
+  }
+  return rawCommand;
+}
+
+export {
+  resolveCliBinary,
+  resolveCopilotCliBinary
+};
+//# sourceMappingURL=chunk-R4UWBC35.js.map