@paradow/ledge 0.34.0 → 0.35.0

package/dist/cli/chunk-G7XPEVCG.js

@@ -1,118 +0,0 @@
-import {
-  CODEX_HOOK_VAR
-} from "./chunk-4TCSADFR.js";
-import {
-  connect
-} from "./chunk-7NHQGP6J.js";
-import {
-  LEDGE_GIVER,
-  TASK_TEXT_MAX,
-  TASK_TITLE_MAX
-} from "./chunk-IWY7DSSO.js";
-
-// src/cli/task.ts
-import { randomUUID } from "crypto";
-var TASK_USAGE = `ledge task give <nom> "<titre>" ["<d\xE9tail>"]   confier un travail \xE0 une session
-ledge task give ledge "<question>" "<options, recommandation>"   une d\xE9cision pour l'utilisateur ; sa r\xE9ponse te r\xE9veille
-ledge task list [--all]                         tes t\xE2ches (tenues ou confi\xE9es), ouvertes ; --all : closes aussi
-ledge task show <id>                            une t\xE2che, son d\xE9tail et son historique
-ledge task take <id>                            la prendre
-ledge task done <id> "<r\xE9sultat>"               la terminer, avec ce qui en est sorti (la session qui l'a confi\xE9e est pr\xE9venue)
-ledge task refuse <id> "<raison>"               la refuser, ou l'annuler si tu l'as confi\xE9e
-ledge task pass <id> <nom> ["<note>"]     la passer \xE0 une autre session`;
-var TASK_MS = 4e3;
-var ID = /^t[0-9a-f]{6}$/;
-function taskArgs(args) {
-  const [op, ...rest] = args;
-  const id = rest[0] && ID.test(rest[0]) ? rest[0] : void 0;
-  const fits = (min, max) => rest.length >= min && rest.length <= max && rest.slice(0, min).every((a) => a.trim() !== "");
-  switch (op) {
-    case "give":
-      return fits(2, 3) && rest[1].length <= TASK_TITLE_MAX && (rest[2]?.length ?? 0) <= TASK_TEXT_MAX ? { op, to: rest[0], title: rest[1], ...rest[2] ? { text: rest[2] } : {} } : void 0;
-    case "list":
-      return rest.length === 0 ? { op } : rest.length === 1 && rest[0] === "--all" ? { op, all: true } : void 0;
-    case "show":
-    case "take":
-      return fits(1, 1) && id ? { op, task: id } : void 0;
-    case "done":
-      return fits(2, 2) && id && rest[1].length <= TASK_TEXT_MAX ? { op, task: id, text: rest[1] } : void 0;
-    case "refuse":
-      return fits(2, 2) && id && rest[1].length <= TASK_TEXT_MAX ? { op, task: id, text: rest[1] } : void 0;
-    case "pass":
-      return fits(2, 3) && id && (rest[2]?.length ?? 0) <= TASK_TEXT_MAX ? { op, task: id, to: rest[1], ...rest[2] ? { text: rest[2] } : {} } : void 0;
-    default:
-      return void 0;
-  }
-}
-var STATE = { open: "\xE0 prendre", taken: "prise", done: "termin\xE9e", refused: "refus\xE9e", dropped: "abandonn\xE9e" };
-var time = (iso) => iso.slice(0, 16).replace("T", " ");
-function formatTask(t) {
-  return [
-    `${t.id} \xB7 ${STATE[t.state]} \xB7 de ${t.giverName} \xE0 ${t.ownerName} \xB7 ${time(t.at)}`,
-    t.title,
-    ...t.text ? ["", t.text] : [],
-    ...t.result ? ["", `${t.state === "done" ? "R\xE9sultat" : "Raison"} : ${t.result}`] : [],
-    "",
-    "Historique :",
-    ...t.log.map((l) => `  ${time(l.at)} ${l.by} : ${l.what}`)
-  ].join("\n");
-}
-async function taskOnClient(client, args, by, ms) {
-  const op = taskArgs(args);
-  if (!op) return { line: TASK_USAGE, code: 1 };
-  if (by === LEDGE_GIVER) return { line: "refus\xE9 : seul Ledge confie une t\xE2che en son nom", code: 1 };
-  try {
-    client.send({ type: "task.cmd", rid: randomUUID(), by, ...op });
-    const r = await client.next("task.result", ms);
-    if (r.reason !== void 0) return { line: `refus\xE9 : ${r.reason}`, code: 1 };
-    if (op.op === "list") {
-      const list = r.tasks ?? [];
-      if (!list.length) return { line: op.all ? "aucune t\xE2che" : "aucune t\xE2che ouverte", code: 0 };
-      return { line: list.map((t2) => `${t2.id}  ${STATE[t2.state].padEnd(10)} ${t2.giverName} \u2192 ${t2.ownerName}  ${t2.title}`).join("\n"), code: 0 };
-    }
-    const t = r.task;
-    switch (op.op) {
-      case "give":
-        return { line: t.owner === LEDGE_GIVER ? `d\xE9cision ${t.id} pos\xE9e \xE0 l'utilisateur (ledge decide) : sa r\xE9ponse t'arrivera comme une t\xE2che termin\xE9e` : `t\xE2che ${t.id} confi\xE9e \xE0 ${t.ownerName} : elle lui arrive \xE0 son prochain moment libre`, code: 0 };
-      case "take":
-        return { line: `t\xE2che ${t.id} prise`, code: 0 };
-      case "done":
-        return { line: `t\xE2che ${t.id} termin\xE9e ; Ledge pr\xE9vient ${t.giverName}`, code: 0 };
-      case "refuse":
-        return { line: t.giver === by ? `t\xE2che ${t.id} annul\xE9e ; Ledge pr\xE9vient ${t.ownerName}` : `t\xE2che ${t.id} refus\xE9e ; Ledge pr\xE9vient ${t.giverName}`, code: 0 };
-      case "pass":
-        return { line: `t\xE2che ${t.id} pass\xE9e \xE0 ${t.ownerName}`, code: 0 };
-      default:
-        return { line: formatTask(t), code: 0 };
-    }
-  } catch (e) {
-    return { line: `pas de r\xE9ponse de Ledge : ${e.message}`, code: 1 };
-  }
-}
-async function runTask(args, opts = {}) {
-  if (!taskArgs(args)) return { line: TASK_USAGE, code: args.length ? 1 : 0 };
-  const env = opts.env ?? process.env;
-  const by = env[CODEX_HOOK_VAR] || env.LEDGE_SESSION;
-  if (!by) return { line: "ledge task ne marche que dans une session lanc\xE9e par Ledge", code: 1 };
-  const deadline = Date.now() + (opts.timeoutMs ?? TASK_MS);
-  const left = () => Math.max(0, deadline - Date.now());
-  let client;
-  try {
-    client = await connect({ port: opts.port, timeoutMs: left() });
-  } catch {
-    return { line: "daemon not running (start a session with `ledge claude`, or run `ledge daemon`)", code: 1 };
-  }
-  try {
-    return await taskOnClient(client, args, by, left());
-  } finally {
-    await client.close();
-  }
-}
-
-export {
-  TASK_USAGE,
-  taskArgs,
-  formatTask,
-  taskOnClient,
-  runTask
-};

