daily-focus 0.1.0

package/dist/chunk-6VWWJZKJ.js

@@ -0,0 +1,27 @@
+// src/install.ts
+import { homedir } from "node:os";
+import { resolve, sep } from "node:path";
+import { fileURLToPath } from "node:url";
+var PACKAGED = import.meta.url.endsWith(".js");
+var ROOT = resolve(import.meta.dirname, "..");
+var IN_NPX_CACHE = ROOT.split(sep).includes("_npx");
+function command(name, args = "") {
+  if (PACKAGED) return `daily-focus ${name}${args ? ` ${args}` : ""}`;
+  return `npm run ${name === "build-calendar" ? "build:calendar" : name}${args ? ` -- ${args}` : ""}`;
+}
+function ranDirectly(url) {
+  const file = fileURLToPath(url);
+  return file.endsWith(".ts") && process.argv[1] !== void 0 && resolve(process.argv[1]) === file;
+}
+var APP_CALENDAR_APP = ROOT.includes(`.app${sep}Contents${sep}Resources${sep}`) ? resolve(ROOT, "..", "..", "Helpers", "Daily Focus Calendar.app") : null;
+var USER_CALENDAR_APP = resolve(homedir(), "Library", "Application Support", "Daily Focus", "Daily Focus Calendar.app");
+
+export {
+  PACKAGED,
+  ROOT,
+  IN_NPX_CACHE,
+  command,
+  ranDirectly,
+  APP_CALENDAR_APP,
+  USER_CALENDAR_APP
+};

package/dist/chunk-EXGTFXNV.js

@@ -0,0 +1,77 @@
+// src/time.ts
+var MS_PER_DAY = 864e5;
+function localDateKey(d) {
+  const y = d.getFullYear();
+  const m = String(d.getMonth() + 1).padStart(2, "0");
+  const day = String(d.getDate()).padStart(2, "0");
+  return `${y}-${m}-${day}`;
+}
+var DATE_ONLY = /^(\d{4})-(\d{2})-(\d{2})$/;
+function isDateOnly(value) {
+  return typeof value === "string" && DATE_ONLY.test(value);
+}
+function parseISO(value) {
+  if (typeof value !== "string" || value === "") return null;
+  const dateOnly = DATE_ONLY.exec(value);
+  if (dateOnly) {
+    const [, y, m, d] = dateOnly;
+    return new Date(Number(y), Number(m) - 1, Number(d));
+  }
+  const parsed = new Date(value);
+  return Number.isNaN(parsed.getTime()) ? null : parsed;
+}
+function startOfLocalDay(d) {
+  return new Date(d.getFullYear(), d.getMonth(), d.getDate());
+}
+function calendarDaysBetween(from, to) {
+  const a = startOfLocalDay(from).getTime();
+  const b = startOfLocalDay(to).getTime();
+  return Math.round((b - a) / MS_PER_DAY);
+}
+function isSameLocalDay(d, reference) {
+  return localDateKey(d) === localDateKey(reference);
+}
+function isWorkingDay(d) {
+  const day = d.getDay();
+  return day !== 0 && day !== 6;
+}
+function workingDaysSince(from, to, counts = isWorkingDay) {
+  const cursor = startOfLocalDay(from);
+  const end = startOfLocalDay(to);
+  let count = 0;
+  while (cursor.getTime() < end.getTime()) {
+    cursor.setDate(cursor.getDate() + 1);
+    if (counts(cursor)) count++;
+  }
+  return count;
+}
+function workingMsBetween(from, to, counts = isWorkingDay) {
+  if (to.getTime() <= from.getTime()) return 0;
+  let cursor = from;
+  let total = 0;
+  while (cursor.getTime() < to.getTime()) {
+    const nextMidnight = new Date(cursor.getFullYear(), cursor.getMonth(), cursor.getDate() + 1);
+    const sliceEnd = Math.min(nextMidnight.getTime(), to.getTime());
+    if (counts(cursor)) total += sliceEnd - cursor.getTime();
+    cursor = new Date(sliceEnd);
+  }
+  return total;
+}
+function laterISO(a, b) {
+  if (!b) return a ?? null;
+  if (!a) return b;
+  return b > a ? b : a;
+}
+
+export {
+  localDateKey,
+  isDateOnly,
+  parseISO,
+  startOfLocalDay,
+  calendarDaysBetween,
+  isSameLocalDay,
+  isWorkingDay,
+  workingDaysSince,
+  workingMsBetween,
+  laterISO
+};

