issue-flow 0.4.3 → 0.5.1

package/dist/chunk-FNLXZXWP.js

@@ -0,0 +1,846 @@
+#!/usr/bin/env node
+
+// src/schemas.ts
+import { z } from "zod";
+var userStorySchema = z.object({
+  id: z.string(),
+  title: z.string(),
+  description: z.string(),
+  acceptanceCriteria: z.array(z.string()),
+  priority: z.number().int().positive(),
+  passes: z.boolean(),
+  notes: z.string()
+});
+var pipelineStateSchema = z.object({
+  analyzeCompleted: z.boolean().optional(),
+  prdCompleted: z.boolean(),
+  jsonCompleted: z.boolean(),
+  executionCompleted: z.boolean(),
+  reviewCompleted: z.boolean(),
+  prCreated: z.boolean()
+});
+var lastErrorSchema = z.object({
+  category: z.string(),
+  message: z.string(),
+  at: z.string()
+});
+var taskPlanSchema = z.object({
+  project: z.string(),
+  issueNumber: z.number().int().positive(),
+  issueUrl: z.string(),
+  branchName: z.string(),
+  noBranch: z.boolean().optional().default(false),
+  description: z.string(),
+  issueStatus: z.enum(["pending", "in_progress", "completed"]),
+  completedAt: z.string().nullable(),
+  lastAttemptAt: z.string().nullable(),
+  lastError: lastErrorSchema.nullable(),
+  correctionCycle: z.number().int().min(0),
+  maxCorrectionCycles: z.number().int().min(0),
+  pipeline: pipelineStateSchema,
+  userStories: z.array(userStorySchema)
+});
+var headlessResultSchema = z.object({
+  success: z.boolean(),
+  result: z.string(),
+  cost: z.object({
+    inputTokens: z.number().optional(),
+    outputTokens: z.number().optional()
+  }).nullable(),
+  error: z.string().nullable()
+});
+var sessionLogEntrySchema = z.object({
+  at: z.string(),
+  level: z.enum(["info", "warn", "error"]),
+  message: z.string()
+});
+var sessionPhaseSchema = z.object({
+  name: z.string(),
+  status: z.enum(["pending", "running", "completed", "failed"]),
+  startedAt: z.string().nullable(),
+  endedAt: z.string().nullable(),
+  durationSeconds: z.number().nullable(),
+  error: z.string().nullable()
+});
+var sessionStorySchema = z.object({
+  id: z.string(),
+  title: z.string(),
+  priority: z.number(),
+  passes: z.boolean(),
+  completedAt: z.string().nullable()
+});
+var sessionSnapshotSchema = z.object({
+  schemaVersion: z.literal(1),
+  sessionId: z.string().nullable(),
+  readOnly: z.literal(true),
+  capabilities: z.array(z.string()),
+  issue: z.object({ number: z.number().nullable(), url: z.string().nullable() }),
+  status: z.enum(["idle", "running", "completed", "failed"]),
+  startedAt: z.string().nullable(),
+  updatedAt: z.string().nullable(),
+  endedAt: z.string().nullable(),
+  elapsedSeconds: z.number().nullable(),
+  estimatedRemainingSeconds: z.number().nullable(),
+  progress: z.object({
+    percent: z.number(),
+    phasesCompleted: z.number(),
+    phasesTotal: z.number(),
+    storiesCompleted: z.number(),
+    storiesTotal: z.number()
+  }),
+  currentPhase: z.string().nullable(),
+  currentActivity: z.object({
+    story: z.string().nullable(),
+    tool: z.string().nullable(),
+    detail: z.string().nullable(),
+    since: z.string()
+  }).nullable(),
+  phases: z.array(sessionPhaseSchema),
+  stories: z.array(sessionStorySchema),
+  execution: z.object({
+    iteration: z.number(),
+    retries: z.number(),
+    correctionCycle: z.number(),
+    maxCorrectionCycles: z.number().nullable()
+  }),
+  git: z.object({
+    branch: z.string().nullable(),
+    baseBranch: z.string().nullable(),
+    commits: z.array(z.object({ hash: z.string(), subject: z.string() }))
+  }),
+  pullRequests: z.array(z.object({ number: z.number(), url: z.string(), title: z.string() })),
+  logs: z.array(sessionLogEntrySchema),
+  errors: z.array(sessionLogEntrySchema),
+  warnings: z.array(sessionLogEntrySchema),
+  lastError: z.object({ message: z.string(), at: z.string() }).nullable(),
+  nextSteps: z.array(z.string()),
+  environment: z.object({ node: z.string(), platform: z.string() }).nullable()
+});
+var webConfigSchema = z.object({
+  enabled: z.boolean().default(false),
+  port: z.number().int().min(1).max(65535).default(3737),
+  host: z.string().min(1).default("127.0.0.1"),
+  refreshSeconds: z.number().positive().default(5),
+  logLimit: z.number().int().positive().default(200),
+  includeLogs: z.boolean().default(true)
+});
+
+// src/core/session-state.ts
+import { rename, writeFile } from "fs/promises";
+import { stripVTControlCharacters } from "util";
+var DEFAULT_LOG_LIMIT = 200;
+var DEFAULT_THROTTLE_MS = 1e3;
+function createInitialSnapshot() {
+  return {
+    schemaVersion: 1,
+    sessionId: null,
+    readOnly: true,
+    capabilities: [],
+    issue: { number: null, url: null },
+    status: "idle",
+    startedAt: null,
+    updatedAt: null,
+    endedAt: null,
+    elapsedSeconds: null,
+    estimatedRemainingSeconds: null,
+    progress: {
+      percent: 0,
+      phasesCompleted: 0,
+      phasesTotal: 0,
+      storiesCompleted: 0,
+      storiesTotal: 0
+    },
+    currentPhase: null,
+    currentActivity: null,
+    phases: [],
+    stories: [],
+    execution: { iteration: 0, retries: 0, correctionCycle: 0, maxCorrectionCycles: null },
+    git: { branch: null, baseBranch: null, commits: [] },
+    pullRequests: [],
+    logs: [],
+    errors: [],
+    warnings: [],
+    lastError: null,
+    nextSteps: [],
+    environment: null
+  };
+}
+function secondsBetween(from, to) {
+  if (from === null) return null;
+  const fromMs = Date.parse(from);
+  const toMs = Date.parse(to);
+  if (Number.isNaN(fromMs) || Number.isNaN(toMs)) return null;
+  return Math.max(0, Math.round((toMs - fromMs) / 1e3));
+}
+function computePercent(phasesCompleted, phasesTotal) {
+  if (phasesTotal === 0) return 0;
+  return Math.round(phasesCompleted / phasesTotal * 100);
+}
+function estimateRemainingSeconds(snapshot) {
+  const completions = snapshot.stories.map((story) => story.completedAt === null ? Number.NaN : Date.parse(story.completedAt)).filter((ms) => !Number.isNaN(ms)).sort((a, b) => a - b);
+  if (completions.length < 2) return null;
+  const startMs = snapshot.startedAt === null ? Number.NaN : Date.parse(snapshot.startedAt);
+  const boundaries = Number.isNaN(startMs) ? completions : [startMs, ...completions];
+  const durations = [];
+  for (let i = 1; i < boundaries.length; i++) {
+    durations.push(Math.max(0, boundaries[i] - boundaries[i - 1]));
+  }
+  if (durations.length === 0) return null;
+  const averageMs = durations.reduce((sum, d) => sum + d, 0) / durations.length;
+  const pending = snapshot.stories.filter((story) => !story.passes).length;
+  return Math.round(averageMs * pending / 1e3);
+}
+function deriveNextSteps(snapshot) {
+  if (snapshot.status === "completed") return [];
+  return snapshot.phases.filter((phase) => phase.status === "pending").map((phase) => phase.name);
+}
+function reduceSessionEvent(snapshot, event, options) {
+  const next = applyEvent(snapshot, event, options);
+  if (next === snapshot) return snapshot;
+  const elapsedSeconds = secondsBetween(next.startedAt, event.at) ?? next.elapsedSeconds;
+  return {
+    ...next,
+    updatedAt: event.at,
+    elapsedSeconds,
+    estimatedRemainingSeconds: estimateRemainingSeconds(next),
+    errors: next.logs.filter((entry) => entry.level === "error"),
+    warnings: next.logs.filter((entry) => entry.level === "warn"),
+    nextSteps: deriveNextSteps(next)
+  };
+}
+function applyEvent(snapshot, event, options) {
+  switch (event.type) {
+    case "session:start": {
+      const initial = createInitialSnapshot();
+      return {
+        ...initial,
+        sessionId: event.sessionId,
+        issue: { number: event.issueNumber, url: event.issueUrl ?? null },
+        status: "running",
+        startedAt: event.at,
+        progress: {
+          ...initial.progress,
+          phasesTotal: event.phases.length
+        },
+        phases: event.phases.map((name) => ({
+          name,
+          status: "pending",
+          startedAt: null,
+          endedAt: null,
+          durationSeconds: null,
+          error: null
+        })),
+        git: { branch: event.branch ?? null, baseBranch: event.baseBranch ?? null, commits: [] },
+        environment: event.environment ?? null
+      };
+    }
+    case "phase:start": {
+      const known = snapshot.phases.some((p) => p.name === event.phase);
+      const phases = known ? snapshot.phases.map(
+        (p) => p.name === event.phase ? {
+          ...p,
+          status: "running",
+          startedAt: event.at,
+          endedAt: null,
+          error: null
+        } : p
+      ) : [
+        ...snapshot.phases,
+        {
+          name: event.phase,
+          status: "running",
+          startedAt: event.at,
+          endedAt: null,
+          durationSeconds: null,
+          error: null
+        }
+      ];
+      return {
+        ...snapshot,
+        currentPhase: event.phase,
+        phases,
+        progress: known ? snapshot.progress : { ...snapshot.progress, phasesTotal: phases.length }
+      };
+    }
+    case "phase:end": {
+      const phases = snapshot.phases.map(
+        (p) => p.name === event.phase ? {
+          ...p,
+          status: event.success ? "completed" : "failed",
+          endedAt: event.at,
+          durationSeconds: secondsBetween(p.startedAt, event.at),
+          error: event.error ? stripVTControlCharacters(event.error) : null
+        } : p
+      );
+      const phasesCompleted = phases.filter((p) => p.status === "completed").length;
+      return {
+        ...snapshot,
+        currentPhase: snapshot.currentPhase === event.phase ? null : snapshot.currentPhase,
+        currentActivity: null,
+        phases,
+        progress: {
+          ...snapshot.progress,
+          phasesCompleted,
+          percent: computePercent(phasesCompleted, snapshot.progress.phasesTotal)
+        }
+      };
+    }
+    case "iteration:start":
+      return {
+        ...snapshot,
+        execution: { ...snapshot.execution, iteration: event.iteration }
+      };
+    case "iteration:end":
+      return { ...snapshot, currentActivity: null };
+    case "retry":
+      return {
+        ...snapshot,
+        execution: { ...snapshot.execution, retries: snapshot.execution.retries + 1 }
+      };
+    case "stories:update": {
+      const previous = new Map(snapshot.stories.map((story) => [story.id, story]));
+      const stories = event.stories.map((story) => {
+        const before = previous.get(story.id);
+        const completedAt = !story.passes ? null : before && !before.passes ? event.at : before?.completedAt ?? null;
+        return {
+          id: story.id,
+          title: story.title,
+          priority: story.priority,
+          passes: story.passes,
+          completedAt
+        };
+      });
+      return {
+        ...snapshot,
+        stories,
+        progress: {
+          ...snapshot.progress,
+          storiesCompleted: stories.filter((s) => s.passes).length,
+          storiesTotal: stories.length
+        }
+      };
+    }
+    case "activity": {
+      const story = event.story ?? null;
+      const tool = event.tool ?? null;
+      const detail = event.detail ?? null;
+      const current = snapshot.currentActivity;
+      const since = current && current.story === story && current.tool === tool && current.detail === detail ? current.since : event.at;
+      return { ...snapshot, currentActivity: { story, tool, detail, since } };
+    }
+    case "log": {
+      const limit = options?.logLimit ?? DEFAULT_LOG_LIMIT;
+      const entry = {
+        at: event.at,
+        level: event.level,
+        message: stripVTControlCharacters(event.message)
+      };
+      const logs = [...snapshot.logs, entry].slice(-Math.max(1, limit));
+      return { ...snapshot, logs };
+    }
+    case "git:update":
+      return {
+        ...snapshot,
+        git: {
+          branch: event.branch ?? snapshot.git.branch,
+          baseBranch: event.baseBranch ?? snapshot.git.baseBranch,
+          commits: event.commits ?? snapshot.git.commits
+        },
+        pullRequests: event.pullRequests ?? snapshot.pullRequests
+      };
+    case "correction:cycle":
+      return {
+        ...snapshot,
+        execution: {
+          ...snapshot.execution,
+          correctionCycle: event.cycle,
+          maxCorrectionCycles: event.maxCycles
+        }
+      };
+    case "session:end":
+      return {
+        ...snapshot,
+        status: event.status,
+        endedAt: event.at,
+        currentPhase: null,
+        currentActivity: null,
+        lastError: event.error ? { message: stripVTControlCharacters(event.error), at: event.at } : snapshot.lastError
+      };
+    default:
+      return snapshot;
+  }
+}
+var NullPublisher = class {
+  empty = createInitialSnapshot();
+  publish(_event) {
+  }
+  snapshot() {
+    return this.empty;
+  }
+  version() {
+    return 0;
+  }
+  async flush() {
+  }
+  async close() {
+  }
+};
+var MemoryPublisher = class {
+  state = createInitialSnapshot();
+  versionCounter = 0;
+  warned = false;
+  onWarn;
+  reducerOptions;
+  includeLogs;
+  constructor(options = {}) {
+    this.onWarn = options.onWarn ?? ((message) => process.stderr.write(`${message}
+`));
+    this.reducerOptions = { logLimit: options.logLimit };
+    this.includeLogs = options.includeLogs ?? true;
+  }
+  publish(event) {
+    if (event.type === "log" && !this.includeLogs) return;
+    try {
+      this.state = reduceSessionEvent(this.state, event, this.reducerOptions);
+      this.versionCounter++;
+      this.afterPublish(event);
+    } catch (err) {
+      this.warnOnce(err);
+    }
+  }
+  /** Hook for subclasses; runs inside publish()'s try/catch. */
+  afterPublish(_event) {
+  }
+  snapshot() {
+    return this.state;
+  }
+  version() {
+    return this.versionCounter;
+  }
+  async flush() {
+  }
+  async close() {
+  }
+  warnOnce(err) {
+    if (this.warned) return;
+    this.warned = true;
+    const message = err instanceof Error ? err.message : String(err);
+    try {
+      this.onWarn(`issue-flow: web monitoring disabled itself after an error: ${message}`);
+    } catch {
+    }
+  }
+};
+var FilePublisher = class extends MemoryPublisher {
+  filePath;
+  throttleMs;
+  timer = null;
+  lastWriteStartedAt = 0;
+  lastWrittenVersion = 0;
+  writeChain = Promise.resolve();
+  closed = false;
+  constructor(filePath, options = {}) {
+    super(options);
+    this.filePath = filePath;
+    this.throttleMs = options.throttleMs ?? DEFAULT_THROTTLE_MS;
+  }
+  afterPublish(event) {
+    if (this.closed) return;
+    const terminal = event.type === "phase:end" || event.type === "session:end";
+    this.scheduleWrite(terminal);
+  }
+  scheduleWrite(force) {
+    if (force) {
+      if (this.timer !== null) {
+        clearTimeout(this.timer);
+        this.timer = null;
+      }
+      this.enqueueWrite();
+      return;
+    }
+    if (this.timer !== null) return;
+    const wait = Math.max(0, this.throttleMs - (Date.now() - this.lastWriteStartedAt));
+    if (wait === 0) {
+      this.enqueueWrite();
+      return;
+    }
+    this.timer = setTimeout(() => {
+      this.timer = null;
+      this.enqueueWrite();
+    }, wait);
+    this.timer.unref();
+  }
+  enqueueWrite() {
+    this.lastWriteStartedAt = Date.now();
+    this.writeChain = this.writeChain.then(async () => {
+      const version = this.versionCounter;
+      if (version === this.lastWrittenVersion) return;
+      const payload = `${JSON.stringify(this.state, null, 2)}
+`;
+      try {
+        await atomicWriteFile(this.filePath, payload);
+        this.lastWrittenVersion = version;
+      } catch (err) {
+        this.warnOnce(err);
+      }
+    });
+  }
+  async flush() {
+    if (this.timer !== null) {
+      clearTimeout(this.timer);
+      this.timer = null;
+    }
+    if (this.versionCounter !== this.lastWrittenVersion) {
+      this.enqueueWrite();
+    }
+    await this.writeChain;
+  }
+  async close() {
+    await this.flush();
+    this.closed = true;
+  }
+};
+async function atomicWriteFile(path, content) {
+  const tmpFile = `${path}.tmp`;
+  await writeFile(tmpFile, content, "utf-8");
+  await rename(tmpFile, path);
+}
+
+// src/core/session-publisher.ts
+var NULL_PUBLISHER = new NullPublisher();
+var _publisher = NULL_PUBLISHER;
+function setSessionPublisher(publisher) {
+  _publisher = publisher ?? NULL_PUBLISHER;
+}
+function getSessionPublisher() {
+  return _publisher;
+}
+
+// src/core/state-manager.ts
+import { copyFile, mkdtemp, readFile, rename as rename2, unlink, writeFile as writeFile2 } from "fs/promises";
+import { tmpdir } from "os";
+import { join } from "path";
+import { ZodError } from "zod";
+function isoNow() {
+  return (/* @__PURE__ */ new Date()).toISOString().replace(/\.\d{3}Z$/, "Z");
+}
+async function loadTaskPlan(path) {
+  const content = await readFile(path, "utf-8");
+  const raw = JSON.parse(content);
+  try {
+    return taskPlanSchema.parse(raw);
+  } catch (err) {
+    if (err instanceof ZodError) {
+      const issues = err.issues.map((i) => `  - ${i.path.join(".")}: ${i.message}`).join("\n");
+      throw new Error(`Invalid tasks.json at ${path}:
+${issues}`);
+    }
+    throw err;
+  }
+}
+async function saveTaskPlan(path, plan) {
+  const tmpDir = await mkdtemp(join(tmpdir(), "issue-flow-task-plan-"));
+  const tmpFile = join(tmpDir, "tasks.json");
+  await writeFile2(tmpFile, `${JSON.stringify(plan, null, 2)}
+`, "utf-8");
+  try {
+    await rename2(tmpFile, path);
+  } catch (err) {
+    if (err.code === "EXDEV") {
+      await copyFile(tmpFile, path);
+      await unlink(tmpFile);
+    } else {
+      throw err;
+    }
+  }
+}
+function initializeState(plan) {
+  const defaultPipeline = {
+    prdCompleted: false,
+    jsonCompleted: false,
+    executionCompleted: false,
+    reviewCompleted: false,
+    prCreated: false
+  };
+  return {
+    ...plan,
+    issueStatus: plan.issueStatus ?? "pending",
+    completedAt: plan.completedAt ?? null,
+    lastAttemptAt: plan.lastAttemptAt ?? null,
+    lastError: plan.lastError ?? null,
+    correctionCycle: plan.correctionCycle ?? 0,
+    maxCorrectionCycles: plan.maxCorrectionCycles ?? 3,
+    pipeline: plan.pipeline ? { ...defaultPipeline, ...plan.pipeline } : defaultPipeline
+  };
+}
+function allStoriesPass(plan) {
+  if (plan.userStories.length === 0) {
+    return false;
+  }
+  return plan.userStories.every((story) => story.passes === true);
+}
+function markIssueInProgress(plan, timestamp) {
+  const ts = timestamp ?? isoNow();
+  return {
+    ...plan,
+    issueStatus: "in_progress",
+    completedAt: null,
+    lastAttemptAt: ts
+  };
+}
+function markIssueCompleted(plan) {
+  const ts = isoNow();
+  return {
+    ...plan,
+    issueStatus: "completed",
+    completedAt: ts,
+    lastAttemptAt: ts,
+    lastError: null,
+    pipeline: plan.pipeline ? { ...plan.pipeline, executionCompleted: true } : plan.pipeline
+  };
+}
+function setLastError(plan, category, message) {
+  const ts = isoNow();
+  const error = {
+    category,
+    message,
+    at: ts
+  };
+  return {
+    ...plan,
+    lastAttemptAt: ts,
+    lastError: error
+  };
+}
+function clearLastError(plan, attemptStartedAt) {
+  const ts = isoNow();
+  if (plan.lastError && plan.lastError.at > attemptStartedAt) {
+    return {
+      ...plan,
+      lastAttemptAt: ts
+    };
+  }
+  return {
+    ...plan,
+    lastAttemptAt: ts,
+    lastError: null
+  };
+}
+function trimErrorMessage(message) {
+  return message.split("\n").filter((line) => line.trim().length > 0).slice(0, 8).join("\n");
+}
+
+// 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 _globalTimeout;
+function setGlobalTimeout(ms) {
+  _globalTimeout = ms;
+}
+function getGlobalTimeout() {
+  return _globalTimeout;
+}
+
+// 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"
+    };
+  }
+  return {
+    success: "[OK]",
+    fail: "[FAIL]",
+    pending: "[...]",
+    retry: "[RETRY]",
+    warn: "[WARN]",
+    start: "[START]",
+    end: "[END]",
+    notReached: "[ ]",
+    tool: ">",
+    connector: "|"
+  };
+}
+function getTermWidth() {
+  return process.stdout.columns ?? 80;
+}
+function emit(line, level = "info") {
+  getSessionPublisher().publish({ type: "log", at: isoNow(), 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.start} ${message}`));
+  } else {
+    emit(`${icons.start} ${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();
+  }
+  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();
+  }
+};
+
+export {
+  taskPlanSchema,
+  webConfigSchema,
+  NullPublisher,
+  FilePublisher,
+  setSessionPublisher,
+  getSessionPublisher,
+  isoNow,
+  loadTaskPlan,
+  saveTaskPlan,
+  initializeState,
+  allStoriesPass,
+  markIssueInProgress,
+  markIssueCompleted,
+  setLastError,
+  clearLastError,
+  trimErrorMessage,
+  setVerbose,
+  isVerbose,
+  setOutputCallback,
+  getOutputCallback,
+  setStoryUpdateCallback,
+  getStoryUpdateCallback,
+  setGlobalTimeout,
+  getGlobalTimeout,
+  useUnicode,
+  useColor,
+  getIcons,
+  getTermWidth,
+  printSuccess,
+  printError,
+  printWarning,
+  printRetry,
+  printInfo,
+  createSpinner,
+  formatDuration,
+  ElapsedTimer
+};
+//# sourceMappingURL=chunk-FNLXZXWP.js.map