@poetic-ai/poetic 1.42.1-bootstrap.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-MFADRRTR.js

@@ -0,0 +1,112 @@
+import {
+  buildProjectVerificationGuidance
+} from "./chunk-MCPQNJMK.js";
+import {
+  detectProjectCapabilities,
+  hasProjectLanguage
+} from "./chunk-GNH3QGTL.js";
+
+// src/core/project/execution-scope.ts
+import { existsSync, readFileSync, realpathSync } from "fs";
+import path from "path";
+var POETIC_PACKAGE_NAME = "@poetic-ai/poetic";
+var POETIC_SELF_VERIFICATION_COMMANDS = [
+  { kind: "format", command: "npm run format:check", scope: "full" },
+  { kind: "lint", command: "npm run lint", scope: "touched" },
+  { kind: "typecheck", command: "npm run typecheck", scope: "full" },
+  { kind: "test", command: "npm run test:smoke", scope: "targeted" },
+  { kind: "build", command: "npm run build", scope: "full" }
+];
+function normalizeRoot(root) {
+  const resolved = path.resolve(root);
+  try {
+    return realpathSync(resolved);
+  } catch {
+    return resolved;
+  }
+}
+function readPackageName(root) {
+  const packageJsonPath = path.join(root, "package.json");
+  if (!existsSync(packageJsonPath)) return null;
+  try {
+    const parsed = JSON.parse(readFileSync(packageJsonPath, "utf8"));
+    if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) return null;
+    const name = parsed.name;
+    return typeof name === "string" ? name : null;
+  } catch {
+    return null;
+  }
+}
+function isNodeLikeProject(capabilities) {
+  const projectCapabilities = capabilities;
+  return hasProjectLanguage(projectCapabilities, "node") || hasProjectLanguage(projectCapabilities, "typescript") || hasProjectLanguage(projectCapabilities, "javascript");
+}
+function passVerification(value, reason) {
+  return reason ? { status: "pass", value, reason } : { status: "pass", value };
+}
+function failVerification(reason, error) {
+  return error ? { status: "fail", reason, error } : { status: "fail", reason };
+}
+function unavailableVerification(reason) {
+  return { status: "unavailable", reason };
+}
+function assertPoeticSelfExecutionScope(options) {
+  const packageRoot = normalizeRoot(options.root);
+  const packageName = readPackageName(packageRoot);
+  if (packageName !== POETIC_PACKAGE_NAME) {
+    throw new Error(
+      `Expected Poetic self scope at package root ${packageRoot} to be ${POETIC_PACKAGE_NAME}; found ${packageName ?? "no package identity"}`
+    );
+  }
+  return {
+    kind: "poetic-self",
+    root: packageRoot,
+    packageName: POETIC_PACKAGE_NAME,
+    packageRoot,
+    verificationCommands: POETIC_SELF_VERIFICATION_COMMANDS.map((command) => ({ ...command }))
+  };
+}
+function resolvePoeticSelfExecutionScope(options) {
+  try {
+    return passVerification(assertPoeticSelfExecutionScope(options));
+  } catch (error) {
+    return failVerification(
+      error instanceof Error ? error.message : String(error),
+      error instanceof Error ? error : void 0
+    );
+  }
+}
+function buildTargetWorktreeExecutionScope(options) {
+  if (options.confirmedRoot !== true) {
+    return unavailableVerification(
+      "target-worktree verification requires an explicitly confirmed target root"
+    );
+  }
+  try {
+    const root = normalizeRoot(options.root);
+    const guidance = buildProjectVerificationGuidance(root, options.changedFiles ?? []);
+    return passVerification({
+      kind: "target-worktree",
+      root,
+      confirmedRoot: true,
+      capabilities: guidance.capabilities,
+      guidance
+    });
+  } catch (error) {
+    return failVerification(
+      `target-worktree verification scope could not be built: ${error instanceof Error ? error.message : String(error)}`,
+      error instanceof Error ? error : void 0
+    );
+  }
+}
+function detectTargetWorktreeCapabilities(root) {
+  return detectProjectCapabilities(root);
+}
+
+export {
+  isNodeLikeProject,
+  resolvePoeticSelfExecutionScope,
+  buildTargetWorktreeExecutionScope,
+  detectTargetWorktreeCapabilities
+};
+//# sourceMappingURL=chunk-MFADRRTR.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