package/dist/cli/chunk-KPDTYX7F.js

@@ -1,60 +0,0 @@
-import {
-  CODEX_HOOK_VAR
-} from "./chunk-4TCSADFR.js";
-import {
-  connect
-} from "./chunk-7NHQGP6J.js";
-import {
-  BRIEF_MAX
-} from "./chunk-IWY7DSSO.js";
-
-// src/cli/handover.ts
-import { randomUUID } from "crypto";
-var HANDOVER_USAGE = `ledge handover "<bilan>"   ton bilan de rel\xE8ve, quand Ledge te le demande (fait, en cours, suite, pi\xE8ges, fichiers cl\xE9s)
-ledge handover show        relire le bilan de la session dont tu as pris la rel\xE8ve`;
-var HANDOVER_MS = 4e3;
-function handoverArgs(args) {
-  if (args.length === 1 && args[0] === "show") return { op: "show" };
-  const text = args.join(" ").trim();
-  if (!args.length || !text || text.length > BRIEF_MAX) return void 0;
-  return { op: "brief", text };
-}
-async function handoverOnClient(client, args, by, ms) {
-  const op = handoverArgs(args);
-  if (!op) return { line: HANDOVER_USAGE, code: 1 };
-  try {
-    const rid = randomUUID();
-    client.send(op.op === "show" ? { type: "handover.show", rid, by } : { type: "handover.brief", rid, by, text: op.text });
-    const r = await client.next("handover.result", ms);
-    if (r.reason !== void 0) return { line: `refus\xE9 : ${r.reason}`, code: 1 };
-    return op.op === "show" ? { line: r.text ?? "", code: 0 } : { line: "bilan re\xE7u : Ledge lance la session qui prend ta rel\xE8ve et lui passe tes t\xE2ches. Arr\xEAte-toi l\xE0.", code: 0 };
-  } catch (e) {
-    return { line: `pas de r\xE9ponse de Ledge : ${e.message}`, code: 1 };
-  }
-}
-async function runHandover(args, opts = {}) {
-  if (!handoverArgs(args)) return { line: HANDOVER_USAGE, code: args.length ? 1 : 0 };
-  const env = opts.env ?? process.env;
-  const by = env[CODEX_HOOK_VAR] || env.LEDGE_SESSION;
-  if (!by) return { line: "ledge handover ne marche que dans une session lanc\xE9e par Ledge", code: 1 };
-  const deadline = Date.now() + (opts.timeoutMs ?? HANDOVER_MS);
-  const left = () => Math.max(0, deadline - Date.now());
-  let client;
-  try {
-    client = await connect({ port: opts.port, timeoutMs: left() });
-  } catch {
-    return { line: "daemon not running (start a session with `ledge claude`, or run `ledge daemon`)", code: 1 };
-  }
-  try {
-    return await handoverOnClient(client, args, by, left());
-  } finally {
-    await client.close();
-  }
-}
-
-export {
-  HANDOVER_USAGE,
-  handoverArgs,
-  handoverOnClient,
-  runHandover
-};

