issue-flow 0.17.0 → 0.19.1

package/dist/chunk-J6VJ5M2U.js

@@ -0,0 +1,1201 @@
+#!/usr/bin/env node
+import {
+  writeDiagnostic
+} from "./chunk-7CMVL4X6.js";
+import {
+  MemoryPublisher,
+  getSessionPublisher
+} from "./chunk-DIMDAYZS.js";
+import {
+  bindTelemetry
+} from "./chunk-HEHHQU4G.js";
+import {
+  METADATA_FILENAME,
+  migrateLegacyStorage,
+  resolveStorageMode
+} from "./chunk-LYC57OXF.js";
+import {
+  isoNow
+} from "./chunk-GD7JZMSJ.js";
+import {
+  globalConfigSchema,
+  projectMetadataSchema,
+  providersHealthSchema,
+  storageConfigInputSchema
+} from "./chunk-IMB6FA2F.js";
+import {
+  CURRENT_SCHEMA_VERSION,
+  getDatabasePath,
+  openDatabase,
+  openIssueFlowDatabase,
+  registerPlanRepository,
+  registerProjectDatabaseOptions,
+  registerQueueRepository,
+  registerStorageProjections,
+  resetPlanRepositories,
+  resetProjectDatabaseOptions,
+  writePlanRows
+} from "./chunk-7MJGYPHF.js";
+import {
+  taskPlanSchema
+} from "./chunk-XNK5UN2D.js";
+import {
+  EVENTS_FILENAME,
+  GLOBAL_ROOT_ENV,
+  ISSUES_DIR_NAME,
+  PROVIDERS_HEALTH_FILENAME,
+  QUEUES_DIR_NAME,
+  ROTATED_EVENTS_FILENAME,
+  RUN_LOCK_FILENAME,
+  VERIFY_FILENAME,
+  getGlobalRoot,
+  getIssuePathsAt,
+  getQueuePathsAt
+} from "./chunk-MAJ6QDRL.js";
+import {
+  getProjectRoot
+} from "./chunk-TJVX42KY.js";
+
+// src/core/verbose.ts
+var _verbose = false;
+function setVerbose(enabled) {
+  _verbose = enabled;
+}
+function isVerbose() {
+  return _verbose;
+}
+var _onOutput;
+function setOutputCallback(callback) {
+  _onOutput = callback;
+}
+function getOutputCallback() {
+  return _onOutput;
+}
+var _onStoryUpdate;
+function setStoryUpdateCallback(callback) {
+  _onStoryUpdate = callback;
+}
+function getStoryUpdateCallback() {
+  return _onStoryUpdate;
+}
+var _onStoryStage;
+function setStoryStageCallback(callback) {
+  _onStoryStage = callback;
+}
+function getStoryStageCallback() {
+  return _onStoryStage;
+}
+var _onActivity;
+function setActivityCallback(callback) {
+  _onActivity = callback;
+}
+function getActivityCallback() {
+  return _onActivity;
+}
+var _globalTimeout;
+function setGlobalTimeout(ms) {
+  _globalTimeout = ms;
+}
+function getGlobalTimeout() {
+  return _globalTimeout;
+}
+var _inactivityTimeout;
+function setInactivityTimeout(ms) {
+  _inactivityTimeout = ms;
+}
+function getInactivityTimeout() {
+  return _inactivityTimeout;
+}
+
+// src/ui/logger.ts
+import chalk from "chalk";
+import ora from "ora";
+function useUnicode() {
+  if (process.env.NO_COLOR != null && process.env.NO_COLOR !== "") return false;
+  if (!process.stdout.isTTY) return false;
+  return true;
+}
+function useColor() {
+  if (process.env.NO_COLOR != null && process.env.NO_COLOR !== "") return false;
+  if (!process.stdout.isTTY) return false;
+  return true;
+}
+function getIcons() {
+  if (useUnicode()) {
+    return {
+      success: "\u2713",
+      fail: "\u2717",
+      pending: "\u23F3",
+      retry: "\u21BB",
+      warn: "\u26A0",
+      start: "\u25B6",
+      end: "\u25A0",
+      notReached: "\u25CB",
+      tool: "\u25B8",
+      connector: "\u2502",
+      info: "\xB7"
+    };
+  }
+  return {
+    success: "[OK]",
+    fail: "[FAIL]",
+    pending: "[...]",
+    retry: "[RETRY]",
+    warn: "[WARN]",
+    start: "[START]",
+    end: "[END]",
+    notReached: "[ ]",
+    tool: ">",
+    connector: "|",
+    info: "-"
+  };
+}
+function getTermWidth() {
+  return process.stdout.columns ?? 80;
+}
+function emit(line, level = "info") {
+  getSessionPublisher().publish({ type: "log", at: isoNow(), level, message: line });
+  writeDiagnostic({
+    level: level === "warn" ? "warning" : level,
+    message: line
+  });
+  const cb = getOutputCallback();
+  if (cb) {
+    cb(line);
+  } else {
+    console.log(line);
+  }
+}
+function printSuccess(message) {
+  const icons = getIcons();
+  if (useColor()) {
+    emit(chalk.green(`${icons.success} ${message}`));
+  } else {
+    emit(`${icons.success} ${message}`);
+  }
+}
+function printError(message) {
+  const icons = getIcons();
+  if (useColor()) {
+    emit(chalk.red(`${icons.fail} ${message}`), "error");
+  } else {
+    emit(`${icons.fail} ${message}`, "error");
+  }
+}
+function printWarning(message) {
+  const icons = getIcons();
+  if (useColor()) {
+    emit(chalk.yellow(`${icons.warn} ${message}`), "warn");
+  } else {
+    emit(`${icons.warn} ${message}`, "warn");
+  }
+}
+function printRetry(message) {
+  const icons = getIcons();
+  if (useColor()) {
+    emit(chalk.yellow(`${icons.retry} ${message}`), "warn");
+  } else {
+    emit(`${icons.retry} ${message}`, "warn");
+  }
+}
+function printInfo(message) {
+  const icons = getIcons();
+  if (useColor()) {
+    emit(chalk.blue(`${icons.info} ${message}`));
+  } else {
+    emit(`${icons.info} ${message}`);
+  }
+}
+function createSpinner(message) {
+  return ora({
+    text: message,
+    color: "blue",
+    spinner: "dots"
+  });
+}
+function formatDuration(totalSeconds) {
+  const hours = Math.floor(totalSeconds / 3600);
+  const mins = Math.floor(totalSeconds % 3600 / 60);
+  const secs = totalSeconds % 60;
+  if (hours > 0) {
+    return `${hours}h ${mins}m ${secs}s`;
+  }
+  if (mins > 0) {
+    return `${mins}m ${secs}s`;
+  }
+  return `${secs}s`;
+}
+var ElapsedTimer = class {
+  constructor(onTick) {
+    this.onTick = onTick;
+    this.startTime = Date.now();
+  }
+  onTick;
+  startTime;
+  intervalId = null;
+  cleanup = () => this.stop();
+  start() {
+    this.startTime = Date.now();
+    this.intervalId = setInterval(() => {
+      const seconds = Math.floor((Date.now() - this.startTime) / 1e3);
+      this.onTick(formatDuration(seconds));
+    }, 1e3);
+    if (this.intervalId && typeof this.intervalId === "object" && "unref" in this.intervalId) {
+      this.intervalId.unref();
+    }
+    process.on("exit", this.cleanup);
+    return this;
+  }
+  getElapsedSeconds() {
+    return Math.floor((Date.now() - this.startTime) / 1e3);
+  }
+  stop() {
+    if (this.intervalId) {
+      clearInterval(this.intervalId);
+      this.intervalId = null;
+    }
+    process.removeListener("exit", this.cleanup);
+    return this.getElapsedSeconds();
+  }
+};
+
+// src/config/sources.ts
+import { existsSync } from "node:fs";
+import { readFile } from "node:fs/promises";
+import { dirname, join } from "node:path";
+var PROJECT_CONFIG_FILENAME = ".issue-flow.json";
+function findProjectRootFromCwd(start = process.cwd()) {
+  let dir = start;
+  while (true) {
+    if (existsSync(join(dir, PROJECT_CONFIG_FILENAME)) || existsSync(join(dir, ".git"))) {
+      return dir;
+    }
+    const parent = dirname(dir);
+    if (parent === dir) return void 0;
+    dir = parent;
+  }
+}
+async function readProjectConfigFile(projectRoot, warn) {
+  const root = projectRoot ?? findProjectRootFromCwd();
+  if (root === void 0) {
+    return null;
+  }
+  const filePath = join(root, PROJECT_CONFIG_FILENAME);
+  let raw;
+  try {
+    raw = await readFile(filePath, "utf-8");
+  } catch {
+    return null;
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(raw);
+  } catch {
+    warn(`Ignoring ${PROJECT_CONFIG_FILENAME}: invalid JSON.`);
+    return null;
+  }
+  if (parsed === null || typeof parsed !== "object" || Array.isArray(parsed)) {
+    warn(`Ignoring ${PROJECT_CONFIG_FILENAME}: expected a JSON object.`);
+    return null;
+  }
+  return parsed;
+}
+var GLOBAL_CONFIG_FILENAME = "config.json";
+async function loadGlobalConfig(options = {}) {
+  const warn = options.warn ?? printWarning;
+  let root;
+  try {
+    root = options.globalRoot ?? getGlobalRoot({ env: options.env ?? process.env });
+  } catch (err) {
+    warn(`Ignoring ${GLOBAL_CONFIG_FILENAME}: ${err.message}`);
+    return {};
+  }
+  const filePath = join(root, GLOBAL_CONFIG_FILENAME);
+  let raw;
+  try {
+    raw = await readFile(filePath, "utf-8");
+  } catch (err) {
+    if (err.code !== "ENOENT") {
+      warn(`Ignoring ${GLOBAL_CONFIG_FILENAME}: ${err.message}`);
+    }
+    return {};
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(raw);
+  } catch {
+    warn(`Ignoring ${GLOBAL_CONFIG_FILENAME}: invalid JSON.`);
+    return {};
+  }
+  if (parsed === null || typeof parsed !== "object" || Array.isArray(parsed)) {
+    warn(`Ignoring ${GLOBAL_CONFIG_FILENAME}: expected a JSON object.`);
+    return {};
+  }
+  const config = {};
+  for (const [key, value] of Object.entries(parsed)) {
+    const result = globalConfigSchema.safeParse({ [key]: value });
+    if (!result.success) {
+      warn(
+        `Ignoring "${key}" key of ${GLOBAL_CONFIG_FILENAME}: ${result.error.issues[0]?.message ?? "invalid value"}.`
+      );
+      continue;
+    }
+    Object.assign(config, result.data);
+  }
+  return config;
+}
+
+// src/core/journal.ts
+import { appendFile, mkdir, rename, stat, unlink } from "node:fs/promises";
+import { dirname as dirname2 } from "node:path";
+var DEFAULT_JOURNAL_MAX_BYTES = 0;
+var JournalPublisher = class extends MemoryPublisher {
+  filePath;
+  rotatedPath;
+  maxFileBytes;
+  seq = 0;
+  writeChain = Promise.resolve();
+  closed = false;
+  /** Bytes in the current file. `null` until the first write measures it. */
+  bytes = null;
+  constructor(filePath, rotatedPath, options = {}) {
+    super(options);
+    this.filePath = filePath;
+    this.rotatedPath = rotatedPath;
+    this.maxFileBytes = options.maxFileBytes ?? DEFAULT_JOURNAL_MAX_BYTES;
+  }
+  afterPublish(event) {
+    if (this.closed) return;
+    this.seq++;
+    const line = `${JSON.stringify({ seq: this.seq, event })}
+`;
+    this.enqueue(line);
+  }
+  enqueue(line) {
+    this.writeChain = this.writeChain.then(async () => {
+      try {
+        await this.appendLine(line);
+      } catch (err) {
+        this.warnOnce(err);
+      }
+    });
+  }
+  async appendLine(line) {
+    const size = Buffer.byteLength(line);
+    if (this.bytes === null) {
+      await mkdir(dirname2(this.filePath), { recursive: true });
+      this.bytes = await currentSize(this.filePath);
+    }
+    if (this.maxFileBytes > 0 && this.bytes > 0 && this.bytes + size > this.maxFileBytes) {
+      await this.rotate();
+    }
+    await appendFile(this.filePath, line, "utf-8");
+    this.bytes += size;
+  }
+  /**
+   * Keep exactly one previous generation only when a caller explicitly asks
+   * for rotation. The default never enters this path, so history is never
+   * discarded without an explicit policy.
+   */
+  async rotate() {
+    try {
+      await unlink(this.rotatedPath);
+    } catch {
+    }
+    await rename(this.filePath, this.rotatedPath);
+    this.bytes = 0;
+  }
+  async flush() {
+    await this.writeChain;
+  }
+  async close() {
+    await this.flush();
+    this.closed = true;
+  }
+};
+async function currentSize(path) {
+  try {
+    return (await stat(path)).size;
+  } catch {
+    return 0;
+  }
+}
+function parseJournal(content) {
+  const entries = [];
+  for (const line of content.split("\n")) {
+    const trimmed = line.trim();
+    if (trimmed === "") continue;
+    let parsed;
+    try {
+      parsed = JSON.parse(trimmed);
+    } catch {
+      continue;
+    }
+    if (!isEntry(parsed)) continue;
+    entries.push(parsed);
+  }
+  return entries;
+}
+function isEntry(value) {
+  if (typeof value !== "object" || value === null) return false;
+  const candidate = value;
+  if (typeof candidate.seq !== "number") return false;
+  const event = candidate.event;
+  return typeof event === "object" && event !== null && typeof event.type === "string";
+}
+var MultiPublisher = class {
+  members;
+  primary;
+  constructor(members) {
+    if (members.length === 0) {
+      throw new Error("MultiPublisher needs at least one member");
+    }
+    this.members = members;
+    this.primary = members[0];
+  }
+  publish(event) {
+    for (const member of this.members) {
+      member.publish(event);
+    }
+  }
+  snapshot() {
+    return this.primary.snapshot();
+  }
+  version() {
+    return this.primary.version();
+  }
+  async flush() {
+    await Promise.all(this.members.map((member) => member.flush()));
+  }
+  async close() {
+    await Promise.all(this.members.map((member) => member.close()));
+  }
+};
+
+// src/storage/db/import.ts
+import { createHash } from "node:crypto";
+import { existsSync as existsSync2 } from "node:fs";
+import { readdir, readFile as readFile2, rename as rename2 } from "node:fs/promises";
+import { basename, join as join2, relative } from "node:path";
+var EMPTY_COUNTS = {
+  projects: 0,
+  issues: 0,
+  pipelines: 0,
+  stories: 0,
+  executions: 0,
+  events: 0,
+  queues: 0,
+  provider_health: 0,
+  verifications: 0,
+  pull_requests: 0,
+  user_story_numbering: 0
+};
+function digest(content) {
+  return createHash("sha256").update(content).digest("hex");
+}
+function stableId(prefix, value) {
+  return `${prefix}-${digest(value).slice(0, 24)}`;
+}
+async function fileIfPresent(path) {
+  try {
+    return await readFile2(path, "utf-8");
+  } catch (error) {
+    if (error.code === "ENOENT") return null;
+    throw error;
+  }
+}
+async function collectArtifacts(projectDir, withEvents) {
+  const artifacts = [];
+  const addJson = async (path, kind, issueId) => {
+    const content = await fileIfPresent(path);
+    if (content === null) return;
+    artifacts.push({
+      path,
+      relativePath: relative(projectDir, path),
+      sha256: digest(content),
+      kind,
+      issueId,
+      value: JSON.parse(content)
+    });
+  };
+  await addJson(join2(projectDir, METADATA_FILENAME), "metadata");
+  await addJson(join2(projectDir, PROVIDERS_HEALTH_FILENAME), "health");
+  const issuesDir = join2(projectDir, ISSUES_DIR_NAME);
+  let issueEntries = [];
+  try {
+    issueEntries = await readdir(issuesDir);
+  } catch (error) {
+    if (error.code !== "ENOENT") throw error;
+  }
+  for (const issueId of issueEntries) {
+    const issueDir = join2(issuesDir, issueId);
+    await addJson(join2(issueDir, "tasks.json"), "tasks", issueId);
+    await addJson(join2(issueDir, VERIFY_FILENAME), "verify", issueId);
+    if (withEvents) {
+      for (const name of [ROTATED_EVENTS_FILENAME, EVENTS_FILENAME]) {
+        const path = join2(issueDir, name);
+        const content = await fileIfPresent(path);
+        if (content !== null) {
+          artifacts.push({
+            path,
+            relativePath: relative(projectDir, path),
+            sha256: digest(content),
+            kind: "events",
+            issueId,
+            value: parseJournal(content)
+          });
+        }
+      }
+    }
+  }
+  const queuesDir = join2(projectDir, QUEUES_DIR_NAME);
+  let queueEntries = [];
+  try {
+    queueEntries = await readdir(queuesDir);
+  } catch (error) {
+    if (error.code !== "ENOENT") throw error;
+  }
+  for (const queueId of queueEntries) {
+    await addJson(join2(queuesDir, queueId, "execution-plan.json"), "queue");
+  }
+  return artifacts;
+}
+function increment(counts, table) {
+  counts[table] = (counts[table] ?? 0) + 1;
+}
+function insertIssue(database, projectId, id, status, title, branchName, timestamp, counts) {
+  database.prepare(
+    `INSERT INTO issues (project_id, id, title, status, branch_name, created_at, updated_at)
+       VALUES (?, ?, ?, ?, ?, ?, ?)
+       ON CONFLICT(project_id, id) DO UPDATE SET
+         title = excluded.title, status = excluded.status, branch_name = excluded.branch_name,
+         updated_at = excluded.updated_at`
+  ).run(projectId, id, title, status, branchName, timestamp, timestamp);
+  increment(counts, "issues");
+}
+function importArtifact(database, artifact, projectId, fallback, counts) {
+  const value = artifact.value;
+  if (artifact.kind === "metadata") {
+    const metadata = projectMetadataSchema.parse(value);
+    database.prepare(
+      `INSERT INTO projects (id, root, remote_url, created_at, updated_at) VALUES (?, ?, ?, ?, ?)
+         ON CONFLICT(id) DO UPDATE SET root = excluded.root, remote_url = excluded.remote_url,
+         updated_at = excluded.updated_at`
+    ).run(projectId, metadata.root, metadata.remoteUrl, metadata.createdAt, metadata.updatedAt);
+    increment(counts, "projects");
+    if (metadata.userStoryNumbering !== void 0) {
+      const decision = metadata.userStoryNumbering;
+      database.prepare(
+        `INSERT INTO user_story_numbering (project_id, next_number, source, issue_id, decided_at, detail)
+           VALUES (?, ?, ?, ?, ?, ?)
+           ON CONFLICT(project_id) DO UPDATE SET next_number = excluded.next_number,
+             source = excluded.source, issue_id = excluded.issue_id, decided_at = excluded.decided_at,
+             detail = excluded.detail`
+      ).run(
+        projectId,
+        decision.nextNumber,
+        decision.source,
+        decision.issueNumber,
+        decision.decidedAt,
+        decision.detail ?? null
+      );
+      increment(counts, "user_story_numbering");
+    }
+    return;
+  }
+  if (artifact.kind === "tasks") {
+    const parsed = taskPlanSchema.safeParse(value);
+    if (!parsed.success) return;
+    const plan = parsed.data;
+    const issueId = artifact.issueId ?? String(plan.issueNumber);
+    writePlanRows(
+      database,
+      {
+        tasksPath: artifact.path,
+        projectId,
+        issueId,
+        projectRoot: fallback.root
+      },
+      plan
+    );
+    increment(counts, "issues");
+    increment(counts, "pipelines");
+    counts.stories += plan.userStories.length;
+    for (const execution of plan.executions ?? []) {
+      const cost = execution.cost.status === "unknown" ? null : execution.cost.amount;
+      database.prepare(
+        `INSERT INTO executions
+           (id, project_id, issue_id, status, started_at, finished_at, duration_ms, cost_status, cost_amount, payload_json)
+           VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+           ON CONFLICT(id) DO UPDATE SET status = excluded.status, finished_at = excluded.finished_at,
+           duration_ms = excluded.duration_ms, cost_status = excluded.cost_status,
+           cost_amount = excluded.cost_amount, payload_json = excluded.payload_json`
+      ).run(
+        execution.id,
+        projectId,
+        issueId,
+        execution.status,
+        execution.startedAt,
+        execution.finishedAt,
+        execution.durationMs,
+        execution.cost.status,
+        cost,
+        JSON.stringify(execution)
+      );
+      increment(counts, "executions");
+    }
+    if (plan.pullRequest !== void 0) {
+      const id = stableId("pr", `${projectId}:${issueId}:${plan.pullRequest.number}`);
+      database.prepare(
+        `INSERT INTO pull_requests (id, project_id, issue_id, number, url, status, created_at)
+           VALUES (?, ?, ?, ?, ?, ?, ?)
+           ON CONFLICT(id) DO UPDATE SET url = excluded.url, status = excluded.status`
+      ).run(
+        id,
+        projectId,
+        issueId,
+        plan.pullRequest.number,
+        plan.pullRequest.url,
+        "created",
+        plan.pullRequest.createdAt
+      );
+      increment(counts, "pull_requests");
+    }
+    return;
+  }
+  if (artifact.kind === "health") {
+    const health = providersHealthSchema.parse(value);
+    for (const [provider, record] of Object.entries(health.providers)) {
+      database.prepare(
+        `INSERT INTO provider_health (project_id, provider, payload_json, updated_at) VALUES (?, ?, ?, ?)
+           ON CONFLICT(project_id, provider) DO UPDATE SET payload_json = excluded.payload_json,
+           updated_at = excluded.updated_at`
+      ).run(projectId, provider, JSON.stringify(record), fallback.timestamp);
+      increment(counts, "provider_health");
+    }
+    return;
+  }
+  if (artifact.kind === "events") {
+    const issueId = artifact.issueId ?? "unknown";
+    const runId = `legacy:${projectId}:${issueId}`;
+    insertIssue(database, projectId, issueId, "imported", null, null, fallback.timestamp, counts);
+    database.prepare(
+      `INSERT INTO runs (id, project_id, issue_id, status, started_at, finished_at, session_id)
+         VALUES (?, ?, ?, 'imported', ?, ?, ?)
+         ON CONFLICT(id) DO NOTHING`
+    ).run(runId, projectId, issueId, fallback.timestamp, fallback.timestamp, runId);
+    let nextSequence = (database.prepare("SELECT COALESCE(MAX(sequence), 0) AS sequence FROM events WHERE run_id = ?").get(runId)?.sequence ?? 0) + 1;
+    for (const [index, entry] of artifact.value.entries()) {
+      const id = stableId("event", `${artifact.relativePath}:${index}`);
+      const event = entry.event;
+      database.prepare(
+        `INSERT INTO events
+           (id, project_id, run_id, occurred_at, kind, payload_json, session_id, sequence)
+           VALUES (?, ?, ?, ?, ?, ?, ?, ?)
+           ON CONFLICT(id) DO UPDATE SET occurred_at = excluded.occurred_at, kind = excluded.kind,
+           payload_json = excluded.payload_json`
+      ).run(
+        id,
+        projectId,
+        runId,
+        event.at ?? fallback.timestamp,
+        event.type,
+        JSON.stringify(entry),
+        runId,
+        nextSequence++
+      );
+      increment(counts, "events");
+    }
+    return;
+  }
+  if (artifact.kind === "verify") {
+    insertIssue(
+      database,
+      projectId,
+      artifact.issueId ?? "unknown",
+      "imported",
+      null,
+      null,
+      fallback.timestamp,
+      counts
+    );
+    const id = stableId("verify", artifact.relativePath);
+    database.prepare(
+      `INSERT INTO verifications (id, project_id, issue_id, status, created_at, payload_json)
+         VALUES (?, ?, ?, ?, ?, ?)
+         ON CONFLICT(id) DO UPDATE SET status = excluded.status, payload_json = excluded.payload_json`
+    ).run(
+      id,
+      projectId,
+      artifact.issueId ?? null,
+      String(value.verdict ?? "unknown"),
+      fallback.timestamp,
+      JSON.stringify(value)
+    );
+    increment(counts, "verifications");
+    return;
+  }
+  const queue = value;
+  database.prepare(
+    `INSERT INTO queues (id, project_id, status, payload_json, created_at, updated_at) VALUES (?, ?, ?, ?, ?, ?)
+       ON CONFLICT(id) DO UPDATE SET status = excluded.status, payload_json = excluded.payload_json,
+       updated_at = excluded.updated_at`
+  ).run(
+    queue.id,
+    projectId,
+    queue.status,
+    JSON.stringify(queue),
+    queue.createdAt,
+    queue.updatedAt
+  );
+  increment(counts, "queues");
+  for (const entry of queue.issues) {
+    insertIssue(database, projectId, entry.id, entry.status, null, null, queue.updatedAt, counts);
+    database.prepare(
+      `INSERT INTO queue_issues (queue_id, project_id, issue_id, position, status) VALUES (?, ?, ?, ?, ?)
+         ON CONFLICT(queue_id, project_id, issue_id) DO UPDATE SET position = excluded.position,
+         status = excluded.status`
+    ).run(queue.id, projectId, entry.id, entry.position, entry.status);
+  }
+  if (queue.pullRequest !== void 0) {
+    const id = stableId("pr", `${projectId}:queue:${queue.id}:${queue.pullRequest.number}`);
+    database.prepare(
+      `INSERT INTO pull_requests (id, project_id, number, url, status, created_at) VALUES (?, ?, ?, ?, ?, ?)
+         ON CONFLICT(id) DO UPDATE SET url = excluded.url, status = excluded.status`
+    ).run(
+      id,
+      projectId,
+      queue.pullRequest.number,
+      queue.pullRequest.url,
+      "created",
+      queue.pullRequest.createdAt
+    );
+    increment(counts, "pull_requests");
+  }
+}
+async function retainBackups(directory, retention) {
+  let names = [];
+  try {
+    names = (await readdir(directory)).filter(
+      (name) => name.startsWith("issue-flow-") && name.endsWith(".db")
+    );
+  } catch {
+    return;
+  }
+  for (const name of names.sort().slice(0, Math.max(0, names.length - retention))) {
+    await import("node:fs/promises").then(
+      ({ unlink: unlink2 }) => unlink2(join2(directory, name)).catch(() => void 0)
+    );
+  }
+}
+function applyRetention(database, projectId, retention) {
+  const trim = (table, limit) => {
+    if (limit === void 0 || limit === 0) return;
+    const timestamp = table === "executions" ? "started_at" : table === "events" ? "occurred_at" : "updated_at";
+    database.prepare(
+      `DELETE FROM ${table} WHERE id IN (
+           SELECT id FROM ${table} WHERE project_id = ?
+           ORDER BY ${timestamp} DESC, rowid DESC LIMIT -1 OFFSET ?
+         )`
+    ).run(projectId, limit);
+  };
+  trim("executions", retention?.executions);
+  trim("events", retention?.events);
+  trim("snapshots", retention?.snapshots);
+}
+var DEFAULT_BACKUP_RETENTION = 5;
+async function prepareDatabase(options) {
+  const path = getDatabasePath(options);
+  if (!existsSync2(path)) return;
+  const raw = await openDatabase(path, options);
+  try {
+    const integrity = raw.integrityCheck();
+    if (integrity !== "ok") {
+      raw.close();
+      const quarantine = `${path}.corrupt-${Date.now()}`;
+      await rename2(path, quarantine);
+      options.onWarning?.(
+        `SQLite integrity check failed; isolated ${path} as ${quarantine} and will re-import preserved JSON artifacts.`
+      );
+      return;
+    }
+    const version = Number(
+      raw.prepare("PRAGMA user_version").get()?.user_version ?? 0
+    );
+    const backupDirectory = join2(getDatabasePath(options).replace(/[/\\][^/\\]+$/, ""), "backups");
+    if (version < CURRENT_SCHEMA_VERSION) {
+      const backup = join2(backupDirectory, `issue-flow-${Date.now()}.db`);
+      raw.backup(backup);
+    }
+    await retainBackups(backupDirectory, options.backupRetention ?? DEFAULT_BACKUP_RETENTION);
+  } finally {
+    try {
+      raw.close();
+    } catch {
+    }
+  }
+}
+async function importProjectArtifacts(options) {
+  const counts = { ...EMPTY_COUNTS };
+  try {
+    await prepareDatabase(options);
+    const database = await openIssueFlowDatabase(options);
+    try {
+      const adopted = database.prepare("SELECT project_id FROM project_imports WHERE project_id = ?").get(options.projectId);
+      const artifacts = (await collectArtifacts(options.projectDir, options.withEvents === true)).filter((artifact) => {
+        if (adopted === void 0) return true;
+        if (options.withEvents === true) return artifact.kind === "events";
+        return artifact.kind === "tasks";
+      });
+      let imported = 0;
+      let skipped = 0;
+      database.transaction(() => {
+        database.prepare(
+          `INSERT INTO projects (id, root, remote_url, created_at, updated_at) VALUES (?, ?, ?, ?, ?)
+             ON CONFLICT(id) DO UPDATE SET root = excluded.root, remote_url = excluded.remote_url,
+             updated_at = excluded.updated_at`
+        ).run(
+          options.projectId,
+          options.projectRoot,
+          options.remoteUrl,
+          (/* @__PURE__ */ new Date()).toISOString(),
+          (/* @__PURE__ */ new Date()).toISOString()
+        );
+        increment(counts, "projects");
+        for (const artifact of artifacts) {
+          const previous = database.prepare("SELECT sha256 FROM migrated_artifacts WHERE source_path = ?").get(artifact.path);
+          const requiresPlanProjection = artifact.kind === "tasks" && taskPlanSchema.safeParse(artifact.value).success && database.prepare("SELECT project FROM pipelines WHERE project_id = ? AND issue_id = ?").get(options.projectId, artifact.issueId ?? "")?.project === null;
+          if (previous?.sha256 === artifact.sha256 && !requiresPlanProjection) {
+            skipped++;
+            continue;
+          }
+          importArtifact(
+            database,
+            artifact,
+            options.projectId,
+            {
+              root: options.projectRoot,
+              remoteUrl: options.remoteUrl,
+              timestamp: (/* @__PURE__ */ new Date()).toISOString()
+            },
+            counts
+          );
+          database.prepare(
+            `INSERT INTO migrated_artifacts (source_path, sha256, migrated_at, table_counts_json)
+               VALUES (?, ?, ?, ?)
+               ON CONFLICT(source_path) DO UPDATE SET sha256 = excluded.sha256,
+               migrated_at = excluded.migrated_at, table_counts_json = excluded.table_counts_json`
+          ).run(artifact.path, artifact.sha256, (/* @__PURE__ */ new Date()).toISOString(), JSON.stringify(counts));
+          imported++;
+        }
+        applyRetention(database, options.projectId, options.retention);
+        database.prepare(
+          `INSERT INTO project_imports (project_id, completed_at) VALUES (?, ?)
+             ON CONFLICT(project_id) DO NOTHING`
+        ).run(options.projectId, (/* @__PURE__ */ new Date()).toISOString());
+      });
+      return { imported, skipped, tableCounts: counts, failed: false };
+    } finally {
+      database.close();
+    }
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    if (message.includes("newer than this Issue Flow supports") || message.includes("SQLite storage requires Node.js")) {
+      throw error;
+    }
+    const path = getDatabasePath(options);
+    if (existsSync2(path)) {
+      const failed = `${path}.failed-${Date.now()}`;
+      try {
+        await rename2(path, failed);
+        options.onWarning?.(
+          `SQLite import failed; preserved the database for diagnosis as ${basename(failed)}. Continuing with the intact JSON storage.`
+        );
+      } catch {
+      }
+    }
+    options.onWarning?.(`SQLite import skipped: ${message}`);
+    return { imported: 0, skipped: 0, tableCounts: counts, failed: true };
+  }
+}
+
+// src/storage/resolve.ts
+import { stat as stat3 } from "node:fs/promises";
+import { basename as basename2, join as join4, resolve } from "node:path";
+
+// src/storage/artifact-storage.ts
+import { readFile as readFile3, stat as stat2, writeFile } from "node:fs/promises";
+import { join as join3 } from "node:path";
+var WORKSPACE_STORAGE_DIR = ".issue-flow";
+var WORKSPACE_IGNORE_BLOCK = [
+  "# Issue Flow operational storage (managed)",
+  "/issues/",
+  "/queues/",
+  "/issue-flow.db",
+  "/issue-flow.db-*",
+  "/run.lock",
+  "/providers.json",
+  "/metadata.json",
+  "/backups/",
+  "/.gitignore"
+].join("\n");
+async function directoryExists(path) {
+  try {
+    return (await stat2(path)).isDirectory();
+  } catch {
+    return false;
+  }
+}
+function selectArtifactStorage(projectRoot, globalRoot, projectId, workspaceSelected) {
+  return workspaceSelected ? { storageMode: "workspace", projectDir: join3(projectRoot, WORKSPACE_STORAGE_DIR) } : { storageMode: "global", projectDir: join3(globalRoot, "projects", projectId) };
+}
+async function ensureWorkspaceStorageIgnored(projectRoot) {
+  const path = join3(projectRoot, WORKSPACE_STORAGE_DIR, ".gitignore");
+  let current = "";
+  try {
+    current = await readFile3(path, "utf8");
+  } catch (error) {
+    if (error.code !== "ENOENT") throw error;
+  }
+  if (WORKSPACE_IGNORE_BLOCK.split("\n").slice(1).every((line) => current.includes(line)))
+    return;
+  const prefix = current.length === 0 ? "" : `${current.trimEnd()}
+
+`;
+  await writeFile(path, `${prefix}${WORKSPACE_IGNORE_BLOCK}
+`, "utf8");
+}
+
+// src/storage/resolve.ts
+async function loadStorageResolutionConfig(projectRoot, options) {
+  const global = await loadGlobalConfig({ env: options.env, warn: options.notice ?? printInfo });
+  const project = await readProjectConfigFile(projectRoot, options.notice ?? printInfo);
+  const parsedProject = storageConfigInputSchema.safeParse(project?.storage);
+  if (!parsedProject.success && project?.storage !== void 0) {
+    (options.notice ?? printInfo)(
+      `Ignoring "storage" key of ${PROJECT_CONFIG_FILENAME}: ${parsedProject.error.issues[0]?.message ?? "invalid value"}.`
+    );
+  }
+  return {
+    driver: parsedProject.success ? parsedProject.data.driver ?? global.storage?.driver ?? "sqlite" : global.storage?.driver ?? "sqlite",
+    backupRetention: (parsedProject.success ? parsedProject.data.backupRetention : void 0) ?? global.storage?.backupRetention,
+    retention: (parsedProject.success ? parsedProject.data.retention : void 0) ?? global.storage?.retention
+  };
+}
+var projectCache = /* @__PURE__ */ new Map();
+var checkedIssues = /* @__PURE__ */ new Set();
+function resetStorageResolutionCache() {
+  projectCache.clear();
+  checkedIssues.clear();
+  resetPlanRepositories();
+  resetProjectDatabaseOptions();
+}
+async function pathExists(path) {
+  try {
+    await stat3(path);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function databaseOptionsFor(projectRoot, storageMode, options) {
+  if (storageMode === "global") return options.env === void 0 ? {} : { env: options.env };
+  return {
+    env: {
+      ...options.env ?? process.env,
+      [GLOBAL_ROOT_ENV]: join4(projectRoot, WORKSPACE_STORAGE_DIR)
+    }
+  };
+}
+function announceMigration(result, notice = printInfo) {
+  if (result.copied.length === 0) return;
+  const count = result.copied.length;
+  const target = join4(result.globalDir, ISSUES_DIR_NAME);
+  notice(`Migrated ${count} file${count === 1 ? "" : "s"} from ${result.legacyDir} to ${target}`);
+  notice(
+    `The legacy directory was not modified or removed \u2014 ${result.legacyDir} is kept as-is, read-only, for compatibility.`
+  );
+}
+async function resolveProject(projectRoot, options) {
+  const status = await resolveStorageMode(projectRoot, options);
+  const storage = await loadStorageResolutionConfig(projectRoot, options);
+  const workspaceIssuesDir = join4(projectRoot, WORKSPACE_STORAGE_DIR, ISSUES_DIR_NAME);
+  const selected = selectArtifactStorage(
+    projectRoot,
+    getGlobalRoot(options),
+    status.projectId,
+    await directoryExists(workspaceIssuesDir)
+  );
+  const { storageMode, projectDir } = selected;
+  const databaseOptions = databaseOptionsFor(projectRoot, storageMode, options);
+  registerProjectDatabaseOptions(status.projectId, databaseOptions);
+  if (storageMode === "workspace") {
+    await ensureWorkspaceStorageIgnored(projectRoot);
+  } else if (status.mode === "needs-migration") {
+    announceMigration(
+      await migrateLegacyStorage(projectRoot, options),
+      options.notice ?? printInfo
+    );
+  }
+  const imported = storage.driver === "sqlite" && !await pathExists(join4(projectDir, RUN_LOCK_FILENAME)) ? await importProjectArtifacts({
+    ...databaseOptions,
+    projectId: status.projectId,
+    projectDir,
+    projectRoot,
+    remoteUrl: status.remoteUrl,
+    ...(storage.retention?.backups ?? storage.backupRetention) === void 0 ? {} : { backupRetention: storage.retention?.backups ?? storage.backupRetention },
+    ...storage.retention === void 0 ? {} : { retention: storage.retention },
+    onWarning: options.notice ?? printInfo
+  }) : null;
+  if (imported !== null && imported.imported > 0) {
+    const counts = Object.entries(imported.tableCounts).filter(([, count]) => count > 0).map(([table, count]) => `${table}: ${count}`).join(", ");
+    (options.notice ?? printInfo)(
+      `Imported ${imported.imported} structured artifact${imported.imported === 1 ? "" : "s"} from ${projectDir} into ${getDatabasePath(databaseOptions)} (${counts || "no rows"}). No source artifacts were removed.`
+    );
+  }
+  return {
+    projectId: status.projectId,
+    legacyDir: status.legacyDir,
+    projectDir,
+    storageMode,
+    databaseOptions,
+    // An import failure is a successful *resolution* through the JSON
+    // compatibility path. Do not subsequently register a SQLite repository,
+    // or telemetry would create a fresh empty database and hide the fallback.
+    driver: imported?.failed === true ? "json" : storage.driver,
+    retention: storage.retention
+  };
+}
+function getProjectResolution(projectRoot, options) {
+  const key = `${getGlobalRoot(options)}::${projectRoot}`;
+  const cached = projectCache.get(key);
+  if (cached) return cached;
+  const pending = resolveProject(projectRoot, options).catch((err) => {
+    projectCache.delete(key);
+    throw err;
+  });
+  projectCache.set(key, pending);
+  return pending;
+}
+async function resolveProjectPaths(options = {}) {
+  const { projectRoot: projectRootOption, ...rootOptions } = options;
+  const projectRoot = resolve(projectRootOption ?? await getProjectRoot());
+  const project = await getProjectResolution(projectRoot, rootOptions);
+  const projectDir = project.projectDir;
+  const providersHealthFile = join4(projectDir, PROVIDERS_HEALTH_FILENAME);
+  if (project.driver === "sqlite") {
+    registerStorageProjections({
+      context: {
+        tasksPath: "",
+        projectId: project.projectId,
+        issueId: "",
+        projectRoot,
+        databaseOptions: project.databaseOptions,
+        retention: project.retention
+      },
+      providersHealthFile
+    });
+  }
+  return {
+    projectId: project.projectId,
+    storageDriver: project.driver,
+    storageMode: project.storageMode,
+    databaseOptions: project.databaseOptions,
+    projectDir,
+    issuesDir: join4(projectDir, ISSUES_DIR_NAME),
+    runLockFile: join4(projectDir, RUN_LOCK_FILENAME),
+    providersHealthFile
+  };
+}
+async function resolveQueuePaths(queueId, options = {}) {
+  const { projectRoot: projectRootOption, ...rootOptions } = options;
+  const projectRoot = resolve(projectRootOption ?? await getProjectRoot());
+  const project = await getProjectResolution(projectRoot, rootOptions);
+  const paths = getQueuePathsAt(project.projectDir, queueId);
+  if (project.driver === "sqlite") {
+    registerQueueRepository({
+      planFile: paths.planFile,
+      projectId: project.projectId,
+      projectRoot,
+      databaseOptions: project.databaseOptions,
+      retention: project.retention
+    });
+  }
+  return paths;
+}
+async function resolveIssuePaths(issueNumber, options = {}) {
+  const { projectRoot: projectRootOption, ...rootOptions } = options;
+  const projectRoot = resolve(projectRootOption ?? await getProjectRoot());
+  const project = await getProjectResolution(projectRoot, rootOptions);
+  const paths = getIssuePathsAt(project.projectDir, issueNumber);
+  if (!checkedIssues.has(paths.issueDir)) {
+    const legacyIssueDir = join4(project.legacyDir, basename2(paths.issueDir));
+    if (project.storageMode === "global" && !await directoryExists(paths.issueDir) && await directoryExists(legacyIssueDir)) {
+      announceMigration(await migrateLegacyStorage(projectRoot, rootOptions));
+    }
+    checkedIssues.add(paths.issueDir);
+  }
+  if (project.driver === "sqlite") {
+    const context = {
+      tasksPath: paths.tasksFile,
+      projectId: project.projectId,
+      issueId: basename2(paths.issueDir),
+      projectRoot,
+      databaseOptions: project.databaseOptions,
+      retention: project.retention
+    };
+    registerPlanRepository(context);
+    registerStorageProjections({
+      context,
+      verifyFile: paths.verifyFile,
+      lastBranchFile: paths.lastBranchFile,
+      providersHealthFile: join4(project.projectDir, PROVIDERS_HEALTH_FILENAME)
+    });
+    bindTelemetry({ tasksPath: paths.tasksFile });
+  } else {
+    bindTelemetry(null);
+  }
+  return paths;
+}
+
+export {
+  setVerbose,
+  isVerbose,
+  setOutputCallback,
+  getOutputCallback,
+  setStoryUpdateCallback,
+  getStoryUpdateCallback,
+  setStoryStageCallback,
+  getStoryStageCallback,
+  setActivityCallback,
+  getActivityCallback,
+  setGlobalTimeout,
+  getGlobalTimeout,
+  setInactivityTimeout,
+  getInactivityTimeout,
+  useUnicode,
+  useColor,
+  getIcons,
+  getTermWidth,
+  printSuccess,
+  printError,
+  printWarning,
+  printRetry,
+  printInfo,
+  createSpinner,
+  formatDuration,
+  ElapsedTimer,
+  PROJECT_CONFIG_FILENAME,
+  readProjectConfigFile,
+  GLOBAL_CONFIG_FILENAME,
+  loadGlobalConfig,
+  JournalPublisher,
+  parseJournal,
+  MultiPublisher,
+  importProjectArtifacts,
+  resetStorageResolutionCache,
+  resolveProjectPaths,
+  resolveQueuePaths,
+  resolveIssuePaths
+};
+//# sourceMappingURL=chunk-J6VJ5M2U.js.map