package/dist/chunk-G4K24I4M.js

@@ -0,0 +1,425 @@
+import {
+  APP_CALENDAR_APP,
+  USER_CALENDAR_APP
+} from "./chunk-6VWWJZKJ.js";
+import {
+  isSameLocalDay,
+  localDateKey,
+  parseISO,
+  startOfLocalDay
+} from "./chunk-EXGTFXNV.js";
+
+// src/env.ts
+import { readFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { isAbsolute, resolve } from "node:path";
+import { parseEnv } from "node:util";
+var DOTENV_PATH = resolve(import.meta.dirname, "..", ".env");
+var DEFAULT_DATA_DIR = "~/.daily-focus";
+var SETTINGS_FILE = "settings.json";
+var LAUNCH_SETTINGS = ["DAILY_FOCUS_DATA", "DAILY_FOCUS_PORT", "DAILY_FOCUS_HOST"];
+function expandHome(p) {
+  if (p === "~") return homedir();
+  if (p.startsWith("~/")) return resolve(homedir(), p.slice(2));
+  if (!p.includes("/")) return p;
+  return isAbsolute(p) ? p : resolve(process.cwd(), p);
+}
+function readDotEnv(path = DOTENV_PATH) {
+  let text;
+  try {
+    text = readFileSync(path, "utf8");
+  } catch (err) {
+    if (err.code === "ENOENT") return {};
+    throw new Error(`could not read ${path}: ${err.message}`);
+  }
+  const parsed = {};
+  for (const [key, value] of Object.entries(parseEnv(text.replace(/^/, "")))) {
+    if (value !== void 0) parsed[key] = value;
+  }
+  return parsed;
+}
+function readSettingsFile(path) {
+  let text;
+  try {
+    text = readFileSync(path, "utf8");
+  } catch (err) {
+    if (err.code === "ENOENT") return { values: {}, error: null };
+    return { values: {}, error: `could not read ${path}: ${err.message}` };
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(text);
+  } catch (err) {
+    return { values: {}, error: `${path} is not valid JSON: ${err.message}` };
+  }
+  if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) {
+    return { values: {}, error: `${path} should hold an object of settings` };
+  }
+  const values = {};
+  const unreadable = [];
+  for (const [key, value] of Object.entries(parsed)) {
+    if (!key.startsWith("DAILY_FOCUS_") || LAUNCH_SETTINGS.includes(key)) continue;
+    if (typeof value === "string") values[key] = value;
+    else if (typeof value === "number" && Number.isFinite(value) || typeof value === "boolean") values[key] = String(value);
+    else unreadable.push(key);
+  }
+  const error = unreadable.length > 0 ? `${path} has values that aren't text, a number or true/false: ${unreadable.join(", ")}` : null;
+  return { values, error };
+}
+function prefixed(record) {
+  const kept = {};
+  for (const [key, value] of Object.entries(record)) {
+    if (key.startsWith("DAILY_FOCUS_") && value !== void 0) kept[key] = value;
+  }
+  return kept;
+}
+function mergeEnv(fromFile, processEnv = process.env) {
+  return { ...prefixed(fromFile), ...processEnv };
+}
+function envSources(processEnv = process.env, dotenv = readDotEnv()) {
+  const merged = mergeEnv(dotenv, processEnv);
+  const dataDir = expandHome((merged.DAILY_FOCUS_DATA ?? "").trim() || DEFAULT_DATA_DIR);
+  const settingsPath = resolve(dataDir, SETTINGS_FILE);
+  const { values, error } = readSettingsFile(settingsPath);
+  return { dotenv: prefixed(dotenv), settings: values, process: processEnv, settingsPath, settingsError: error };
+}
+function layerEnv(sources, settings = sources.settings) {
+  return { ...sources.dotenv, ...withoutBlanks(settings), ...withoutBlanks(sources.process) };
+}
+function withoutBlanks(record) {
+  const kept = {};
+  for (const [key, value] of Object.entries(record)) {
+    if (value !== void 0 && value.trim() !== "") kept[key] = value;
+  }
+  return kept;
+}
+function loadEnv() {
+  return layerEnv(envSources());
+}
+
+// src/schedule.ts
+var BRIEF_REFRESH_GRACE_HOURS = 45 / 60;
+var MONDAY_TO_FRIDAY = [1, 2, 3, 4, 5];
+var DAY_NAMES = ["Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"];
+function runsOn(schedule, date) {
+  return schedule.days.includes(date.getDay());
+}
+function nextRunDate(schedule, from) {
+  const cursor = startOfLocalDay(from);
+  for (let i = 0; i < 7; i++) {
+    cursor.setDate(cursor.getDate() + 1);
+    if (runsOn(schedule, cursor)) return localDateKey(cursor);
+  }
+  return null;
+}
+function describeSchedule(schedule) {
+  const days = schedule.days;
+  if (days.length === 0) return "never";
+  const contiguous = days.every((day, i) => i === 0 || day === days[i - 1] + 1);
+  return contiguous && days.length > 2 ? `${DAY_NAMES[days[0]]}\u2013${DAY_NAMES[days[days.length - 1]]}` : days.map((day) => DAY_NAMES[day]).join(", ");
+}
+function parseWeekdays(spec) {
+  const days = /* @__PURE__ */ new Set();
+  for (const part of spec.split(",")) {
+    const piece = part.trim();
+    if (piece === "") continue;
+    const range = /^([0-6])\s*-\s*([0-6])$/.exec(piece);
+    if (range) {
+      const from = Number(range[1]);
+      const to = Number(range[2]);
+      if (from > to) {
+        throw new Error(`day range "${piece}" runs backwards; write it as a list, e.g. "6,0"`);
+      }
+      for (let day = from; day <= to; day++) days.add(day);
+      continue;
+    }
+    if (!/^[0-6]$/.test(piece)) {
+      throw new Error(`"${piece}" is not a weekday; use 0\u20136 where 0 is Sunday, e.g. "1-5"`);
+    }
+    days.add(Number(piece));
+  }
+  if (days.size === 0) throw new Error("no weekdays given");
+  return [...days].sort((a, b) => a - b);
+}
+function resolveSchedule(config) {
+  if (config.agentDays) return { days: config.agentDays, source: "config" };
+  return { days: MONDAY_TO_FRIDAY, source: "default" };
+}
+function atTimeOn(date, at) {
+  const when = startOfLocalDay(date);
+  when.setHours(at.hour, at.minute, 0, 0);
+  return when;
+}
+function describeTime(at) {
+  return `${String(at.hour).padStart(2, "0")}:${String(at.minute).padStart(2, "0")}`;
+}
+function scheduledRunDue({ at, schedule, lastRunStartedAt, now }) {
+  if (!runsOn(schedule, now)) return false;
+  if (now.getTime() < atTimeOn(now, at).getTime()) return false;
+  return !ranToday(lastRunStartedAt, now);
+}
+function nextScheduledRun({ at, schedule, lastRunStartedAt, now }) {
+  const today = atTimeOn(now, at);
+  if (runsOn(schedule, now) && now.getTime() < today.getTime() && !ranToday(lastRunStartedAt, now)) {
+    return today;
+  }
+  const next = nextRunDate(schedule, now);
+  if (!next) return null;
+  const date = parseISO(next);
+  return date ? atTimeOn(date, at) : null;
+}
+function ranToday(lastRunStartedAt, now) {
+  const when = parseISO(lastRunStartedAt);
+  return when !== null && isSameLocalDay(when, now);
+}
+
+// src/config.ts
+import { existsSync } from "node:fs";
+import { resolve as resolve2 } from "node:path";
+var PROFILES = ["work", "personal"];
+var CLI_NAMES = ["claude", "codex"];
+function envInt(name, fallback, env) {
+  const raw = env[name];
+  if (raw === void 0 || raw.trim() === "") return fallback;
+  const n = Number(raw);
+  if (!Number.isFinite(n)) {
+    throw new Error(`${name} must be a number, got ${JSON.stringify(raw)}`);
+  }
+  return n;
+}
+function envBounded(name, fallback, min, max, env) {
+  const n = envInt(name, fallback, env);
+  if (!Number.isInteger(n) || n < min || n > max) {
+    throw new Error(`${name} must be a whole number from ${min} to ${max}, got ${JSON.stringify(env[name])}`);
+  }
+  return n;
+}
+function envNameList(name, env) {
+  const raw = env[name];
+  if (raw === void 0) return [];
+  const names = [];
+  for (const entry of raw.split(",")) {
+    const trimmed = entry.trim();
+    if (trimmed !== "" && !names.includes(trimmed)) names.push(trimmed);
+  }
+  return names;
+}
+function envList(name, env) {
+  const raw = env[name];
+  if (raw === void 0) return [];
+  return raw.split(/[\s,]+/).map((entry) => entry.trim()).filter((entry) => entry !== "");
+}
+function parseScope(entries) {
+  const qualifiers = [];
+  for (const entry of entries) {
+    const bare = entry.replace(/^(org|repo|user):/i, "");
+    if (bare === "") continue;
+    const qualifier = bare.includes("/") ? `repo:${bare}` : `org:${bare}`;
+    if (!qualifiers.includes(qualifier)) qualifiers.push(qualifier);
+  }
+  return qualifiers;
+}
+function envFlag(name, fallback, env) {
+  const flag = (env[name] ?? "").trim().toLowerCase();
+  if (flag === "") return fallback;
+  return !["off", "false", "0", "no"].includes(flag);
+}
+function envGitHub(env) {
+  const pollMinutes = envInt("DAILY_FOCUS_GITHUB_POLL_MINUTES", 5, env);
+  if (pollMinutes < 1) {
+    throw new Error(`DAILY_FOCUS_GITHUB_POLL_MINUTES must be at least 1, got ${pollMinutes}`);
+  }
+  return {
+    enabled: envFlag("DAILY_FOCUS_GITHUB", true, env),
+    accounts: envList("DAILY_FOCUS_GITHUB_ACCOUNTS", env),
+    scope: parseScope(envList("DAILY_FOCUS_GITHUB_SCOPE", env)),
+    mergeGateChecks: envNameList("DAILY_FOCUS_GITHUB_MERGE_GATE_CHECKS", env),
+    pollMinutes,
+    ghPath: expandHome((env.DAILY_FOCUS_GH ?? "").trim() || "gh")
+  };
+}
+function envCalendar(env) {
+  const pollMinutes = envInt("DAILY_FOCUS_CALENDAR_POLL_MINUTES", 5, env);
+  if (pollMinutes < 1) {
+    throw new Error(`DAILY_FOCUS_CALENDAR_POLL_MINUTES must be at least 1, got ${pollMinutes}`);
+  }
+  return {
+    enabled: envFlag("DAILY_FOCUS_CALENDAR", true, env),
+    // Commas only, as for merge gate checks: calendar names contain spaces.
+    names: envNameList("DAILY_FOCUS_CALENDARS", env),
+    addresses: envNameList("DAILY_FOCUS_CALENDAR_ADDRESSES", env),
+    pollMinutes,
+    // What the user set, then the helper the Mac app carries, then the one
+    // `daily-focus build-calendar` installs, then a checkout's own build.
+    appPath: expandHome(
+      (env.DAILY_FOCUS_CALENDAR_APP ?? "").trim() || [APP_CALENDAR_APP, USER_CALENDAR_APP].find((path) => path !== null && existsSync(path)) || resolve2(import.meta.dirname, "..", "tools/dfcal/build/Daily Focus Calendar.app")
+    )
+  };
+}
+function envJira(env, profile) {
+  const pollMinutes = envInt("DAILY_FOCUS_JIRA_POLL_MINUTES", 15, env);
+  if (pollMinutes < 1) {
+    throw new Error(`DAILY_FOCUS_JIRA_POLL_MINUTES must be at least 1, got ${pollMinutes}`);
+  }
+  return {
+    enabled: envFlag("DAILY_FOCUS_JIRA", profile === "work", env),
+    projects: envList("DAILY_FOCUS_JIRA_PROJECTS", env),
+    // Commas only, as for merge gate checks and calendars: status names contain
+    // spaces almost by default — "In Review", "Waiting for customer".
+    holdStatuses: envNameList("DAILY_FOCUS_JIRA_HOLD_STATUSES", env),
+    inProgressStatuses: envNameList("DAILY_FOCUS_JIRA_IN_PROGRESS_STATUSES", env),
+    pollMinutes,
+    // Tolerates a pasted URL, since that is what is on screen when someone goes
+    // looking for their site's name.
+    site: envString("DAILY_FOCUS_JIRA_SITE", "", env).replace(/^https?:\/\//i, "").replace(/\/.*$/, "") || null,
+    acliPath: expandHome((env.DAILY_FOCUS_ACLI ?? "").trim() || "acli")
+  };
+}
+function envCli(name, env) {
+  const raw = envString(name, "off", env).toLowerCase();
+  if (["off", "false", "0", "no", "none"].includes(raw)) return null;
+  if (!CLI_NAMES.includes(raw)) {
+    throw new Error(`${name} must be off or one of ${CLI_NAMES.join(", ")}, got ${JSON.stringify(raw)}`);
+  }
+  return raw;
+}
+function envAssistant(env) {
+  const agent = envCli("DAILY_FOCUS_ASSISTANT", env);
+  const tools = envNameList("DAILY_FOCUS_ASSISTANT_TOOLS", env);
+  return {
+    agent,
+    binPath: expandHome((env.DAILY_FOCUS_ASSISTANT_BIN ?? "").trim() || (agent ?? "claude")),
+    model: envString("DAILY_FOCUS_ASSISTANT_MODEL", "", env) || null,
+    effort: envString("DAILY_FOCUS_ASSISTANT_EFFORT", "", env) || null,
+    tools: tools.length > 0 ? tools : DEFAULT_ASSISTANT_TOOLS
+  };
+}
+var DEFAULT_ASSISTANT_TOOLS = ["Bash(gh *)", "Bash(acli *)", "WebFetch", "mcp__claude_ai_Gmail"];
+var DEFAULT_AGENT_TOOLS = ["Bash(gh *)", "Bash(acli *)", "WebFetch", "mcp__claude_ai_Gmail"];
+function briefWritingTools() {
+  const repo = resolve2(import.meta.dirname, "..");
+  return [
+    // `//` anchors a rule at the filesystem root; the path supplies one slash.
+    `Read(/${repo}/prompts/**)`,
+    `Read(/${repo}/schema/**)`,
+    "Write(./items.json)",
+    "Write(./items.json.*)",
+    "Edit(./items.json.*)",
+    "Bash(mv items.json.* items.json)"
+  ];
+}
+var DEFAULT_AGENT_AT = { hour: 7, minute: 0 };
+function envAgent(env) {
+  const cli = envCli("DAILY_FOCUS_AGENT", env);
+  const at = envTimeOfDay("DAILY_FOCUS_AGENT_AT", env);
+  if (at && !cli && envString("DAILY_FOCUS_AGENT_AT", "", env) !== "") {
+    throw new Error("DAILY_FOCUS_AGENT_AT needs DAILY_FOCUS_AGENT set to codex or claude");
+  }
+  const tools = envNameList("DAILY_FOCUS_AGENT_TOOLS", env);
+  return {
+    cli,
+    at: cli ? at : null,
+    binPath: expandHome((env.DAILY_FOCUS_AGENT_BIN ?? "").trim() || (cli ?? "codex")),
+    model: envString("DAILY_FOCUS_AGENT_MODEL", "", env) || null,
+    effort: envString("DAILY_FOCUS_AGENT_EFFORT", "", env) || null,
+    tools: tools.length > 0 ? tools : DEFAULT_AGENT_TOOLS
+  };
+}
+function envTimeOfDay(name, env) {
+  const raw = envString(name, "", env).toLowerCase();
+  if (raw === "") return DEFAULT_AGENT_AT;
+  if (["off", "false", "0", "no", "none", "never"].includes(raw)) return null;
+  const match = /^([01]?\d|2[0-3]):([0-5]\d)$/.exec(raw);
+  if (!match) throw new Error(`${name} must be a 24-hour time such as 06:30, or off, got ${JSON.stringify(raw)}`);
+  return { hour: Number(match[1]), minute: Number(match[2]) };
+}
+function envWeekdays(name, env) {
+  const raw = env[name];
+  if (raw === void 0 || raw.trim() === "") return null;
+  try {
+    return parseWeekdays(raw);
+  } catch (error) {
+    throw new Error(`${name}: ${error instanceof Error ? error.message : String(error)}`);
+  }
+}
+function envString(name, fallback, env) {
+  const raw = env[name];
+  return raw === void 0 || raw.trim() === "" ? fallback : raw.trim();
+}
+function workingDay(env) {
+  const workStartHour = envBounded("DAILY_FOCUS_WORK_START", 9, 0, 23, env);
+  const workEndHour = envBounded("DAILY_FOCUS_WORK_END", 17, 1, 24, env);
+  if (workEndHour <= workStartHour) {
+    throw new Error(`DAILY_FOCUS_WORK_END (${workEndHour}) must be later than DAILY_FOCUS_WORK_START (${workStartHour})`);
+  }
+  return { workStartHour, workEndHour };
+}
+function envProfile(env) {
+  const raw = envString("DAILY_FOCUS_PROFILE", "work", env).toLowerCase();
+  if (!PROFILES.includes(raw)) {
+    throw new Error(`DAILY_FOCUS_PROFILE must be one of ${PROFILES.join(", ")}, got ${JSON.stringify(raw)}`);
+  }
+  return raw;
+}
+function loadConfig(env = loadEnv()) {
+  const dataDir = expandHome(envString("DAILY_FOCUS_DATA", DEFAULT_DATA_DIR, env));
+  const profile = envProfile(env);
+  return {
+    profile,
+    dataDir,
+    itemsFile: resolve2(dataDir, "items.json"),
+    actionsFile: resolve2(dataDir, "actions.jsonl"),
+    focusFile: resolve2(dataDir, "focus.md"),
+    settingsFile: resolve2(dataDir, SETTINGS_FILE),
+    sourcesFile: resolve2(dataDir, "sources.md"),
+    promptFile: resolve2(dataDir, "prompt.md"),
+    promptSource: resolve2(import.meta.dirname, "..", "prompts", `morning-brief-${profile}.md`),
+    schemaFile: resolve2(dataDir, "items.schema.json"),
+    schemaSource: resolve2(import.meta.dirname, "..", "schema", "items.schema.json"),
+    archiveDir: resolve2(dataDir, "archive"),
+    sessionFile: resolve2(dataDir, "session.json"),
+    sessionsLogFile: resolve2(dataDir, "sessions.jsonl"),
+    pullsFile: resolve2(dataDir, "prs.json"),
+    calendarFile: resolve2(dataDir, "calendar.json"),
+    ticketsFile: resolve2(dataDir, "tickets.json"),
+    // The same 1 to 120 the session endpoint holds a start to.
+    sessionMinutes: envBounded("DAILY_FOCUS_SESSION_MINUTES", 25, 1, 120, env),
+    awayAfterMinutes: envBounded("DAILY_FOCUS_AWAY_AFTER", profile === "personal" ? 0 : 10, 0, 24 * 60, env),
+    port: envBounded("DAILY_FOCUS_PORT", 4321, 0, 65535, env),
+    host: envString("DAILY_FOCUS_HOST", "127.0.0.1", env),
+    freeWindows: envFlag("DAILY_FOCUS_FREE_WINDOWS", profile !== "personal", env),
+    ...workingDay(env),
+    minFreeWindowMinutes: envBounded("DAILY_FOCUS_MIN_FREE_WINDOW", 45, 1, 24 * 60, env),
+    staleAfterHours: envBounded("DAILY_FOCUS_STALE_AFTER_HOURS", 24, 1, 24 * 30, env),
+    agentDays: envWeekdays("DAILY_FOCUS_AGENT_DAYS", env),
+    github: envGitHub(env),
+    calendar: envCalendar(env),
+    jira: envJira(env, profile),
+    assistant: envAssistant(env),
+    assistantLogFile: resolve2(dataDir, "assistant.jsonl"),
+    assistantDir: resolve2(dataDir, "assistant"),
+    assistantPromptFile: resolve2(dataDir, "assistant.md"),
+    assistantPromptSource: resolve2(import.meta.dirname, "..", "prompts", "assistant.md"),
+    agent: envAgent(env),
+    agentLogFile: resolve2(dataDir, "agent.jsonl")
+  };
+}
+
+export {
+  LAUNCH_SETTINGS,
+  readDotEnv,
+  envSources,
+  layerEnv,
+  BRIEF_REFRESH_GRACE_HOURS,
+  runsOn,
+  nextRunDate,
+  describeSchedule,
+  resolveSchedule,
+  describeTime,
+  scheduledRunDue,
+  nextScheduledRun,
+  PROFILES,
+  CLI_NAMES,
+  briefWritingTools,
+  loadConfig
+};