package/dist/cli/chunk-OLLQBK6N.js

@@ -1,41 +0,0 @@
-// src/transport/frames.ts
-var MAX_FRAME = 4 * 1024 * 1024;
-function readFrames(input, frame, fail) {
-  let buffer = "", stopped = false;
-  input.setEncoding("utf8");
-  const data = (chunk) => {
-    if (stopped) return;
-    buffer += chunk;
-    try {
-      let i;
-      while ((i = buffer.indexOf("\n")) >= 0) {
-        const line = buffer.slice(0, i);
-        buffer = buffer.slice(i + 1);
-        if (Buffer.byteLength(line) > MAX_FRAME) throw new Error("Ledge frame too large");
-        if (line.trim()) frame(JSON.parse(line));
-      }
-      if (Buffer.byteLength(buffer) > MAX_FRAME) throw new Error("Ledge frame too large");
-    } catch (e) {
-      stopped = true;
-      fail(e instanceof Error ? e : new Error(String(e)));
-    }
-  };
-  const end = () => {
-    if (!stopped && buffer.trim()) {
-      stopped = true;
-      fail(new Error("Incomplete Ledge frame"));
-    }
-  };
-  input.on("data", data);
-  input.on("end", end);
-  return () => {
-    stopped = true;
-    input.off("data", data);
-    input.off("end", end);
-  };
-}
-
-export {
-  MAX_FRAME,
-  readFrames
-};

package/dist/cli/chunk-RPH773TY.js

@@ -1,6 +0,0 @@
-// src/version.ts
-var LEDGE_VERSION = true ? "0.34.0" : "0.0.0-dev";
-
-export {
-  LEDGE_VERSION
-};

package/dist/cli/chunk-RX5CJ7YH.js

