@iowarp/clio-coder 0.3.0

package/dist/chunk-KBR4MZZR.js

@@ -0,0 +1,41 @@
+// src/domains/prompts/preload.ts
+var FULL_PROJECT_CONTEXT_MAX_CHARS = 8e3;
+var FULL_PROJECT_CONTEXT_MAX_LINES = 220;
+var NEAR_LIMIT_FRACTION = 0.9;
+function formatKb(chars) {
+  return `${(chars / 1e3).toFixed(1)}kB`;
+}
+function classifyProjectPreload(input) {
+  const chars = input.text.length;
+  const lines = input.text.length === 0 ? 0 : input.text.split("\n").length;
+  if (input.text.trim().length === 0) {
+    return { mode: "none", chars, lines, reason: null, nearLimit: false, label: "none (no project context)" };
+  }
+  const reason = !input.hasClioMd ? "no-clio-md" : chars > FULL_PROJECT_CONTEXT_MAX_CHARS ? "size" : lines > FULL_PROJECT_CONTEXT_MAX_LINES ? "lines" : null;
+  if (reason !== null) {
+    return {
+      mode: "synopsis",
+      chars,
+      lines,
+      reason,
+      nearLimit: false,
+      label: `synopsis (reason: ${reason})`
+    };
+  }
+  const nearLimit = chars > FULL_PROJECT_CONTEXT_MAX_CHARS * NEAR_LIMIT_FRACTION || lines > FULL_PROJECT_CONTEXT_MAX_LINES * NEAR_LIMIT_FRACTION;
+  return {
+    mode: "full",
+    chars,
+    lines,
+    reason: null,
+    nearLimit,
+    label: `full (${formatKb(chars)}, ${lines} lines)`
+  };
+}
+
+export {
+  FULL_PROJECT_CONTEXT_MAX_CHARS,
+  FULL_PROJECT_CONTEXT_MAX_LINES,
+  classifyProjectPreload
+};
+//# sourceMappingURL=chunk-KBR4MZZR.js.map

package/dist/chunk-KKKPTZLM.js

@@ -0,0 +1,93 @@
+// src/cli/oauth-manual-input.ts
+function createDelayedManualCodeInput(rl, prompt, options) {
+  const delayMs = Math.max(0, options?.delayMs ?? 1e4);
+  let timer = null;
+  let abortController = null;
+  let pendingReject = null;
+  let started = false;
+  let cancelled = false;
+  return {
+    onManualCodeInput: () => new Promise((resolve, reject) => {
+      pendingReject = reject;
+      const beginPrompt = () => {
+        pendingReject = null;
+        if (cancelled) {
+          reject(new Error("cancelled"));
+          return;
+        }
+        started = true;
+        abortController = new AbortController();
+        void rl.question(prompt, { signal: abortController.signal }).then((answer) => {
+          resolve(answer.trim());
+        }).catch((error) => {
+          const next = error instanceof Error && error.name === "AbortError" ? new Error("cancelled") : error;
+          reject(next instanceof Error ? next : new Error(String(next)));
+        }).finally(() => {
+          abortController = null;
+        });
+      };
+      if (delayMs === 0) {
+        beginPrompt();
+        return;
+      }
+      timer = setTimeout(() => {
+        timer = null;
+        beginPrompt();
+      }, delayMs);
+    }),
+    cancel: () => {
+      if (cancelled) return;
+      cancelled = true;
+      if (timer) {
+        clearTimeout(timer);
+        timer = null;
+      }
+      if (!started) {
+        pendingReject?.(new Error("cancelled"));
+        pendingReject = null;
+      }
+      if (started) {
+        abortController?.abort();
+      }
+    }
+  };
+}
+
+// src/cli/oauth-select.ts
+import { stdin as input, stdout as output } from "node:process";
+function writeOAuthSelectOptions(prompt) {
+  const defaultId = prompt.options[0]?.id;
+  process.stdout.write(`${prompt.message}
+`);
+  for (const [index, option] of prompt.options.entries()) {
+    const marker = option.id === defaultId ? "*" : " ";
+    process.stdout.write(`  ${marker} ${String(index + 1).padStart(2)}. ${option.label} (${option.id})
+`);
+  }
+  process.stdout.write("\n");
+  return defaultId;
+}
+async function promptOAuthSelection(rl, prompt) {
+  const defaultId = writeOAuthSelectOptions(prompt);
+  if (!defaultId) return void 0;
+  if (!input.isTTY || !output.isTTY) return defaultId;
+  const ids = new Set(prompt.options.map((option) => option.id));
+  for (; ; ) {
+    const answer = (await rl.question(`Selection (number or id, q to cancel) [${defaultId}]: `)).trim();
+    if (answer.length === 0) return defaultId;
+    if (answer === "q" || answer === "quit" || answer === "cancel") return void 0;
+    const numeric = Number(answer);
+    if (Number.isInteger(numeric) && numeric >= 1 && numeric <= prompt.options.length) {
+      return prompt.options[numeric - 1]?.id;
+    }
+    if (ids.has(answer)) return answer;
+    process.stderr.write(`unknown selection: ${answer}
+`);
+  }
+}
+
+export {
+  createDelayedManualCodeInput,
+  promptOAuthSelection
+};
+//# sourceMappingURL=chunk-KKKPTZLM.js.map

