very-happy-cli 0.2.159 → 0.2.161

package/dist/streamRelay-FPVbHpbM.mjs

@@ -0,0 +1,231 @@
+import { S as STREAM_DELTA_MAX_CHARS } from './index-qdS1friN.mjs';
+
+const STREAM_FLUSH_MS = 80;
+const PROGRESS_FLUSH_MS = 250;
+const STREAM_FLUSH_MAX_BYTES = 16 * 1024;
+class StreamRelay {
+  send;
+  setTimer;
+  clearTimer;
+  now;
+  /** The block currently accumulating deltas. At most one is open at a time
+   *  in practice; a switch flushes the previous one first, so out-of-order
+   *  SDK frames degrade to "slightly chunkier", never to interleaved text. */
+  pending = null;
+  flushHandle = null;
+  progress = {};
+  progressDirty = false;
+  progressHandle = null;
+  /** Message id of the block currently open, so `content_block_delta` (which
+   *  carries only an index) can be attributed. Reset per assistant message. */
+  currentMid = null;
+  openBlocks = /* @__PURE__ */ new Set();
+  /** True while nothing has been ingested since the last sweep. Both the SDK
+   *  `result` frame and the launcher's `finally` call endTurn (the second is
+   *  the safety net for turns that die before producing a result), so
+   *  without this a normal turn would emit two sweeps. */
+  idleSinceTurnEnd = true;
+  constructor(options) {
+    this.send = options.send;
+    this.setTimer = options.setTimer ?? ((fn, ms) => setTimeout(fn, ms));
+    this.clearTimer = options.clearTimer ?? ((handle) => clearTimeout(handle));
+    this.now = options.now ?? (() => Date.now());
+  }
+  /** Feed one SDK frame. Unknown shapes are ignored, never thrown on: this
+   *  channel must not be able to take a turn down. */
+  ingest(message) {
+    this.idleSinceTurnEnd = false;
+    try {
+      if (message.type === "stream_event") {
+        this.ingestStreamEvent(message.event);
+        return;
+      }
+      if (message.type === "system" && message.subtype === "thinking_tokens") {
+        if (typeof message.estimated_tokens === "number") {
+          this.setProgress({ thinkingTokens: message.estimated_tokens });
+        }
+        return;
+      }
+      if (message.type === "system" && message.subtype === "status") {
+        const status = message.status === "requesting" || message.status === "compacting" ? message.status : void 0;
+        this.progress.status = status;
+        this.progressDirty = true;
+        this.scheduleProgress();
+        return;
+      }
+    } catch {
+    }
+  }
+  /** The turn produced its result. Flushes everything and tells the web to
+   *  sweep drafts that no persisted message ever claimed. */
+  endTurn() {
+    if (this.idleSinceTurnEnd) {
+      this.clearTimers();
+      return;
+    }
+    this.idleSinceTurnEnd = true;
+    this.flushPending();
+    this.closeOpenBlocks();
+    this.flushProgress();
+    this.progress = {};
+    this.currentMid = null;
+    this.send({ t: "turn-end" });
+  }
+  /** Release timers without emitting anything (session teardown). */
+  dispose() {
+    this.clearTimers();
+    this.pending = null;
+    this.openBlocks.clear();
+  }
+  clearTimers() {
+    if (this.flushHandle !== null) this.clearTimer(this.flushHandle);
+    if (this.progressHandle !== null) this.clearTimer(this.progressHandle);
+    this.flushHandle = null;
+    this.progressHandle = null;
+  }
+  ingestStreamEvent(event) {
+    const e = event;
+    if (!e || typeof e.type !== "string") return;
+    if (e.type === "message_start") {
+      const mid = e.message?.id;
+      this.flushPending();
+      this.closeOpenBlocks();
+      this.currentMid = typeof mid === "string" && mid.length > 0 ? mid : null;
+      const usage = e.message?.usage;
+      if (usage || ["inputTokens", "cacheTokens", "outputTokens", "thinkingTokens"].some((key) => key in this.progress)) {
+        const count = (value) => typeof value === "number" && Number.isSafeInteger(value) && value >= 0 ? value : 0;
+        this.setProgress({
+          inputTokens: count(usage?.input_tokens),
+          cacheTokens: count(usage?.cache_creation_input_tokens) + count(usage?.cache_read_input_tokens),
+          outputTokens: count(usage?.output_tokens),
+          thinkingTokens: 0
+        });
+      }
+      return;
+    }
+    if (e.type === "content_block_start") {
+      const kind = e.content_block?.type === "thinking" ? "thinking" : e.content_block?.type === "text" ? "text" : null;
+      if (!kind || !this.currentMid || typeof e.index !== "number") return;
+      this.openBlock(this.currentMid, e.index, kind);
+      return;
+    }
+    if (e.type === "content_block_delta") {
+      const delta = e.delta;
+      const text = delta?.type === "text_delta" ? delta.text : delta?.type === "thinking_delta" ? delta.thinking : null;
+      if (typeof text !== "string" || text.length === 0) return;
+      if (!this.currentMid || typeof e.index !== "number") return;
+      this.appendDelta(this.currentMid, e.index, text);
+      return;
+    }
+    if (e.type === "content_block_stop") {
+      if (!this.currentMid || typeof e.index !== "number") return;
+      this.closeBlock(this.currentMid, e.index);
+      return;
+    }
+    if (e.type === "message_delta") {
+      const outputTokens = e.usage?.output_tokens;
+      if (typeof outputTokens === "number") {
+        this.setProgress({ outputTokens });
+      }
+      return;
+    }
+  }
+  // ---- Block-level API (see module comment) --------------------------------
+  /** Open a draft block. A different `mid` than the one currently open closes
+   *  whatever the previous message left open, exactly like the SDK's
+   *  `message_start` does. Re-opening an already open block is a no-op. */
+  openBlock(mid, idx, kind) {
+    this.idleSinceTurnEnd = false;
+    if (this.currentMid !== mid) {
+      this.flushPending();
+      this.closeOpenBlocks();
+      this.currentMid = mid;
+    }
+    if (this.openBlocks.has(idx)) return;
+    this.flushPending();
+    this.openBlocks.add(idx);
+    this.send({ t: "block-start", mid, idx, kind });
+  }
+  /** Append text to an OPEN block; deltas for a block that was never opened
+   *  (or belongs to another message) are dropped — the SDK path relies on
+   *  this to ignore `input_json_delta` for tool_use blocks. */
+  appendDelta(mid, idx, text) {
+    this.idleSinceTurnEnd = false;
+    if (text.length === 0) return;
+    if (this.currentMid !== mid || !this.openBlocks.has(idx)) return;
+    if (this.pending && (this.pending.mid !== mid || this.pending.idx !== idx)) {
+      this.flushPending();
+    }
+    if (!this.pending) {
+      this.pending = { mid, idx, text: "", bytes: 0 };
+    }
+    this.pending.text += text;
+    this.pending.bytes += Buffer.byteLength(text, "utf8");
+    if (this.pending.bytes >= STREAM_FLUSH_MAX_BYTES || this.pending.text.length >= STREAM_DELTA_MAX_CHARS) {
+      this.flushPending();
+      return;
+    }
+    if (this.flushHandle === null) {
+      this.flushHandle = this.setTimer(() => {
+        this.flushHandle = null;
+        this.flushPending();
+      }, STREAM_FLUSH_MS);
+    }
+  }
+  /** Close an open block: pending text goes out first, then `block-end`. */
+  closeBlock(mid, idx) {
+    this.idleSinceTurnEnd = false;
+    if (this.currentMid !== mid || !this.openBlocks.has(idx)) return;
+    this.flushPending();
+    this.openBlocks.delete(idx);
+    this.send({ t: "block-end", mid, idx });
+  }
+  /** Merge quantified progress; flushed on the progress cadence. */
+  setProgress(patch) {
+    this.idleSinceTurnEnd = false;
+    this.progress = { ...this.progress, ...patch };
+    this.progressDirty = true;
+    this.scheduleProgress();
+  }
+  // -------------------------------------------------------------------------
+  flushPending() {
+    if (this.flushHandle !== null) {
+      this.clearTimer(this.flushHandle);
+      this.flushHandle = null;
+    }
+    const pending = this.pending;
+    this.pending = null;
+    if (!pending || pending.text.length === 0) return;
+    this.send({ t: "block-delta", mid: pending.mid, idx: pending.idx, text: pending.text });
+  }
+  /** Close blocks the SDK never stopped (interrupt, error, message switch) so
+   *  the web's draft does not keep a blinking cursor forever. */
+  closeOpenBlocks() {
+    if (!this.currentMid || this.openBlocks.size === 0) {
+      this.openBlocks.clear();
+      return;
+    }
+    for (const idx of [...this.openBlocks].sort((a, b) => a - b)) {
+      this.send({ t: "block-end", mid: this.currentMid, idx });
+    }
+    this.openBlocks.clear();
+  }
+  scheduleProgress() {
+    if (this.progressHandle !== null) return;
+    this.progressHandle = this.setTimer(() => {
+      this.progressHandle = null;
+      this.flushProgress();
+    }, PROGRESS_FLUSH_MS);
+  }
+  flushProgress() {
+    if (this.progressHandle !== null) {
+      this.clearTimer(this.progressHandle);
+      this.progressHandle = null;
+    }
+    if (!this.progressDirty) return;
+    this.progressDirty = false;
+    this.send({ t: "progress", ...this.progress });
+  }
+}
+
+export { StreamRelay as S };