package/dist/chunk-MQ4WA34C.js

@@ -0,0 +1,206 @@
+import {
+  evaluateStaleReclaim
+} from "./chunk-P7CQGPLS.js";
+import {
+  signalCoordinator
+} from "./chunk-72YTZMAM.js";
+
+// src/planning/ingest-lock.ts
+import { randomUUID } from "crypto";
+import * as fs from "fs/promises";
+import * as os from "os";
+import * as path from "path";
+var DEFAULTS = {
+  timeoutMs: 6e4,
+  staleThresholdMs: 3e5,
+  initialRetryMs: 50,
+  maxRetryMs: 2e3,
+  backoffFactor: 2
+};
+var CROSS_HOST_STALE_MULTIPLIER = 3;
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+function getHostIdentity() {
+  const envHostname = process.env.HOSTNAME?.trim();
+  return envHostname || os.hostname() || "unknown";
+}
+async function readLockPayload(lockFile) {
+  const read = await readLockPayloadWithRaw(lockFile);
+  return read?.payload ?? null;
+}
+async function readLockPayloadWithRaw(lockFile) {
+  try {
+    const content = await fs.readFile(lockFile, "utf-8");
+    let payload = null;
+    try {
+      payload = JSON.parse(content);
+    } catch {
+      payload = null;
+    }
+    return { payload, rawContent: content };
+  } catch {
+    return null;
+  }
+}
+function isProcessAlive(pid) {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (error) {
+    if (error.code === "EPERM") {
+      return true;
+    }
+    return false;
+  }
+}
+async function isLockStaleAndAbandoned(lockFile, staleThresholdMs) {
+  try {
+    const stat2 = await fs.stat(lockFile);
+    const ageMs = Date.now() - stat2.mtimeMs;
+    const read = await readLockPayloadWithRaw(lockFile);
+    if (!read) {
+      return null;
+    }
+    const payload = read.payload;
+    let holder = null;
+    if (payload && typeof payload.pid === "number") {
+      const currentHostname = getHostIdentity();
+      const hasUnknownHost = payload.hostname === "unknown" || currentHostname === "unknown";
+      const sameHost = !hasUnknownHost && payload.hostname === currentHostname;
+      holder = { sameHost, pidAlive: sameHost ? isProcessAlive(payload.pid) : false };
+    }
+    const decision = evaluateStaleReclaim(
+      { ageMs, holder },
+      {
+        staleMs: staleThresholdMs,
+        corruptPayload: "reclaim",
+        foreignHost: { kind: "after-multiplier", multiplier: CROSS_HOST_STALE_MULTIPLIER },
+        // Preserve the original strict-greater-than age boundary (age <= stale
+        // holds; reclaim only strictly past stale / past 3x for foreign hosts).
+        ageBoundary: "gt"
+      }
+    );
+    return decision === "reclaim" ? { dev: stat2.dev, ino: stat2.ino, rawContent: read.rawContent } : null;
+  } catch {
+    return null;
+  }
+}
+async function releaseOwnLock(lockFile, snapshot) {
+  try {
+    if (!await lockSnapshotStillMatches(lockFile, snapshot)) {
+      return;
+    }
+    try {
+      await fs.unlink(lockFile);
+    } catch (error) {
+      if (error.code !== "ENOENT") {
+      }
+    }
+  } finally {
+    await snapshot.fileHandle?.close().catch(() => {
+    });
+  }
+}
+async function lockSnapshotStillMatches(lockFile, snapshot) {
+  try {
+    const [openFileStat, stat2, rawContent] = await Promise.all([
+      snapshot.fileHandle?.stat(),
+      fs.stat(lockFile),
+      fs.readFile(lockFile, "utf-8")
+    ]);
+    const acquiredDev = openFileStat?.dev ?? snapshot.dev;
+    const acquiredIno = openFileStat?.ino ?? snapshot.ino;
+    return stat2.dev === acquiredDev && stat2.ino === acquiredIno && rawContent === snapshot.rawContent;
+  } catch {
+    return false;
+  }
+}
+async function forceRelease(lockFile, snapshot) {
+  if (!await lockSnapshotStillMatches(lockFile, snapshot)) {
+    return;
+  }
+  try {
+    await fs.unlink(lockFile);
+  } catch (error) {
+    if (error.code !== "ENOENT") {
+      throw error;
+    }
+  }
+}
+async function withIngestLock(planningRoot, fn, options) {
+  const timeoutMs = options?.timeoutMs ?? DEFAULTS.timeoutMs;
+  const staleThresholdMs = options?.staleThresholdMs ?? DEFAULTS.staleThresholdMs;
+  const initialRetryMs = options?.initialRetryMs ?? DEFAULTS.initialRetryMs;
+  const maxRetryMs = options?.maxRetryMs ?? DEFAULTS.maxRetryMs;
+  const backoffFactor = options?.backoffFactor ?? DEFAULTS.backoffFactor;
+  const operation = options?.operation ?? "ingest";
+  const lockDir = options?.lockDir ?? path.join(planningRoot, ".poetic", "planning", "locks");
+  const lockFile = path.join(lockDir, "ingest.lock");
+  await fs.mkdir(lockDir, { recursive: true });
+  const startTime = Date.now();
+  let retryMs = initialRetryMs;
+  while (Date.now() - startTime < timeoutMs) {
+    const staleSnapshot = await isLockStaleAndAbandoned(lockFile, staleThresholdMs);
+    if (staleSnapshot) {
+      await forceRelease(lockFile, staleSnapshot);
+    }
+    try {
+      const ownerId = randomUUID();
+      const payload = {
+        pid: process.pid,
+        hostname: getHostIdentity(),
+        createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+        operation,
+        ownerId
+      };
+      const rawContent = JSON.stringify(payload, null, 2);
+      const fileHandle = await fs.open(lockFile, "wx");
+      let lockSnapshot;
+      try {
+        await fileHandle.writeFile(rawContent, "utf-8");
+        const lockStat = await fileHandle.stat();
+        lockSnapshot = { dev: lockStat.dev, ino: lockStat.ino, rawContent, fileHandle };
+      } catch (writeError) {
+        await fileHandle.close().catch(() => {
+        });
+        await fs.unlink(lockFile).catch(() => {
+        });
+        throw writeError;
+      }
+      const cleanupName = `planning-ingest-lock:${process.pid}:${operation}`;
+      const release = async () => {
+        try {
+          await releaseOwnLock(lockFile, lockSnapshot);
+        } finally {
+          signalCoordinator.unregister(cleanupName);
+        }
+      };
+      signalCoordinator.register(cleanupName, release, {
+        priority: "critical",
+        phase: "artifact-cleanup"
+      });
+      try {
+        return await fn();
+      } finally {
+        await release();
+      }
+    } catch (error) {
+      if (error.code === "EEXIST") {
+        await sleep(retryMs);
+        retryMs = Math.min(retryMs * backoffFactor, maxRetryMs);
+        continue;
+      }
+      throw error;
+    }
+  }
+  const lockInfo = await readLockPayload(lockFile);
+  throw new Error(
+    `Ingest lock acquisition timed out after ${timeoutMs}ms. Lock held by PID ${lockInfo?.pid ?? "unknown"} since ${lockInfo?.createdAt ?? "unknown"} (operation: ${lockInfo?.operation ?? "unknown"})`
+  );
+}
+
+export {
+  withIngestLock
+};
+//# sourceMappingURL=chunk-MQ4WA34C.js.map