@inetafrica/open-claudia 2.0.2 → 2.0.3

package/bin/cli.js

@@ -233,6 +233,12 @@ switch (command) {
     break;
   }
 
+  case "tw":
+  case "transcript-window": {
+    require("./transcript-window").run(args.slice(1));
+    break;
+  }
+
   default:
     console.log(`
 Open Claudia — AI Coding Assistant via Telegram
@@ -252,6 +258,10 @@ Send tools (only work inside an active bot-spawned task):
   open-claudia send-photo <path> [caption]
   open-claudia send-voice <path>
 
+Memory tools:
+  open-claudia transcript-window <pattern>   Search project transcript, show hits with context
+                                             (alias: tw; --help for options)
+
 Start options:
   --web           Also start the web UI
   --quick         Skip slow health checks (Claude auth, Telegram API)

package/bin/transcript-window.js

@@ -0,0 +1,202 @@
+// Search the project transcript JSONL for a pattern and print each hit
+// with surrounding turns of context, capped to keep the output bounded.
+//
+// One JSONL line = one user or assistant turn. Output is plain text:
+// match header, separator-delimited context blocks (before, HIT, after).
+//
+// Path resolution:
+//   1. --path <file> flag
+//   2. OC_TRANSCRIPT_PATH env (injected by core/runner.js for bot-spawned tasks)
+//   3. error out — we don't try to guess
+
+const fs = require("fs");
+
+const DEFAULTS = {
+  before: 2,
+  after: 2,
+  maxTurns: 10,
+  maxChars: 1200,
+};
+
+function parseArgs(argv) {
+  const out = {
+    pattern: null,
+    before: DEFAULTS.before,
+    after: DEFAULTS.after,
+    maxTurns: DEFAULTS.maxTurns,
+    maxChars: DEFAULTS.maxChars,
+    regex: false,
+    path: null,
+    json: false,
+    help: false,
+  };
+  for (let i = 0; i < argv.length; i++) {
+    const a = argv[i];
+    if (a === "-h" || a === "--help") { out.help = true; continue; }
+    if (a === "--regex") { out.regex = true; continue; }
+    if (a === "--json") { out.json = true; continue; }
+    if (a === "--before") { out.before = parseInt(argv[++i], 10); continue; }
+    if (a === "--after") { out.after = parseInt(argv[++i], 10); continue; }
+    if (a === "--max-turns") { out.maxTurns = parseInt(argv[++i], 10); continue; }
+    if (a === "--max-chars") { out.maxChars = parseInt(argv[++i], 10); continue; }
+    if (a === "--path") { out.path = argv[++i]; continue; }
+    if (a.startsWith("--")) {
+      console.error(`Unknown flag: ${a}`);
+      process.exit(2);
+    }
+    if (out.pattern === null) { out.pattern = a; continue; }
+    console.error(`Unexpected argument: ${a}`);
+    process.exit(2);
+  }
+  if (!Number.isFinite(out.before) || out.before < 0) out.before = DEFAULTS.before;
+  if (!Number.isFinite(out.after) || out.after < 0) out.after = DEFAULTS.after;
+  if (!Number.isFinite(out.maxTurns) || out.maxTurns < 1) out.maxTurns = DEFAULTS.maxTurns;
+  if (!Number.isFinite(out.maxChars) || out.maxChars < 100) out.maxChars = DEFAULTS.maxChars;
+  return out;
+}
+
+function printHelp() {
+  console.log(`Usage: open-claudia transcript-window <pattern> [options]
+
+Search the active project transcript and print each hit with surrounding turns.
+
+Options:
+  --before N        Turns of context before each hit (default ${DEFAULTS.before})
+  --after N         Turns of context after each hit (default ${DEFAULTS.after})
+  --max-turns K     Stop after K hits (default ${DEFAULTS.maxTurns})
+  --max-chars C     Cap per-turn text length (default ${DEFAULTS.maxChars})
+  --regex           Treat pattern as a regex (default: literal, case-insensitive)
+  --path <file>     Transcript path (default: OC_TRANSCRIPT_PATH env)
+  --json            Emit JSONL of matched windows instead of pretty text
+
+Exit codes: 0 hits found, 1 no hits, 2 usage error, 3 transcript unreadable.`);
+}
+
+function resolveTranscriptPath(flagPath) {
+  if (flagPath) return flagPath;
+  if (process.env.OC_TRANSCRIPT_PATH) return process.env.OC_TRANSCRIPT_PATH;
+  return null;
+}
+
+function loadTurns(transcriptPath) {
+  const raw = fs.readFileSync(transcriptPath, "utf-8");
+  const turns = [];
+  let lineNo = 0;
+  for (const line of raw.split("\n")) {
+    lineNo++;
+    if (!line.trim()) continue;
+    try {
+      const obj = JSON.parse(line);
+      turns.push({
+        lineNo,
+        timestamp: obj.timestamp || "",
+        role: obj.role || "",
+        text: typeof obj.text === "string" ? obj.text : "",
+        sessionId: obj.sessionId || "",
+      });
+    } catch (e) {
+      // skip malformed line
+    }
+  }
+  return turns;
+}
+
+function buildMatcher(pattern, regex) {
+  if (regex) {
+    try { return new RegExp(pattern); }
+    catch (e) {
+      console.error(`Invalid regex: ${e.message}`);
+      process.exit(2);
+    }
+  }
+  const lc = pattern.toLowerCase();
+  return { test: (s) => s.toLowerCase().includes(lc) };
+}
+
+function truncate(text, maxChars) {
+  if (text.length <= maxChars) return text;
+  return text.slice(0, maxChars) + `\n[...truncated, ${text.length - maxChars} more chars]`;
+}
+
+function formatTurn(turn, label, maxChars) {
+  return [
+    `--- ${label}  line ${turn.lineNo}  ${turn.timestamp}  ${turn.role} ---`,
+    truncate(turn.text, maxChars),
+  ].join("\n");
+}
+
+function run(argv) {
+  const opts = parseArgs(argv);
+  if (opts.help || !opts.pattern) {
+    printHelp();
+    process.exit(opts.help ? 0 : 2);
+  }
+  const transcriptPath = resolveTranscriptPath(opts.path);
+  if (!transcriptPath) {
+    console.error("No transcript path. Pass --path <file>, or run inside an active bot-spawned task (OC_TRANSCRIPT_PATH).");
+    process.exit(2);
+  }
+  if (!fs.existsSync(transcriptPath)) {
+    console.error(`Transcript not found: ${transcriptPath}`);
+    process.exit(3);
+  }
+
+  let turns;
+  try { turns = loadTurns(transcriptPath); }
+  catch (e) {
+    console.error(`Failed to read transcript: ${e.message}`);
+    process.exit(3);
+  }
+
+  const matcher = buildMatcher(opts.pattern, opts.regex);
+  const hits = [];
+  for (let i = 0; i < turns.length; i++) {
+    if (matcher.test(turns[i].text)) {
+      hits.push(i);
+      if (hits.length >= opts.maxTurns) break;
+    }
+  }
+
+  if (hits.length === 0) {
+    console.error(`No matches for ${JSON.stringify(opts.pattern)} in ${transcriptPath}`);
+    process.exit(1);
+  }
+
+  if (opts.json) {
+    for (let h = 0; h < hits.length; h++) {
+      const idx = hits[h];
+      const window = [];
+      for (let j = Math.max(0, idx - opts.before); j <= Math.min(turns.length - 1, idx + opts.after); j++) {
+        window.push({ ...turns[j], offset: j - idx });
+      }
+      process.stdout.write(JSON.stringify({ matchIndex: h + 1, matchLine: turns[idx].lineNo, window }) + "\n");
+    }
+    process.exit(0);
+  }
+
+  console.log(`Transcript: ${transcriptPath}`);
+  console.log(`Pattern: ${JSON.stringify(opts.pattern)}${opts.regex ? " (regex)" : ""}`);
+  console.log(`Hits: ${hits.length}  Window: -${opts.before}/+${opts.after} turns  Per-turn cap: ${opts.maxChars} chars`);
+  console.log("");
+
+  for (let h = 0; h < hits.length; h++) {
+    const idx = hits[h];
+    const start = Math.max(0, idx - opts.before);
+    const end = Math.min(turns.length - 1, idx + opts.after);
+    console.log(`===== match ${h + 1}/${hits.length}  line ${turns[idx].lineNo} =====`);
+    for (let j = start; j <= end; j++) {
+      const offset = j - idx;
+      const label = offset === 0 ? "HIT" : (offset < 0 ? `ctx ${offset}` : `ctx +${offset}`);
+      console.log(formatTurn(turns[j], label, opts.maxChars));
+    }
+    console.log("");
+  }
+
+  process.exit(0);
+}
+
+module.exports = { run, parseArgs, loadTurns };
+
+if (require.main === module) {
+  run(process.argv.slice(2));
+}

package/core/config.js

@@ -47,7 +47,8 @@ const WORKSPACE = config.WORKSPACE;
 const CLAUDE_PATH = config.CLAUDE_PATH;
 const CURSOR_PATH = config.CURSOR_PATH || null;
 const CODEX_PATH = config.CODEX_PATH || null;
-const AUTO_COMPACT_TOKENS = parseInt(config.AUTO_COMPACT_TOKENS || process.env.AUTO_COMPACT_TOKENS || "280000", 10);
+const AUTO_COMPACT_TOKENS = parseInt(config.AUTO_COMPACT_TOKENS || process.env.AUTO_COMPACT_TOKENS || "380000", 10);
+const MIN_COMPACT_INTERVAL_MS = parseInt(config.MIN_COMPACT_INTERVAL_MS || process.env.MIN_COMPACT_INTERVAL_MS || "1800000", 10);
 const PROJECT_TRANSCRIPTS = configTruthy(config.PROJECT_TRANSCRIPTS || process.env.PROJECT_TRANSCRIPTS, true);
 const TRANSCRIPT_MAX_ENTRY_CHARS = parseInt(config.TRANSCRIPT_MAX_ENTRY_CHARS || process.env.TRANSCRIPT_MAX_ENTRY_CHARS || "12000", 10);
 const TRANSCRIPTS_DIR = config.TRANSCRIPTS_DIR || process.env.TRANSCRIPTS_DIR || path.join(CONFIG_DIR, "transcripts");
@@ -185,6 +186,7 @@ module.exports = {
   resolvedCursorPath,
   resolvedCodexPath,
   AUTO_COMPACT_TOKENS,
+  MIN_COMPACT_INTERVAL_MS,
   PROJECT_TRANSCRIPTS,
   TRANSCRIPT_MAX_ENTRY_CHARS,
   TRANSCRIPTS_DIR,

package/core/runner.js

@@ -6,7 +6,7 @@
 const { spawn } = require("child_process");
 const {
   CLAUDE_PATH, resolvedCursorPath, resolvedCodexPath,
-  AUTO_COMPACT_TOKENS, MAX_PROCESS_TIMEOUT, botSubprocessEnv,
+  AUTO_COMPACT_TOKENS, MIN_COMPACT_INTERVAL_MS, MAX_PROCESS_TIMEOUT, botSubprocessEnv,
 } = require("./config");
 const { currentState, saveState, recordSession, userOwnsClaudeSession } = require("./state");
 const { chatContext, currentChannelId, currentAdapter } = require("./context");
@@ -33,6 +33,8 @@ function chatEnvOverlay() {
     overlay.OC_SEND_URL = lb.url;
     overlay.OC_SEND_TOKEN = lb.token;
   }
+  const tinfo = transcriptProjectInfo();
+  if (tinfo && tinfo.transcriptPath) overlay.OC_TRANSCRIPT_PATH = tinfo.transcriptPath;
   return overlay;
 }
 
@@ -71,8 +73,11 @@ function getActiveSessionKey(state = currentState()) {
 function shouldAutoCompact(state = currentState(), opts = {}) {
   if (opts.skipAutoCompact || opts.fresh || opts.continueSession || state.isCompacting) return false;
   if (!state[getActiveSessionKey(state)]) return false;
-  const threshold = Number.isFinite(AUTO_COMPACT_TOKENS) ? AUTO_COMPACT_TOKENS : 280000;
-  return (state.sessionUsage?.lastInputTokens || 0) >= threshold;
+  const threshold = Number.isFinite(AUTO_COMPACT_TOKENS) ? AUTO_COMPACT_TOKENS : 380000;
+  if ((state.sessionUsage?.lastInputTokens || 0) < threshold) return false;
+  const minInterval = Number.isFinite(MIN_COMPACT_INTERVAL_MS) ? MIN_COMPACT_INTERVAL_MS : 1800000;
+  if (state.lastCompactedAt && (Date.now() - state.lastCompactedAt) < minInterval) return false;
+  return true;
 }
 
 function buildClaudeArgs(prompt, opts = {}) {
@@ -181,13 +186,20 @@ function claudeEmptyFailureMessage(code, stderrText = "") {
 function compactSummaryPrompt() {
   return [
     "Summarize this conversation for a fresh compacted continuation.",
-    "Include only durable context needed to continue effectively:",
-    "- current user goal and constraints",
-    "- important decisions and preferences",
-    "- files/repos touched and current code state",
-    "- commands/tests already run and results",
-    "- open TODOs, blockers, and exact next step",
-    "Do not include secrets, raw tokens, or irrelevant chat transcript.",
+    "Write a brief that lets your future self resume work without re-asking the user.",
+    "",
+    "Include:",
+    "- Current user goal and any active side threads or sub-goals.",
+    "- Locked-in constraints, preferences, and decisions (with the WHY when non-obvious).",
+    "- Infrastructure / release facts: how things deploy, publish, or release; which CI handles what; required env or secrets; commands the user said NOT to run locally.",
+    "- Files and repos touched, current branch / commit / tag state, what is committed vs uncommitted, what is pushed vs local.",
+    "- Commands already run and their results — so you do not re-run completed setup and do not re-attempt failed steps.",
+    "- Open TODOs, blockers, and the exact next step.",
+    "- User pushback or corrections this session — your future self must not repeat the mistake. Quote the correction if short.",
+    "- Stable paths, IDs, PIDs, owner IDs, and reference URLs the work depends on.",
+    "",
+    "Do not include: secrets, raw tokens, full file dumps, or chat pleasantries.",
+    "Be concrete. Names of files, commands, flags, tags, and commits beat paraphrase. If a fact was load-bearing in this session, write it down verbatim.",
   ].join("\n");
 }
 
@@ -197,6 +209,17 @@ function compactSeedPrompt(summary) {
     "Treat the following summary as the prior conversation context. Do not repeat it back unless asked.",
     "Continue from this state in future turns.",
     "",
+    "Before telling the user you lack context on something they reference:",
+    "1. Check the summary below.",
+    "2. Search the project transcript with `open-claudia transcript-window <pattern>`.",
+    "   It returns each hit with surrounding turns of context, capped per turn so it stays bounded.",
+    "   Useful flags: --before N / --after N (default 2), --max-turns K (default 10), --regex.",
+    "   Fall back to `grep -n -C 5 <pattern> <transcript-path>` (path in your system prompt under",
+    "   'Project Transcript Memory') only if the helper does not fit your search.",
+    "Only ask the user if both turn up nothing.",
+    "",
+    "If a fact in the summary contradicts current repo state (a file path, a command, a flag, a version), trust what you observe now and proceed without flagging it unless the user asks.",
+    "",
     "Compacted summary:",
     summary,
   ].join("\n");
@@ -366,17 +389,6 @@ async function runClaude(prompt, cwd, replyToMsgId, opts = {}) {
     return;
   }
 
-  if (shouldAutoCompact(state, opts)) {
-    try {
-      await compactActiveSession(cwd, {
-        notify: true,
-        message: "Context is getting large, compacting first so this stays fast…",
-      });
-    } catch (e) {
-      await send(`Compaction failed: ${redactSensitive(e.message)}\nContinuing in the existing session.`, { replyTo: replyToMsgId });
-    }
-  }
-
   appendProjectTranscript("user", prompt, {
     sourceMessageId: replyToMsgId || null,
     fresh: !!opts.fresh,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@inetafrica/open-claudia",
-  "version": "2.0.2",
+  "version": "2.0.3",
   "description": "Your always-on AI coding assistant — Claude Code, Cursor Agent, and OpenAI Codex via Telegram or Kazee Chat",
   "main": "bot.js",
   "bin": {