@@ -1,43 +0,0 @@
-import {
-  connect
-} from "./chunk-7NHQGP6J.js";
-import {
-  isArchived
-} from "./chunk-IWY7DSSO.js";
-
-// src/cli/who.ts
-import { basename } from "path";
-function formatWho(sessions, self) {
-  const live = sessions.filter((s) => s.state !== "exited" && !isArchived(s));
-  if (live.length === 0) return "aucune autre session";
-  const rows = live.map((s) => [
-    s.id === self ? "*" : " ",
-    s.name,
-    s.tool,
-    s.state,
-    `${s.repo ?? s.project}${s.worktree ? ` (${basename(s.cwd)})` : ""}`,
-    s.branch ?? "-",
-    `${s.topic ?? "-"}${s.source === "hook_only" ? " \xB7 lecture seule" : ""}`
-  ]);
-  const head = [" ", "NOM", "OUTIL", "\xC9TAT", "PROJET", "BRANCHE", "SUJET"];
-  const widths = head.map((h, i) => Math.max(h.length, ...rows.map((r) => r[i].length)));
-  return [head, ...rows].map((r) => r.map((c, i) => i === r.length - 1 ? c : c.padEnd(widths[i])).join(" ")).join("\n");
-}
-async function printWho(opts = {}) {
-  let client;
-  try {
-    client = await connect({ port: opts.port, timeoutMs: 800 });
-  } catch {
-    return "daemon not running (start a session with `ledge claude`, or run `ledge daemon`)";
-  }
-  try {
-    return formatWho((await client.next("snapshot")).sessions, opts.self ?? process.env.LEDGE_SESSION);
-  } finally {
-    await client.close();
-  }
-}
-
-export {
-  formatWho,
-  printWho
-};

package/dist/cli/chunk-T547FLQN.js

