@poetic-ai/poetic 1.42.0

package/dist/chunk-IRFBN336.js

@@ -0,0 +1,878 @@
+import {
+  getBuckets
+} from "./chunk-HOYBYAOA.js";
+import {
+  SCHEMA_VERSION,
+  TelemetryDatabase,
+  checkSchemaVersion
+} from "./chunk-FYOILAN5.js";
+import {
+  hasMigratableRepoLocalData,
+  isDataMigrationComplete
+} from "./chunk-CD7ISXA4.js";
+import {
+  getGlobalTelemetryDir,
+  getProjectDataDir
+} from "./chunk-UUH2RVKS.js";
+import {
+  hasExplicitPoeticRoot,
+  resolvePoeticRepoStartDir,
+  resolveRepoRootOverride
+} from "./chunk-L7JZLXQL.js";
+
+// src/bootstrap/ensure-initialized.ts
+import { AsyncLocalStorage } from "async_hooks";
+import { execSync } from "child_process";
+import * as fs from "fs";
+import * as path from "path";
+import { fileURLToPath } from "url";
+import Database from "better-sqlite3";
+import * as lockfile from "proper-lockfile";
+
+// src/bootstrap/initialization-types.ts
+var RuntimeRequirements = {
+  /** Required directories */
+  directories: [
+    // Note: all paths are relative to the `.poetic/` directory.
+    "artifacts",
+    "config",
+    "telemetry",
+    "telemetry/db",
+    "telemetry/state",
+    "telemetry/state/competitions",
+    "telemetry/state/decisions",
+    "telemetry/state/variants",
+    "telemetry/logs",
+    "cache",
+    "worktrees",
+    "state"
+  ],
+  /** Required database files */
+  databases: ["telemetry/db/variants.db", "telemetry/db/validations.db"],
+  /** Required configuration files (created from embedded templates if missing) */
+  configFiles: [".gitignore"],
+  /** State marker file */
+  stateFile: "state/init.json",
+  /** Initialization lock file path (for cross-process safety) */
+  lockFile: "state/.init.lock"
+};
+var FullRequirements = {
+  /** Additional directories for full tier */
+  directories: [
+    // Note: all paths are relative to the `.poetic/` directory.
+    "templates",
+    "planning",
+    "reasoning"
+  ],
+  /** Optional configuration files for full setup */
+  optionalConfig: ["config/user.yaml"]
+};
+
+// src/bootstrap/ensure-initialized.ts
+var __filename = fileURLToPath(import.meta.url);
+var __dirname = path.dirname(__filename);
+function resolveRepoRootForPoeticDir(cwd, options = {}) {
+  const { honorPoeticRepo = true } = options;
+  if (honorPoeticRepo && hasExplicitPoeticRoot()) {
+    const explicitRoot = resolveRepoRootOverride();
+    if (explicitRoot) {
+      return explicitRoot;
+    }
+  }
+  const startDir = honorPoeticRepo ? resolvePoeticRepoStartDir(cwd) : cwd;
+  try {
+    const stdout = execSync("git rev-parse --show-toplevel", {
+      cwd: startDir,
+      stdio: ["ignore", "pipe", "ignore"]
+    }).toString().trim();
+    if (stdout) return stdout;
+  } catch {
+  }
+  let currentDir = path.resolve(startDir);
+  while (true) {
+    const gitDir = path.join(currentDir, ".git");
+    if (fs.existsSync(gitDir)) return currentDir;
+    const parentDir = path.dirname(currentDir);
+    if (parentDir === currentDir) break;
+    currentDir = parentDir;
+  }
+  return path.resolve(startDir);
+}
+function findPackageRoot(startDir) {
+  let current = startDir;
+  for (let i = 0; i < 12; i++) {
+    const pkgJsonPath = path.join(current, "package.json");
+    const templatesDir = path.join(current, "templates", ".poetic");
+    if (fs.existsSync(pkgJsonPath) && fs.existsSync(templatesDir)) {
+      return current;
+    }
+    const parent = path.dirname(current);
+    if (parent === current) break;
+    current = parent;
+  }
+  return path.resolve(startDir, "..");
+}
+var PACKAGE_ROOT = findPackageRoot(__dirname);
+var TEMPLATE_POETIC_DIR = path.join(PACKAGE_ROOT, "templates", ".poetic");
+var PACK_SAFE_TEMPLATE_SOURCES = {
+  ".gitignore": "gitignore.template"
+};
+var POETIC_GITIGNORE_RUNTIME_ENTRY_FALLBACK = [
+  "runs/",
+  "blocker-answers/",
+  "merge-apply/",
+  "config/project-context.json",
+  "provider-history/",
+  "prompts/",
+  "planning/indexes/",
+  // Transient intent context-injection telemetry (see gitignore.template).
+  "logs/injection/"
+];
+function readPoeticGitignoreTemplateEntries() {
+  const templatePath = path.join(TEMPLATE_POETIC_DIR, templateSourceRelPath(".gitignore"));
+  try {
+    return fs.readFileSync(templatePath, "utf-8").split("\n").map((line) => line.trim()).filter((line) => line.length > 0 && !line.startsWith("#"));
+  } catch {
+    return [...POETIC_GITIGNORE_RUNTIME_ENTRY_FALLBACK];
+  }
+}
+function toPosixRelPath(relPath) {
+  return relPath.split(path.sep).join("/");
+}
+function templateSourceRelPath(destRelPath) {
+  return PACK_SAFE_TEMPLATE_SOURCES[toPosixRelPath(destRelPath)] ?? destRelPath;
+}
+function templateDestRelPath(sourceRelPath) {
+  const normalized = toPosixRelPath(sourceRelPath);
+  for (const [dest, source] of Object.entries(PACK_SAFE_TEMPLATE_SOURCES)) {
+    if (source === normalized) return dest;
+  }
+  return sourceRelPath;
+}
+function normalizeGitignoreEntry(entry) {
+  return entry.trim().replace(/^\/+/, "").replace(/\/+$/, "");
+}
+function hasPoeticGitignoreRuntimeEntries(poeticDir) {
+  const gitignorePath = path.join(poeticDir, ".gitignore");
+  try {
+    const entries = new Set(
+      fs.readFileSync(gitignorePath, "utf-8").split("\n").map((line) => line.trim()).filter((line) => line.length > 0 && !line.startsWith("#")).map(normalizeGitignoreEntry).filter(Boolean)
+    );
+    return readPoeticGitignoreTemplateEntries().every(
+      (entry) => entries.has(normalizeGitignoreEntry(entry))
+    );
+  } catch {
+    return false;
+  }
+}
+function ensurePoeticGitignoreRuntimeEntries(poeticDir, result, log) {
+  const gitignorePath = path.join(poeticDir, ".gitignore");
+  let existing = "";
+  try {
+    existing = fs.readFileSync(gitignorePath, "utf-8");
+  } catch {
+    return;
+  }
+  const present = new Set(
+    existing.split("\n").map((line) => line.trim()).filter((line) => line.length > 0 && !line.startsWith("#")).map(normalizeGitignoreEntry).filter(Boolean)
+  );
+  const missing = readPoeticGitignoreTemplateEntries().filter(
+    (entry) => !present.has(normalizeGitignoreEntry(entry))
+  );
+  if (missing.length === 0) return;
+  const needsTrailingNewline = existing.length > 0 && !existing.endsWith("\n");
+  const prefix = needsTrailingNewline ? "\n" : "";
+  fs.appendFileSync(gitignorePath, `${prefix}${missing.join("\n")}
+`);
+  result.actions.repaired.push(gitignorePath);
+  log(`Updated runtime ignore entries: ${gitignorePath}`);
+}
+function hasTrackedInstanceBuckets(repoRoot) {
+  try {
+    return getBuckets(repoRoot).some((bucket) => {
+      const normalized = bucket.path.replace(/\\/g, "/");
+      return bucket.enabled && normalized.startsWith(".poetic/");
+    });
+  } catch {
+    return void 0;
+  }
+}
+function reconcilePoeticDirGitExclude(repoRoot, tier, result, log) {
+  let gitInfoExcludePath;
+  try {
+    const insideWorkTree = execSync("git rev-parse --is-inside-work-tree", {
+      cwd: repoRoot,
+      stdio: ["ignore", "pipe", "ignore"]
+    }).toString().trim();
+    if (insideWorkTree !== "true") return;
+    const resolvedPath = execSync("git rev-parse --git-path info/exclude", {
+      cwd: repoRoot,
+      stdio: ["ignore", "pipe", "ignore"]
+    }).toString().trim();
+    if (!resolvedPath) return;
+    gitInfoExcludePath = path.isAbsolute(resolvedPath) ? resolvedPath : path.resolve(repoRoot, resolvedPath);
+  } catch {
+    return;
+  }
+  let existing = "";
+  try {
+    if (fs.existsSync(gitInfoExcludePath)) {
+      existing = fs.readFileSync(gitInfoExcludePath, "utf-8");
+    } else {
+      fs.mkdirSync(path.dirname(gitInfoExcludePath), { recursive: true });
+    }
+  } catch {
+    return;
+  }
+  try {
+    const trackedInstanceBuckets = tier === "full" ? false : hasTrackedInstanceBuckets(repoRoot);
+    if (trackedInstanceBuckets === void 0) {
+      result.warnings.push(
+        "Could not resolve bucket paths; left git info exclude unchanged to avoid hiding managed .poetic work."
+      );
+      return;
+    }
+    if (tier === "full" || trackedInstanceBuckets) {
+      const lines = existing.split("\n");
+      const filtered = lines.filter((line) => {
+        const trimmed = line.trim();
+        return trimmed !== ".poetic/" && trimmed !== "/.poetic/";
+      });
+      if (filtered.length === lines.length) return;
+      fs.writeFileSync(gitInfoExcludePath, filtered.join("\n"));
+      result.actions.repaired.push(gitInfoExcludePath);
+      log(`Removed wholesale .poetic exclude from git info exclude: ${gitInfoExcludePath}`);
+      return;
+    }
+    const present = existing.split("\n").some((line) => line.trim() === ".poetic/" || line.trim() === "/.poetic/");
+    if (present) return;
+    const needsTrailingNewline = existing.length > 0 && !existing.endsWith("\n");
+    const prefix = needsTrailingNewline ? "\n" : "";
+    fs.appendFileSync(gitInfoExcludePath, `${prefix}.poetic/
+`);
+    result.actions.repaired.push(gitInfoExcludePath);
+    log(`Added wholesale .poetic exclude to git info exclude: ${gitInfoExcludePath}`);
+  } catch (error) {
+    result.warnings.push(
+      `Failed to update git info exclude for .poetic/: ${error instanceof Error ? error.message : String(error)}`
+    );
+  }
+}
+var LOCK_TIMEOUT_MS = 1e4;
+var LOCK_OPTIONS = {
+  stale: 3e4,
+  // Consider lock stale after 30 seconds
+  retries: {
+    retries: 50,
+    minTimeout: 100,
+    maxTimeout: 1e3,
+    maxRetryTime: LOCK_TIMEOUT_MS
+  }
+};
+function getProjectInitializationLockPath(repoRoot) {
+  return path.join(getProjectDataDir(path.resolve(repoRoot)), "initialization.lock");
+}
+var heldProjectInitializationLocks = new AsyncLocalStorage();
+async function withProjectInitializationLock(repoRoot, fn) {
+  const lockPath = getProjectInitializationLockPath(repoRoot);
+  const heldLocks = heldProjectInitializationLocks.getStore();
+  if (heldLocks?.has(lockPath)) return fn();
+  return withInitLock(
+    lockPath,
+    () => heldProjectInitializationLocks.run(/* @__PURE__ */ new Set([...heldLocks ?? [], lockPath]), fn)
+  );
+}
+async function ensurePoeticInitialized(options = {}) {
+  const repoRoot = resolveRepoRootForPoeticDir(options.cwd ?? process.cwd());
+  return withProjectInitializationLock(
+    repoRoot,
+    () => ensurePoeticInitializedLocked({ ...options, cwd: repoRoot })
+  );
+}
+async function ensurePoeticInitializedLocked(options) {
+  const startTime = Date.now();
+  const {
+    cwd = process.cwd(),
+    tier = "runtime",
+    verbose = false,
+    repair = false,
+    allowDegraded = true,
+    fullTemplateExcludes = []
+  } = options;
+  const repoRoot = resolveRepoRootForPoeticDir(cwd);
+  const poeticDir = path.join(repoRoot, ".poetic");
+  const stateFilePath = path.join(poeticDir, RuntimeRequirements.stateFile);
+  const result = {
+    status: "ok",
+    tier,
+    actions: { created: [], repaired: [], skipped: [] },
+    warnings: [],
+    errors: [],
+    nextSteps: [],
+    telemetryMode: "database",
+    initDurationMs: 0
+  };
+  const log = (message) => {
+    if (verbose) {
+      console.log(`[Init] ${message}`);
+    }
+  };
+  if (!repair) {
+    const fastState = readInitializationState(stateFilePath);
+    const hasDbFiles = fs.existsSync(path.join(poeticDir, "telemetry", "db", "variants.db")) && fs.existsSync(path.join(poeticDir, "telemetry", "db", "validations.db"));
+    const databasesOpenable = hasDbFiles && areDatabasesOpenable(poeticDir);
+    const hasGitignoreStub = fs.existsSync(path.join(poeticDir, ".gitignore"));
+    const hasRuntimeGitignoreEntries = hasPoeticGitignoreRuntimeEntries(poeticDir);
+    if (tier === "runtime" && fastState && fastState.schemaVersion === SCHEMA_VERSION && databasesOpenable && hasGitignoreStub && hasRuntimeGitignoreEntries && isTierSufficient(fastState.tier, tier)) {
+      reconcilePoeticDirGitExclude(repoRoot, maxTier(fastState.tier, tier), result, log);
+      if (result.status === "ok" || allowDegraded && result.status === "degraded") {
+        await warnIfDataMigrationPending(poeticDir, result);
+        if (result.actions.created.length > 0 || result.actions.repaired.length > 0) {
+          try {
+            await writeStateMarker(poeticDir, tier, result, log, true, {
+              materialChanges: true,
+              schemaNeedsHealing: false
+            });
+          } catch {
+          }
+        }
+        result.schemaVersion = fastState.schemaVersion;
+        result.nextSteps = generateNextSteps(result);
+        result.initDurationMs = Date.now() - startTime;
+        return finalizeInitializationResult(result, allowDegraded);
+      }
+    }
+  }
+  try {
+    log("Ensuring base directory exists");
+    await ensureBaseDirectory(poeticDir, result, log);
+    const lockResult = await (async () => {
+      log("Checking required directories");
+      await ensureDirectories(poeticDir, tier, result, log, allowDegraded);
+      await ensureExternalDataDirectories(repoRoot, poeticDir, result, log);
+      log("Initializing databases");
+      await initializeDatabases(poeticDir, result, log, allowDegraded);
+      log("Checking configuration stubs");
+      await ensureConfigStubs(poeticDir, tier, result, log, fullTemplateExcludes);
+      const existingState = readInitializationState(stateFilePath);
+      const effectiveTier = maxTier(existingState?.tier ?? tier, tier);
+      reconcilePoeticDirGitExclude(repoRoot, effectiveTier, result, log);
+      log("Writing state marker");
+      const schemaNeedsHealing = typeof existingState?.schemaVersion === "number" && typeof result.schemaVersion === "number" && existingState.schemaVersion < result.schemaVersion;
+      const materialChangesBeforeState = result.actions.created.length > 0 || result.actions.repaired.length > 0;
+      const shouldUpdateState = repair || schemaNeedsHealing || materialChangesBeforeState;
+      await writeStateMarker(poeticDir, tier, result, log, shouldUpdateState, {
+        materialChanges: materialChangesBeforeState,
+        schemaNeedsHealing
+      });
+      return result;
+    })();
+    Object.assign(result, lockResult);
+  } catch (error) {
+    const errorCode = determineErrorCode(error);
+    const errorMessage = error instanceof Error ? error.message : String(error);
+    result.status = "failed";
+    result.errors.push({
+      code: errorCode,
+      message: errorMessage,
+      cause: error
+    });
+    if (errorCode === "DB_LOCKED" /* DB_LOCKED */) {
+      result.nextSteps.push(
+        "Wait for other Poetic processes to complete",
+        "Check for a stale project initialization lock in the Poetic data directory",
+        `If issue persists, inspect ${getProjectInitializationLockPath(repoRoot)}`
+      );
+    }
+  }
+  result.initDurationMs = Date.now() - startTime;
+  if (result.nextSteps.length === 0) {
+    result.nextSteps = generateNextSteps(result);
+  }
+  log(`Initialization complete: ${result.status} (${result.initDurationMs}ms)`);
+  return finalizeInitializationResult(result, allowDegraded);
+}
+async function withInitLock(lockPath, fn) {
+  const lockDir = path.dirname(lockPath);
+  if (!fs.existsSync(lockDir)) {
+    fs.mkdirSync(lockDir, { recursive: true });
+  }
+  if (!fs.existsSync(lockPath)) {
+    fs.writeFileSync(lockPath, "");
+  }
+  let release;
+  try {
+    try {
+      release = await lockfile.lock(lockPath, LOCK_OPTIONS);
+    } catch (error) {
+      if (error.code === "ELOCKED") {
+        throw new Error(
+          `Lock acquisition timeout after ${LOCK_TIMEOUT_MS}ms. Another Poetic process may be initializing.`,
+          { cause: error }
+        );
+      }
+      throw error;
+    }
+    return await fn();
+  } finally {
+    if (release) {
+      try {
+        await release();
+      } catch (error) {
+        console.warn(
+          "[Init] Failed to release lock:",
+          error instanceof Error ? error.message : String(error)
+        );
+      }
+    }
+  }
+}
+async function ensureBaseDirectory(poeticDir, result, log) {
+  try {
+    if (!fs.existsSync(poeticDir)) {
+      fs.mkdirSync(poeticDir, { recursive: true });
+      result.actions.created.push(poeticDir);
+      log(`Created: ${poeticDir}`);
+    } else {
+      result.actions.skipped.push(poeticDir);
+    }
+  } catch (error) {
+    const errorCode = determineErrorCode(error);
+    result.status = "failed";
+    result.errors.push({
+      code: errorCode,
+      message: `Failed to create base directory: ${error instanceof Error ? error.message : String(error)}`,
+      cause: error,
+      path: poeticDir
+    });
+    throw error;
+  }
+}
+async function ensureDirectories(poeticDir, tier, result, log, allowDegraded = true) {
+  const directories = [...RuntimeRequirements.directories];
+  if (tier === "full") {
+    directories.push(...FullRequirements.directories);
+  }
+  for (const dir of directories) {
+    const fullPath = path.join(poeticDir, dir);
+    try {
+      if (!fs.existsSync(fullPath)) {
+        fs.mkdirSync(fullPath, { recursive: true });
+        result.actions.created.push(fullPath);
+        log(`Created: ${fullPath}`);
+      } else {
+        result.actions.skipped.push(fullPath);
+      }
+    } catch (error) {
+      const errorCode = determineErrorCode(error);
+      result.warnings.push(
+        `Failed to create directory ${fullPath}: ${error instanceof Error ? error.message : String(error)}`
+      );
+      if (dir.includes("telemetry") || dir.includes("config") || dir.includes("cache") || dir.includes("state") || dir.includes("worktrees")) {
+        result.errors.push({
+          code: errorCode,
+          message: `Failed to create critical directory: ${fullPath}`,
+          cause: error,
+          path: fullPath
+        });
+        if (allowDegraded) {
+          result.status = "degraded";
+        } else {
+          result.status = "failed";
+          throw error instanceof Error ? error : new Error(String(error));
+        }
+      }
+    }
+  }
+}
+async function ensureExternalDataDirectories(repoRoot, poeticDir, result, log) {
+  const globalTelemetryDir = getGlobalTelemetryDir();
+  const projectDataDir = getProjectDataDir(repoRoot);
+  const externalDirs = [
+    globalTelemetryDir,
+    path.join(globalTelemetryDir, "db"),
+    path.join(globalTelemetryDir, "logs"),
+    projectDataDir,
+    path.join(projectDataDir, "state"),
+    path.join(projectDataDir, "provider-history"),
+    path.join(projectDataDir, "labs"),
+    path.join(projectDataDir, "backups"),
+    path.join(projectDataDir, "lifecycle"),
+    path.join(projectDataDir, "cache")
+  ];
+  for (const dir of externalDirs) {
+    try {
+      if (!fs.existsSync(dir)) {
+        fs.mkdirSync(dir, { recursive: true, mode: 448 });
+        result.actions.created.push(dir);
+        log(`Created external data dir: ${dir}`);
+      }
+    } catch (error) {
+      result.warnings.push(
+        `Failed to create external data directory ${dir}: ${error instanceof Error ? error.message : String(error)}`
+      );
+    }
+  }
+  await warnIfDataMigrationPending(poeticDir, result);
+}
+async function warnIfDataMigrationPending(poeticDir, result) {
+  if (isDataMigrationComplete(poeticDir)) {
+    return;
+  }
+  try {
+    if (!await hasMigratableRepoLocalData(poeticDir)) {
+      return;
+    }
+  } catch {
+    return;
+  }
+  result.warnings.push(
+    "Legacy telemetry data detected in .poetic/. Run `poetic data migrate preview` then `poetic data migrate execute` to externalize non-reproducible data."
+  );
+}
+async function initializeDatabases(poeticDir, result, log, allowDegraded) {
+  const dbDir = path.join(poeticDir, "telemetry", "db");
+  try {
+    if (!fs.existsSync(dbDir)) {
+      fs.mkdirSync(dbDir, { recursive: true });
+      result.actions.created.push(dbDir);
+    }
+    const progressReporter = (message) => log(message);
+    const db = new TelemetryDatabase(dbDir, progressReporter);
+    log("Initializing database schema");
+    db.init();
+    const health = db.getHealth();
+    log(`Database health: ${JSON.stringify(health)}`);
+    if (!health.available) {
+      throw new Error(health.lastInitError || "Database initialization failed");
+    }
+    const variantsDb = db.getVariantsDb();
+    if (variantsDb) {
+      const currentVersion = checkSchemaVersion(variantsDb);
+      result.schemaVersion = currentVersion;
+      if (currentVersion !== SCHEMA_VERSION) {
+        result.warnings.push(
+          `Schema version mismatch: expected ${SCHEMA_VERSION}, got ${currentVersion}`
+        );
+      } else {
+        log(`Schema version: ${currentVersion}`);
+      }
+    }
+    db.close();
+    result.telemetryMode = "database";
+  } catch (error) {
+    const errorCode = determineErrorCode(error);
+    const errorMessage = error instanceof Error ? error.message : String(error);
+    log(`Database initialization failed: ${errorMessage}`);
+    result.errors.push({
+      code: errorCode,
+      message: `Database initialization failed: ${errorMessage}`,
+      cause: error,
+      path: dbDir
+    });
+    if (allowDegraded) {
+      result.status = "degraded";
+      result.telemetryMode = "jsonl-only";
+      result.warnings.push("Operating in JSONL-only mode (database unavailable)");
+      log("Entering degraded mode (JSONL-only)");
+    } else {
+      result.status = "failed";
+      throw error;
+    }
+  }
+}
+async function ensureConfigStubs(poeticDir, tier, result, log, fullTemplateExcludes = []) {
+  for (const relPath of RuntimeRequirements.configFiles) {
+    const destPath = path.join(poeticDir, relPath);
+    if (fs.existsSync(destPath)) {
+      result.actions.skipped.push(destPath);
+      if (relPath === ".gitignore") {
+        ensurePoeticGitignoreRuntimeEntries(poeticDir, result, log);
+      }
+      continue;
+    }
+    const sourcePath = path.join(TEMPLATE_POETIC_DIR, templateSourceRelPath(relPath));
+    if (!fs.existsSync(sourcePath)) {
+      const message = `Missing embedded template: ${sourcePath}`;
+      result.warnings.push(message);
+      continue;
+    }
+    try {
+      fs.mkdirSync(path.dirname(destPath), { recursive: true });
+      fs.copyFileSync(sourcePath, destPath);
+      if (relPath === ".gitignore") {
+        ensurePoeticGitignoreRuntimeEntries(poeticDir, result, log);
+      }
+      result.actions.created.push(destPath);
+      log(`Created: ${destPath}`);
+    } catch (error) {
+      const errorMessage = error instanceof Error ? error.message : String(error);
+      const message = `Failed to copy template ${relPath}: ${errorMessage}`;
+      result.warnings.push(message);
+    }
+  }
+  if (tier === "full") {
+    await ensureTemplateTree(poeticDir, result, log, [
+      .../* @__PURE__ */ new Set([...fullTemplateExcludes, "config/providers.yaml"])
+    ]);
+  }
+}
+async function ensureTemplateTree(poeticDir, result, log, fullTemplateExcludes = []) {
+  if (!fs.existsSync(TEMPLATE_POETIC_DIR)) {
+    const message = `Templates directory not found: ${TEMPLATE_POETIC_DIR}`;
+    result.status = "failed";
+    result.errors.push({
+      code: "TEMPLATE_COPY_FAILED" /* TEMPLATE_COPY_FAILED */,
+      message,
+      path: TEMPLATE_POETIC_DIR
+    });
+    throw new Error(message);
+  }
+  const copyMissing = (sourcePath, relPath) => {
+    if (isExcludedTemplatePath(relPath, fullTemplateExcludes)) {
+      return;
+    }
+    const destPath = path.join(poeticDir, relPath);
+    if (fs.existsSync(destPath)) {
+      result.actions.skipped.push(destPath);
+      return;
+    }
+    fs.mkdirSync(path.dirname(destPath), { recursive: true });
+    fs.copyFileSync(sourcePath, destPath);
+    result.actions.created.push(destPath);
+    log(`Created: ${destPath}`);
+  };
+  const walk = (dir, relBase) => {
+    for (const entry of fs.readdirSync(dir, { withFileTypes: true })) {
+      const entrySourcePath = path.join(dir, entry.name);
+      const entryRelPath = relBase ? path.join(relBase, entry.name) : entry.name;
+      if (isExcludedTemplatePath(entryRelPath, fullTemplateExcludes)) {
+        continue;
+      }
+      if (entry.isDirectory()) {
+        const destDir = path.join(poeticDir, entryRelPath);
+        if (!fs.existsSync(destDir)) {
+          fs.mkdirSync(destDir, { recursive: true });
+          result.actions.created.push(destDir);
+          log(`Created: ${destDir}`);
+        } else {
+          result.actions.skipped.push(destDir);
+        }
+        walk(entrySourcePath, entryRelPath);
+        continue;
+      }
+      if (entry.isFile()) {
+        copyMissing(entrySourcePath, templateDestRelPath(entryRelPath));
+      }
+    }
+  };
+  try {
+    walk(TEMPLATE_POETIC_DIR, "");
+  } catch (error) {
+    const errorMessage = error instanceof Error ? error.message : String(error);
+    result.status = "failed";
+    result.errors.push({
+      code: "TEMPLATE_COPY_FAILED" /* TEMPLATE_COPY_FAILED */,
+      message: `Failed to copy templates: ${errorMessage}`,
+      cause: error,
+      path: TEMPLATE_POETIC_DIR
+    });
+    throw error;
+  }
+}
+function isExcludedTemplatePath(relPath, excludedPrefixes) {
+  if (excludedPrefixes.length === 0) return false;
+  const normalizedRelPath = path.normalize(relPath);
+  return excludedPrefixes.some((prefix) => {
+    const normalizedPrefix = path.normalize(prefix);
+    return normalizedRelPath === normalizedPrefix || normalizedRelPath.startsWith(normalizedPrefix + path.sep);
+  });
+}
+async function writeStateMarker(poeticDir, tier, result, log, shouldUpdate, context = { materialChanges: false, schemaNeedsHealing: false }) {
+  const stateFile = path.join(poeticDir, RuntimeRequirements.stateFile);
+  try {
+    const existingState = readInitializationState(stateFile);
+    const stateFileExists = fs.existsSync(stateFile);
+    if (stateFileExists && !shouldUpdate) {
+      result.actions.skipped.push(stateFile);
+      return;
+    }
+    const version = readPackageVersion();
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    const effectiveTier = maxTier(existingState?.tier ?? tier, tier);
+    const state = {
+      version,
+      tier: effectiveTier,
+      initializedAt: existingState?.initializedAt ?? now,
+      lastCheckedAt: now,
+      schemaVersion: result.schemaVersion ?? existingState?.schemaVersion ?? SCHEMA_VERSION,
+      repairHistory: result.actions.repaired.length > 0 ? [
+        ...existingState?.repairHistory ?? [],
+        {
+          timestamp: now,
+          repairs: result.actions.repaired
+        }
+      ] : existingState?.repairHistory
+    };
+    fs.mkdirSync(path.dirname(stateFile), { recursive: true });
+    fs.writeFileSync(stateFile, `${JSON.stringify(state, null, 2)}
+`);
+    if (!stateFileExists) {
+      result.actions.created.push(stateFile);
+    } else if (context.materialChanges || context.schemaNeedsHealing) {
+      result.actions.repaired.push(stateFile);
+    }
+    log(`Updated state marker: ${stateFile}`);
+  } catch (error) {
+    result.warnings.push(
+      `Failed to write state marker: ${error instanceof Error ? error.message : String(error)}`
+    );
+    log(
+      `Warning: Could not write state marker: ${error instanceof Error ? error.message : String(error)}`
+    );
+  }
+}
+function readPackageVersion() {
+  try {
+    const pkgPath = path.join(PACKAGE_ROOT, "package.json");
+    if (!fs.existsSync(pkgPath)) return "0.0.0";
+    const pkg = JSON.parse(fs.readFileSync(pkgPath, "utf-8"));
+    return typeof pkg.version === "string" && pkg.version.trim() ? pkg.version.trim() : "0.0.0";
+  } catch {
+    return "0.0.0";
+  }
+}
+function readInitializationState(stateFilePath) {
+  try {
+    if (!fs.existsSync(stateFilePath)) return null;
+    const raw = fs.readFileSync(stateFilePath, "utf-8");
+    return JSON.parse(raw);
+  } catch {
+    return null;
+  }
+}
+function tierRank(tier) {
+  return tier === "full" ? 2 : 1;
+}
+function isTierSufficient(actual, required) {
+  return tierRank(actual) >= tierRank(required);
+}
+function maxTier(a, b) {
+  return tierRank(a) >= tierRank(b) ? a : b;
+}
+function areDatabasesOpenable(poeticDir) {
+  for (const rel of RuntimeRequirements.databases) {
+    const dbPath = path.join(poeticDir, rel);
+    if (!fs.existsSync(dbPath)) return false;
+    let db;
+    try {
+      db = new Database(dbPath, { readonly: true, fileMustExist: true });
+      db.prepare("SELECT 1").get();
+    } catch {
+      return false;
+    } finally {
+      try {
+        db?.close();
+      } catch {
+      }
+    }
+  }
+  return true;
+}
+function finalizeInitializationResult(result, allowDegraded) {
+  if (!allowDegraded && result.status === "degraded") {
+    result.status = "failed";
+    if (result.errors.length === 0) {
+      result.errors.push({
+        code: "UNKNOWN_ERROR" /* UNKNOWN_ERROR */,
+        message: "Initialization completed in degraded mode but allowDegraded=false"
+      });
+    }
+    if (result.nextSteps.length === 0 || result.nextSteps[0]?.includes("degraded")) {
+      result.nextSteps = generateNextSteps(result);
+    }
+  }
+  return result;
+}
+function determineErrorCode(error) {
+  const message = error instanceof Error ? error.message.toLowerCase() : String(error);
+  if (message.includes("locked") || message.includes("busy")) {
+    return "DB_LOCKED" /* DB_LOCKED */;
+  }
+  if (message.includes("corrupt") || message.includes("malformed") || message.includes("integrity")) {
+    return "DB_CORRUPT" /* DB_CORRUPT */;
+  }
+  if (message.includes("permission") || message.includes("eacces") || message.includes("eperm")) {
+    return "PERMISSION_DENIED" /* PERMISSION_DENIED */;
+  }
+  if (message.includes("migration")) {
+    return "MIGRATION_FAILED" /* MIGRATION_FAILED */;
+  }
+  if (message.includes("enospc") || message.includes("disk space")) {
+    return "UNKNOWN_ERROR" /* UNKNOWN_ERROR */;
+  }
+  if (message.includes("timeout") || message.includes("lock acquisition")) {
+    return "DB_LOCKED" /* DB_LOCKED */;
+  }
+  return "UNKNOWN_ERROR" /* UNKNOWN_ERROR */;
+}
+function generateNextSteps(result) {
+  const steps = [];
+  if (result.status === "ok") {
+    steps.push("Poetic is ready to use");
+    return steps;
+  }
+  if (result.status === "degraded") {
+    steps.push(
+      "Poetic is running in degraded mode (JSONL-only telemetry)",
+      "Check database errors above for details"
+    );
+    const hasDbError = result.errors.some(
+      (e) => e.code === "DB_CORRUPT" /* DB_CORRUPT */ || e.code === "DB_LOCKED" /* DB_LOCKED */
+    );
+    if (hasDbError) {
+      steps.push(
+        "Try removing .poetic/telemetry/db/ and restarting",
+        "If issue persists, check file permissions and disk space"
+      );
+    }
+  }
+  if (result.status === "failed") {
+    steps.push("Initialization failed - Poetic cannot run");
+    const hasPermissionError = result.errors.some(
+      (e) => e.code === "PERMISSION_DENIED" /* PERMISSION_DENIED */
+    );
+    if (hasPermissionError) {
+      steps.push(
+        "Check file permissions for .poetic directory",
+        "Ensure you have write access to the project directory"
+      );
+    }
+    const hasCorruptError = result.errors.some((e) => e.code === "DB_CORRUPT" /* DB_CORRUPT */);
+    if (hasCorruptError) {
+      steps.push(
+        "Database appears corrupted",
+        "Remove .poetic/telemetry/db/ and restart",
+        "If you need to preserve data, backup .poetic/ first"
+      );
+    }
+    const hasMigrationError = result.errors.some((e) => e.code === "MIGRATION_FAILED" /* MIGRATION_FAILED */);
+    if (hasMigrationError) {
+      steps.push(
+        "Schema migration failed",
+        "Check that Node.js version is 24.x",
+        "Remove .poetic/telemetry/db/ to reset schema"
+      );
+    }
+  }
+  return steps;
+}
+
+export {
+  RuntimeRequirements,
+  resolveRepoRootForPoeticDir,
+  withProjectInitializationLock,
+  ensurePoeticInitialized,
+  withInitLock
+};
+//# sourceMappingURL=chunk-IRFBN336.js.map