package/dist/sync-CVk4QERO.cjs

@@ -0,0 +1,71 @@
+'use strict';
+
+var time = require('./time-CNRE4ChD.cjs');
+
+class InvalidateSync {
+  _invalidated = false;
+  _invalidatedDouble = false;
+  _stopped = false;
+  _command;
+  _pendings = [];
+  constructor(command) {
+    this._command = command;
+  }
+  invalidate() {
+    if (this._stopped) {
+      return;
+    }
+    if (!this._invalidated) {
+      this._invalidated = true;
+      this._invalidatedDouble = false;
+      this._doSync();
+    } else {
+      if (!this._invalidatedDouble) {
+        this._invalidatedDouble = true;
+      }
+    }
+  }
+  async invalidateAndAwait() {
+    if (this._stopped) {
+      return;
+    }
+    await new Promise((resolve) => {
+      this._pendings.push(resolve);
+      this.invalidate();
+    });
+  }
+  stop() {
+    if (this._stopped) {
+      return;
+    }
+    this._notifyPendings();
+    this._stopped = true;
+  }
+  _notifyPendings = () => {
+    for (let pending of this._pendings) {
+      pending();
+    }
+    this._pendings = [];
+  };
+  _doSync = async () => {
+    await time.backoff(async () => {
+      if (this._stopped) {
+        return;
+      }
+      await this._command();
+    });
+    if (this._stopped) {
+      this._notifyPendings();
+      return;
+    }
+    if (this._invalidatedDouble) {
+      this._invalidatedDouble = false;
+      this._doSync();
+    } else {
+      this._invalidated = false;
+      this._notifyPendings();
+    }
+  };
+}
+
+exports.InvalidateSync = InvalidateSync;