@@ -1,128 +0,0 @@
-import {
-  log
-} from "./chunk-54KF5RBY.js";
-import {
-  paths
-} from "./chunk-53ISXX2R.js";
-
-// src/tmux.ts
-import { execFile } from "child_process";
-import { existsSync } from "fs";
-import { join } from "path";
-function runFile(file, args, env, opts) {
-  return new Promise((resolve) => {
-    execFile(file, args, { maxBuffer: 4 * 1024 * 1024, env, ...opts?.timeoutMs ? { timeout: opts.timeoutMs, killSignal: "SIGTERM" } : {} }, (err, stdout, stderr) => {
-      const code = err && opts?.timeoutMs && err.killed ? 124 : err && typeof err.code === "number" ? err.code : err ? 1 : 0;
-      resolve({ code, stdout: String(stdout), stderr: String(stderr) });
-    });
-  });
-}
-var run = (args, env) => runFile("tmux", args, env);
-function systemdAvailable(env = process.env, exists = existsSync) {
-  return !!env.XDG_RUNTIME_DIR && exists(join(env.XDG_RUNTIME_DIR, "systemd", "private"));
-}
-function newSessionCommand(tmuxArgs, scoped, unit) {
-  if (!scoped) return { file: "tmux", args: tmuxArgs };
-  return { file: "systemd-run", args: ["--user", "--scope", "--quiet", "--collect", `--unit=${unit}`, "--", "tmux", ...tmuxArgs] };
-}
-function realTmux(socket = "ledge", opts = {}) {
-  const scope = opts.scope ?? (async () => systemdAvailable());
-  const base = () => socket === null ? [] : ["-L", socket, "-f", paths().tmuxConf];
-  const t = (args, env) => run([...base(), ...args], env);
-  return {
-    async newSession({ name, cwd, env, unset = [], command }) {
-      const envArgs = Object.entries(env).flatMap(([k, v]) => ["-e", `${k}=${v}`]);
-      if (unset.length) command = ["env", ...unset.flatMap((v) => ["-u", v]), ...command];
-      const clientEnv = env.PATH === void 0 ? void 0 : { ...process.env, PATH: env.PATH };
-      const args = [...base(), "new-session", "-d", "-s", name, "-c", cwd, "-x", "200", "-y", "50", ...envArgs, "--", ...command];
-      const serverUp = (await t(["list-sessions"])).code === 0;
-      const scoped = !serverUp && await scope();
-      const { file, args: argv } = newSessionCommand(args, scoped, `ledge-tmux-${Date.now()}`);
-      let r = await runFile(file, argv, clientEnv);
-      if (r.code !== 0 && scoped) {
-        log(`tmux: scoped start failed (${r.stderr.trim()}), starting unscoped`);
-        r = await runFile("tmux", args, clientEnv);
-      }
-      if (r.code !== 0) throw new Error(`tmux new-session failed: ${r.stderr.trim()}`);
-    },
-    async sendText(name, text) {
-      if (/[\r\n]/.test(text)) throw new Error("sendText: text must not contain newlines; flatten it first");
-      const arg = text.endsWith(";") ? `${text.slice(0, -1)}\\;` : text;
-      const r = await t(["send-keys", "-t", `=${name}:`, "-l", "--", arg]);
-      if (r.code !== 0) throw new Error(`tmux send-keys failed: ${r.stderr.trim()}`);
-    },
-    async sendKeys(name, keys) {
-      const r = await t(["send-keys", "-t", `=${name}:`, ...keys]);
-      if (r.code !== 0) throw new Error(`tmux send-keys failed: ${r.stderr.trim()}`);
-    },
-    async capture(name, lines) {
-      const r = await t(["capture-pane", "-p", "-J", "-t", `=${name}:`, "-S", String(-lines)]);
-      if (r.code !== 0) return null;
-      return r.stdout.replace(/\s+$/g, "").split("\n").slice(-lines).join("\n");
-    },
-    async width(name) {
-      const r = await t(["display-message", "-p", "-t", `=${name}:`, "#{pane_width}"]);
-      const n = Number(r.stdout.trim());
-      return r.code === 0 && Number.isInteger(n) && n > 0 ? n : null;
-    },
-    async hasSession(name) {
-      return (await t(["has-session", "-t", `=${name}`])).code === 0;
-    },
-    async paneCwd(name) {
-      const r = await t(["display-message", "-p", "-t", `=${name}:`, "#{pane_current_path}"]);
-      const p = r.stdout.trim();
-      return r.code === 0 && p.startsWith("/") ? p : null;
-    },
-    async listSessions() {
-      const r = await t(["list-sessions", "-F", "#{session_name}"]);
-      if (r.code === 0) return r.stdout.split("\n").map((s) => s.trim()).filter(Boolean);
-      if (/no server running|error connecting to/i.test(r.stderr)) return [];
-      throw new Error(`tmux list-sessions failed: ${r.stderr.trim()}`);
-    },
-    async setOption(name, option, value) {
-      const r = await t(["set-option", "-t", `=${name}:`, option, value]);
-      if (r.code !== 0) throw new Error(`tmux set-option failed: ${r.stderr.trim()}`);
-    },
-    async killSession(name) {
-      await t(["kill-session", "-t", `=${name}`]);
-    },
-    attachArgs(name, opts2) {
-      return [...base(), "attach-session", ...opts2?.readOnly ? ["-r"] : [], "-t", `=${name}`];
-    }
-  };
-}
-var isSeatSession = (name) => name.includes("@");
-function routedTmux(own, seats) {
-  const of = (name) => isSeatSession(name) ? seats : own;
-  return {
-    newSession: (o) => own.newSession(o),
-    sendText: (n, text) => of(n).sendText(n, text),
-    sendKeys: (n, keys) => of(n).sendKeys(n, keys),
-    capture: (n, lines) => of(n).capture(n, lines),
-    width: async (n) => {
-      const t = of(n);
-      return t.width ? t.width(n) : null;
-    },
-    paneCwd: async (n) => {
-      const t = of(n);
-      return t.paneCwd ? t.paneCwd(n) : null;
-    },
-    hasSession: (n) => of(n).hasSession(n),
-    async listSessions() {
-      const mine = await own.listSessions();
-      const theirs = await seats.listSessions().catch(() => []);
-      return [...mine, ...theirs.filter(isSeatSession)];
-    },
-    killSession: (n) => of(n).killSession(n),
-    setOption: (n, option, value) => of(n).setOption(n, option, value),
-    attachArgs: (n, opts) => of(n).attachArgs(n, opts)
-  };
-}
-
-export {
-  runFile,
-  run,
-  realTmux,
-  isSeatSession,
-  routedTmux
-};

package/dist/cli/chunk-U67V476Y.js

@@ -1,35 +0,0 @@
-var __create = Object.create;
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __getProtoOf = Object.getPrototypeOf;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __commonJS = (cb, mod) => function __require() {
-  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
-};
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
-  // If the importer is in node compatibility mode or this is not an ESM
-  // file that has been converted to a CommonJS file using a Babel-
-  // compatible transform (i.e. "__esModule" has not been set), then set
-  // "default" to the CommonJS "module.exports" for node compatibility.
-  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
-  mod
-));
-
-export {
-  __commonJS,
-  __export,
-  __toESM
-};