package/dist/chunk-ME6DNWIU.js

@@ -0,0 +1,66 @@
+// src/cli/text-layout.ts
+function terminalColumns(stream = process.stdout) {
+  const columns = stream.columns;
+  if (typeof columns !== "number" || !Number.isFinite(columns)) return 80;
+  return Math.max(20, Math.floor(columns));
+}
+function truncate(text, width) {
+  if (width <= 0) return "";
+  if (text.length <= width) return text;
+  if (width === 1) return "\u2026";
+  return `${text.slice(0, width - 1)}\u2026`;
+}
+function column(text, width) {
+  return truncate(text, width).padEnd(width);
+}
+function wrapPlain(text, width, hangingIndent = 0) {
+  const words = text.split(/\s+/).filter((word) => word.length > 0);
+  if (words.length === 0) return [""];
+  const indent = " ".repeat(hangingIndent);
+  const lines = [];
+  let current = "";
+  const emit = (line) => {
+    lines.push(lines.length === 0 ? line : `${indent}${line}`);
+  };
+  for (const word of words) {
+    if (current.length === 0) {
+      current = word;
+      continue;
+    }
+    if (current.length + 1 + word.length <= width) {
+      current = `${current} ${word}`;
+      continue;
+    }
+    emit(current);
+    current = word;
+  }
+  emit(current);
+  return lines;
+}
+function twoColumnRow(left, right, options) {
+  const { indent, leftWidth, width } = options;
+  const minRight = options.minRight ?? 24;
+  const pad = " ".repeat(indent);
+  const rightRoom = width - indent - leftWidth;
+  if (rightRoom >= minRight) {
+    const wrapped = wrapPlain(right, rightRoom, indent + leftWidth);
+    const [first = "", ...rest] = wrapped;
+    return [`${pad}${column(left, leftWidth)}${first}`, ...rest];
+  }
+  const stackIndent = indent + 2;
+  return [
+    `${pad}${left}`,
+    ...wrapPlain(right, Math.max(8, width - stackIndent), stackIndent).map(
+      (line, index) => index === 0 ? `${" ".repeat(stackIndent)}${line}` : line
+    )
+  ];
+}
+
+export {
+  terminalColumns,
+  truncate,
+  column,
+  wrapPlain,
+  twoColumnRow
+};
+//# sourceMappingURL=chunk-ME6DNWIU.js.map

package/dist/chunk-NI4DEJMC.js

@@ -0,0 +1,88 @@
+import {
+  readStateInfo,
+  runDoctor
+} from "./chunk-7RBKDI66.js";
+import {
+  getVersionInfo
+} from "./chunk-HMYNFFY4.js";
+
+// src/domains/lifecycle/migrations/index.ts
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+var REGISTRY = Object.freeze([]);
+function listMigrations() {
+  return REGISTRY;
+}
+function manifestPath(stateDir) {
+  return join(stateDir, "migrations.json");
+}
+function readManifest(path) {
+  if (!existsSync(path)) return { applied: [] };
+  try {
+    const raw = readFileSync(path, "utf8");
+    const parsed = JSON.parse(raw);
+    if (parsed && typeof parsed === "object" && Array.isArray(parsed.applied)) {
+      const ids = parsed.applied.filter((v) => typeof v === "string");
+      return { applied: ids };
+    }
+  } catch {
+  }
+  return { applied: [] };
+}
+function writeManifest(path, manifest) {
+  writeFileSync(path, `${JSON.stringify(manifest, null, 2)}
+`, { encoding: "utf8", mode: 420 });
+}
+async function runPending(stateDir) {
+  mkdirSync(stateDir, { recursive: true });
+  const path = manifestPath(stateDir);
+  const manifest = readManifest(path);
+  const applied = new Set(manifest.applied);
+  const newlyApplied = [];
+  for (const m of REGISTRY) {
+    if (applied.has(m.id)) continue;
+    await m.up(stateDir);
+    applied.add(m.id);
+    newlyApplied.push(m.id);
+  }
+  const allApplied = [...applied];
+  writeManifest(path, { applied: allApplied });
+  return {
+    applied: newlyApplied,
+    allApplied,
+    available: REGISTRY.map((m) => m.id)
+  };
+}
+
+// src/domains/lifecycle/extension.ts
+function createLifecycleBundle(_context) {
+  const extension = {
+    async start() {
+    }
+  };
+  const contract = {
+    version: getVersionInfo,
+    state: readStateInfo,
+    doctor: runDoctor,
+    runMigrations: (stateDir) => runPending(stateDir)
+  };
+  return { extension, contract };
+}
+
+// src/domains/lifecycle/manifest.ts
+var LifecycleManifest = {
+  name: "lifecycle",
+  dependsOn: ["config"]
+};
+
+// src/domains/lifecycle/index.ts
+var LifecycleDomainModule = {
+  manifest: LifecycleManifest,
+  createExtension: createLifecycleBundle
+};
+
+export {
+  listMigrations,
+  LifecycleDomainModule
+};
+//# sourceMappingURL=chunk-NI4DEJMC.js.map