package/dist/sync-CxD-w_40.mjs

@@ -0,0 +1,69 @@
+import { b as backoff } from './time-BZNdNiIV.mjs';
+
+class InvalidateSync {
+  _invalidated = false;
+  _invalidatedDouble = false;
+  _stopped = false;
+  _command;
+  _pendings = [];
+  constructor(command) {
+    this._command = command;
+  }
+  invalidate() {
+    if (this._stopped) {
+      return;
+    }
+    if (!this._invalidated) {
+      this._invalidated = true;
+      this._invalidatedDouble = false;
+      this._doSync();
+    } else {
+      if (!this._invalidatedDouble) {
+        this._invalidatedDouble = true;
+      }
+    }
+  }
+  async invalidateAndAwait() {
+    if (this._stopped) {
+      return;
+    }
+    await new Promise((resolve) => {
+      this._pendings.push(resolve);
+      this.invalidate();
+    });
+  }
+  stop() {
+    if (this._stopped) {
+      return;
+    }
+    this._notifyPendings();
+    this._stopped = true;
+  }
+  _notifyPendings = () => {
+    for (let pending of this._pendings) {
+      pending();
+    }
+    this._pendings = [];
+  };
+  _doSync = async () => {
+    await backoff(async () => {
+      if (this._stopped) {
+        return;
+      }
+      await this._command();
+    });
+    if (this._stopped) {
+      this._notifyPendings();
+      return;
+    }
+    if (this._invalidatedDouble) {
+      this._invalidatedDouble = false;
+      this._doSync();
+    } else {
+      this._invalidated = false;
+      this._notifyPendings();
+    }
+  };
+}
+
+export { InvalidateSync as I };

package/dist/systemPrompt-BygJcmbi.cjs

@@ -0,0 +1,97 @@
+'use strict';
+
+var logger = require('./logger-Bc8-u1w0.cjs');
+var node_fs = require('node:fs');
+var path$1 = require('node:path');
+var path = require('./path-B7zW-WwE.cjs');
+var index = require('./index-DA7yINuk.cjs');
+var trimIdent = require('./trimIdent-4gvk9Wk6.cjs');
+var os = require('node:os');
+var agentGuidance = require('./agentGuidance-B5NATuFa.cjs');
+
+function claudeCheckSession(sessionId, path$2) {
+  const projectDir = path.getProjectPath(path$2);
+  const sessionFile = path$1.join(projectDir, `${sessionId}.jsonl`);
+  const sessionExists = node_fs.existsSync(sessionFile);
+  if (!sessionExists) {
+    logger.logger.debug(`[claudeCheckSession] Path ${sessionFile} does not exist`);
+    return false;
+  }
+  const sessionData = node_fs.readFileSync(sessionFile, "utf-8").split("\n");
+  const hasGoodMessage = !!sessionData.find((v, index) => {
+    if (!v.trim()) return false;
+    try {
+      const parsed = JSON.parse(v);
+      return typeof parsed.uuid === "string" && parsed.uuid.length > 0 || // Claude Code 2.1.x
+      typeof parsed.messageId === "string" && parsed.messageId.length > 0 || // Older Claude Code
+      typeof parsed.leafUuid === "string" && parsed.leafUuid.length > 0;
+    } catch (e) {
+      logger.logger.debug(`[claudeCheckSession] Malformed JSON at line ${index + 1}:`, e);
+      return false;
+    }
+  });
+  logger.logger.debug(`[claudeCheckSession] Session ${sessionId}: ${hasGoodMessage ? "valid" : "invalid"}`);
+  return hasGoodMessage;
+}
+
+function getClaudeSettingsPath() {
+  const claudeConfigDir = process.env.CLAUDE_CONFIG_DIR || path$1.join(os.homedir(), ".claude");
+  return path$1.join(claudeConfigDir, "settings.json");
+}
+function readClaudeSettings() {
+  try {
+    const settingsPath = getClaudeSettingsPath();
+    if (!node_fs.existsSync(settingsPath)) {
+      logger.logger.debug(`[ClaudeSettings] No Claude settings file found at ${settingsPath}`);
+      return null;
+    }
+    const settingsContent = node_fs.readFileSync(settingsPath, "utf-8");
+    const settings = JSON.parse(settingsContent);
+    logger.logger.debug(`[ClaudeSettings] Successfully read Claude settings from ${settingsPath}`);
+    logger.logger.debug(`[ClaudeSettings] includeCoAuthoredBy: ${settings.includeCoAuthoredBy}`);
+    return settings;
+  } catch (error) {
+    logger.logger.debug(`[ClaudeSettings] Error reading Claude settings: ${error}`);
+    return null;
+  }
+}
+function shouldIncludeCoAuthoredBy() {
+  const settings = readClaudeSettings();
+  if (!settings) {
+    return true;
+  }
+  if (settings.attribution?.commit === "") {
+    return false;
+  }
+  if (settings.includeCoAuthoredBy === void 0) {
+    return true;
+  }
+  return settings.includeCoAuthoredBy;
+}
+
+const BASE_SYSTEM_PROMPT = (() => trimIdent.trimIdent(`
+    This chat is titled automatically from the user's first message. Call "mcp__happy__change_title" only when the topic has clearly moved on or the current title is too generic to find this chat later. Do not call it as a ritual at the start of a chat, and not for a quick question you can just answer.
+`))() + "\n\n" + agentGuidance.AGENT_GUIDANCE + "\n\n" + index.BUILTIN_TODO_DISCOVERY;
+const CO_AUTHORED_CREDITS = (() => trimIdent.trimIdent(`
+    When you yourself create a git commit, instead of just giving co-credit to Claude, also give credit to Happy like so:
+
+    <main commit message>
+
+    Generated with [Claude Code](https://claude.ai/code)
+    via [Very Happy](https://github.com/Mereithhh/very-happy)
+
+    Co-Authored-By: Claude <noreply@anthropic.com>
+
+    Do not add these lines to commit message text you only draft for the user.
+`))();
+const systemPrompt = (() => {
+  const includeCoAuthored = shouldIncludeCoAuthoredBy();
+  if (includeCoAuthored) {
+    return BASE_SYSTEM_PROMPT + "\n\n" + CO_AUTHORED_CREDITS;
+  } else {
+    return BASE_SYSTEM_PROMPT;
+  }
+})();
+
+exports.claudeCheckSession = claudeCheckSession;
+exports.systemPrompt = systemPrompt;

package/dist/systemPrompt-DmtypUc7.mjs

@@ -0,0 +1,94 @@
+import { l as logger } from './logger-fXoNzNuB.mjs';
+import { existsSync, readFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { g as getProjectPath } from './path-D2wdaNSk.mjs';
+import { l as BUILTIN_TODO_DISCOVERY } from './index-qdS1friN.mjs';
+import { t as trimIdent } from './trimIdent-BAjmv_TG.mjs';
+import { homedir } from 'node:os';
+import { A as AGENT_GUIDANCE } from './agentGuidance-CQuNlNx8.mjs';
+
+function claudeCheckSession(sessionId, path) {
+  const projectDir = getProjectPath(path);
+  const sessionFile = join(projectDir, `${sessionId}.jsonl`);
+  const sessionExists = existsSync(sessionFile);
+  if (!sessionExists) {
+    logger.debug(`[claudeCheckSession] Path ${sessionFile} does not exist`);
+    return false;
+  }
+  const sessionData = readFileSync(sessionFile, "utf-8").split("\n");
+  const hasGoodMessage = !!sessionData.find((v, index) => {
+    if (!v.trim()) return false;
+    try {
+      const parsed = JSON.parse(v);
+      return typeof parsed.uuid === "string" && parsed.uuid.length > 0 || // Claude Code 2.1.x
+      typeof parsed.messageId === "string" && parsed.messageId.length > 0 || // Older Claude Code
+      typeof parsed.leafUuid === "string" && parsed.leafUuid.length > 0;
+    } catch (e) {
+      logger.debug(`[claudeCheckSession] Malformed JSON at line ${index + 1}:`, e);
+      return false;
+    }
+  });
+  logger.debug(`[claudeCheckSession] Session ${sessionId}: ${hasGoodMessage ? "valid" : "invalid"}`);
+  return hasGoodMessage;
+}
+
+function getClaudeSettingsPath() {
+  const claudeConfigDir = process.env.CLAUDE_CONFIG_DIR || join(homedir(), ".claude");
+  return join(claudeConfigDir, "settings.json");
+}
+function readClaudeSettings() {
+  try {
+    const settingsPath = getClaudeSettingsPath();
+    if (!existsSync(settingsPath)) {
+      logger.debug(`[ClaudeSettings] No Claude settings file found at ${settingsPath}`);
+      return null;
+    }
+    const settingsContent = readFileSync(settingsPath, "utf-8");
+    const settings = JSON.parse(settingsContent);
+    logger.debug(`[ClaudeSettings] Successfully read Claude settings from ${settingsPath}`);
+    logger.debug(`[ClaudeSettings] includeCoAuthoredBy: ${settings.includeCoAuthoredBy}`);
+    return settings;
+  } catch (error) {
+    logger.debug(`[ClaudeSettings] Error reading Claude settings: ${error}`);
+    return null;
+  }
+}
+function shouldIncludeCoAuthoredBy() {
+  const settings = readClaudeSettings();
+  if (!settings) {
+    return true;
+  }
+  if (settings.attribution?.commit === "") {
+    return false;
+  }
+  if (settings.includeCoAuthoredBy === void 0) {
+    return true;
+  }
+  return settings.includeCoAuthoredBy;
+}
+
+const BASE_SYSTEM_PROMPT = (() => trimIdent(`
+    This chat is titled automatically from the user's first message. Call "mcp__happy__change_title" only when the topic has clearly moved on or the current title is too generic to find this chat later. Do not call it as a ritual at the start of a chat, and not for a quick question you can just answer.
+`))() + "\n\n" + AGENT_GUIDANCE + "\n\n" + BUILTIN_TODO_DISCOVERY;
+const CO_AUTHORED_CREDITS = (() => trimIdent(`
+    When you yourself create a git commit, instead of just giving co-credit to Claude, also give credit to Happy like so:
+
+    <main commit message>
+
+    Generated with [Claude Code](https://claude.ai/code)
+    via [Very Happy](https://github.com/Mereithhh/very-happy)
+
+    Co-Authored-By: Claude <noreply@anthropic.com>
+
+    Do not add these lines to commit message text you only draft for the user.
+`))();
+const systemPrompt = (() => {
+  const includeCoAuthored = shouldIncludeCoAuthoredBy();
+  if (includeCoAuthored) {
+    return BASE_SYSTEM_PROMPT + "\n\n" + CO_AUTHORED_CREDITS;
+  } else {
+    return BASE_SYSTEM_PROMPT;
+  }
+})();
+
+export { claudeCheckSession as c, systemPrompt as s };

package/dist/{teams-CEahj4cm.mjs → teams-BOC6nIPL.mjs}

@@ -2,51 +2,20 @@ import { homedir } from 'node:os';
 import { readFile } from 'node:fs/promises';
 import { z } from 'zod';
 import { randomUUID } from 'node:crypto';
-import { I as teamRequest, J as createTeamsClient } from './agentGuidance-KgvYuF3R.mjs';
-import { h as readCredentialsForConfiguredRelay } from './limits-CjRj8IX5.mjs';
-import { a as installTeamSkill, i as installAutomationSkill } from './install-BPhJppvd.mjs';
+import { t as teamRequest, c as createTeamsClient } from './client-Brn-UwVk.mjs';
+import { readCredentialsForConfiguredRelay } from './persistence-oET5n61f.mjs';
+import { a as installTeamSkill, i as installAutomationSkill } from './install-BO_W7VhL.mjs';
+import './configuration-DoWFJUPm.mjs';
 import 'node:fs';
 import 'node:path';
-import 'axios';
-import 'socket.io-client';
-import '@paralleldrive/cuid2';
+import './package-uOg9SCKi.mjs';
+import './context-C9GHPLEm.mjs';
+import './authRelay-DSAvg1uv.mjs';
 import 'tweetnacl';
+import './logger-fXoNzNuB.mjs';
 import 'chalk';
 import 'node:util';
-import './index-BF6WfgV5.mjs';
-import './types-Dh-s4Lqs.mjs';
-import 'node:events';
-import 'child_process';
-import 'util';
-import 'fs/promises';
-import 'crypto';
-import 'path';
-import 'cross-spawn';
-import './terminalTitleSuggest-DKgX3osW.mjs';
-import 'url';
-import 'os';
-import 'node:child_process';
-import 'node-pty';
-import 'fs';
-import 'node:readline';
-import '@anthropic-ai/sandbox-runtime';
-import 'expo-server-sdk';
-import 'ink';
-import 'react';
-import '@anthropic-ai/claude-agent-sdk';
-import 'ps-list';
-import 'tmp';
-import 'open';
-import 'fastify';
-import 'fastify-type-provider-zod';
-import 'node:module';
-import '@modelcontextprotocol/sdk/server/mcp.js';
-import 'node:http';
-import '@modelcontextprotocol/sdk/server/streamableHttp.js';
-import 'http';
-import 'inquirer';
-import 'node:url';
-import 'node:readline/promises';
+import './resources-BdFBQi8r.mjs';
 
 const legacyTask = z.object({
   id: z.string().regex(/^T-\d{3,}$/),