@dtoolkit/dproxy 0.1.0

package/dist/index.js

@@ -0,0 +1,1398 @@
+#!/usr/bin/env node
+
+// src/index.ts
+import chalk7 from "chalk";
+import { Command as Command7 } from "commander";
+
+// src/commands/ask.ts
+import chalk from "chalk";
+import { Command } from "commander";
+
+// src/claude.ts
+import { spawn } from "child_process";
+
+// src/lib/config.ts
+import { readFile, writeFile, rename, mkdir } from "fs/promises";
+import { homedir } from "os";
+import { join } from "path";
+var DATA_DIR = process.env.DPROXY_DATA_DIR || join(homedir(), ".dproxy");
+var DEFAULT_CONFIG = {
+  initialized: false,
+  memory: {
+    autoInject: true,
+    defaultKeys: [],
+    maxInjectionChars: 4e3
+  },
+  life: {
+    autoInject: true,
+    dir: "",
+    maxInjectionChars: 12e3,
+    maxEntityChars: 1500,
+    pythonBin: "python3"
+  },
+  history: {
+    maxEntries: 1e3
+  },
+  workspace: {
+    enabled: false,
+    dir: "",
+    maxInjectionChars: 16e3,
+    files: [
+      { file: "IDENTITY.md", header: "## Identity" },
+      { file: "SOUL.md", header: "## Soul / Personality" },
+      { file: "USER.md", header: "## User Profile" },
+      { file: "MEMORY.md", header: "## System Memory" }
+    ]
+  },
+  chatLog: {
+    enabled: false,
+    dir: "",
+    userPrefix: "User:",
+    assistantPrefix: "Assistant:",
+    sectionHeader: "## Today's conversation"
+  },
+  claude: {
+    bin: "claude",
+    skipPermissions: false
+  },
+  defaults: {},
+  debug: false
+};
+function getDataDir() {
+  return DATA_DIR;
+}
+async function ensureDataDir() {
+  await mkdir(DATA_DIR, { recursive: true });
+  await mkdir(join(DATA_DIR, "memory"), { recursive: true });
+  await mkdir(join(DATA_DIR, "templates"), { recursive: true });
+}
+function deepMerge(defaults, overrides) {
+  const result = { ...defaults };
+  for (const key in overrides) {
+    if (typeof defaults[key] === "object" && defaults[key] !== null && !Array.isArray(defaults[key]) && typeof overrides[key] === "object" && overrides[key] !== null && !Array.isArray(overrides[key])) {
+      result[key] = deepMerge(
+        defaults[key],
+        overrides[key]
+      );
+    } else {
+      result[key] = overrides[key];
+    }
+  }
+  return result;
+}
+async function loadConfig() {
+  try {
+    const raw = await readFile(join(DATA_DIR, "config.json"), "utf-8");
+    const parsed = JSON.parse(raw);
+    return deepMerge(
+      DEFAULT_CONFIG,
+      parsed
+    );
+  } catch {
+    return { ...DEFAULT_CONFIG };
+  }
+}
+async function saveConfig(config) {
+  await ensureDataDir();
+  await atomicWriteFile(join(DATA_DIR, "config.json"), JSON.stringify(config, null, 2) + "\n");
+}
+async function atomicWriteFile(filePath, data) {
+  const tmp = filePath + ".tmp";
+  await writeFile(tmp, data, "utf-8");
+  await rename(tmp, filePath);
+}
+async function getConfigValue(key) {
+  const config = await loadConfig();
+  const parts = key.split(".");
+  let current = config;
+  for (const part of parts) {
+    if (current && typeof current === "object" && part in current) {
+      current = current[part];
+    } else {
+      return void 0;
+    }
+  }
+  return current;
+}
+async function setConfigValue(key, value) {
+  const config = await loadConfig();
+  const parts = key.split(".");
+  let current = config;
+  for (let i = 0; i < parts.length - 1; i++) {
+    if (!(parts[i] in current) || typeof current[parts[i]] !== "object") {
+      current[parts[i]] = {};
+    }
+    current = current[parts[i]];
+  }
+  let parsed = value;
+  if (value === "true") parsed = true;
+  else if (value === "false") parsed = false;
+  else if (!isNaN(Number(value)) && value !== "") parsed = Number(value);
+  current[parts[parts.length - 1]] = parsed;
+  await saveConfig(config);
+}
+
+// src/claude.ts
+async function execClaude(options) {
+  const config = await loadConfig();
+  const args = buildArgs(options, config.claude?.skipPermissions ?? false);
+  const bin = config.claude?.bin || "claude";
+  const startTime = Date.now();
+  return new Promise((resolve, reject) => {
+    const proc = spawn(bin, args, {
+      stdio: ["pipe", "pipe", "pipe"],
+      env: { ...process.env }
+    });
+    let stdout = "";
+    let stderr = "";
+    proc.stdout.on("data", (data) => {
+      stdout += data.toString();
+    });
+    proc.stderr.on("data", (data) => {
+      stderr += data.toString();
+    });
+    if (options.stdinContent) {
+      proc.stdin.write(options.stdinContent);
+      proc.stdin.end();
+    } else {
+      proc.stdin.end();
+    }
+    proc.on("error", (err) => {
+      if (err.code === "ENOENT") {
+        reject(
+          new Error("claude CLI not found. Make sure Claude Code is installed and on your PATH.")
+        );
+      } else {
+        reject(err);
+      }
+    });
+    proc.on("close", (code) => {
+      const durationMs = Date.now() - startTime;
+      if (code !== 0 && !stdout.trim()) {
+        reject(new Error(stderr || `claude exited with code ${code}`));
+        return;
+      }
+      try {
+        const parsed = JSON.parse(stdout);
+        const u = parsed.usage ?? {};
+        const usage = {
+          input: u.input_tokens ?? 0,
+          output: u.output_tokens ?? 0,
+          cacheWrite: u.cache_creation_input_tokens ?? 0,
+          cacheRead: u.cache_read_input_tokens ?? 0,
+          total: (u.input_tokens ?? 0) + (u.output_tokens ?? 0) + (u.cache_creation_input_tokens ?? 0) + (u.cache_read_input_tokens ?? 0)
+        };
+        resolve({
+          result: parsed.result ?? parsed.content ?? stdout,
+          sessionId: parsed.session_id ?? "",
+          costUsd: parsed.cost_usd ?? parsed.total_cost_usd ?? 0,
+          durationMs,
+          isError: parsed.is_error ?? false,
+          usage,
+          raw: parsed
+        });
+      } catch {
+        resolve({
+          result: stdout.trim(),
+          sessionId: "",
+          costUsd: 0,
+          durationMs,
+          isError: code !== 0
+        });
+      }
+    });
+  });
+}
+function buildArgs(options, skipPermissions) {
+  const args = ["--print", "--output-format", "json"];
+  if (skipPermissions) {
+    args.push("--dangerously-skip-permissions");
+  }
+  if (options.model) {
+    args.push("--model", options.model);
+  }
+  if (options.maxTurns !== void 0) {
+    args.push("--max-turns", String(options.maxTurns));
+  }
+  if (options.maxBudgetUsd !== void 0) {
+    args.push("--max-budget-usd", String(options.maxBudgetUsd));
+  }
+  if (options.systemPrompt) {
+    args.push("--system-prompt", options.systemPrompt);
+  }
+  if (options.appendSystemPrompt) {
+    args.push("--append-system-prompt", options.appendSystemPrompt);
+  }
+  if (options.resumeSessionId) {
+    args.push("--resume", options.resumeSessionId);
+  }
+  if (options.continueSession) {
+    args.push("--continue");
+  }
+  if (options.allowedTools) {
+    for (const tool of options.allowedTools) {
+      args.push("--allowedTools", tool);
+    }
+  }
+  if (options.additionalArgs) {
+    args.push(...options.additionalArgs);
+  }
+  args.push(options.prompt);
+  return args;
+}
+async function readStdin() {
+  if (process.stdin.isTTY) {
+    return "";
+  }
+  return new Promise((resolve) => {
+    let data = "";
+    const timeout = setTimeout(() => resolve(data), 5e3);
+    process.stdin.setEncoding("utf-8");
+    process.stdin.on("data", (chunk) => {
+      data += chunk;
+    });
+    process.stdin.on("end", () => {
+      clearTimeout(timeout);
+      resolve(data);
+    });
+  });
+}
+
+// src/lib/chat-log-store.ts
+import { appendFile, mkdir as mkdir2, readFile as readFile2 } from "fs/promises";
+import { join as join2 } from "path";
+function getTodayFile(dir) {
+  const today = (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
+  return join2(dir, `${today}.md`);
+}
+async function buildDayChatContext() {
+  const config = await loadConfig();
+  const cl = config.chatLog;
+  if (!cl?.enabled || !cl?.dir) return "";
+  try {
+    const content = await readFile2(getTodayFile(cl.dir), "utf-8");
+    const trimmed = content.trim();
+    if (!trimmed) return "";
+    const header = cl.sectionHeader ?? "## Today's conversation";
+    return `${header}
+
+${trimmed}`;
+  } catch {
+    return "";
+  }
+}
+async function addChatLog(userPrompt, assistantResponse) {
+  const config = await loadConfig();
+  const cl = config.chatLog;
+  if (!cl?.enabled || !cl?.dir) return;
+  const userMsg = userPrompt.trim();
+  const assistantMsg = assistantResponse.trim();
+  if (!userMsg || !assistantMsg) return;
+  const userPrefix = cl.userPrefix ?? "User:";
+  const assistantPrefix = cl.assistantPrefix ?? "Assistant:";
+  await mkdir2(cl.dir, { recursive: true });
+  const entry = `${userPrefix} ${userMsg}
+${assistantPrefix} ${assistantMsg}
+
+`;
+  await appendFile(getTodayFile(cl.dir), entry, "utf-8");
+}
+
+// src/lib/life-store.ts
+import { execFile } from "child_process";
+import { readFile as readFile3, readdir, stat, appendFile as appendFile2 } from "fs/promises";
+import { join as join3, dirname } from "path";
+import { fileURLToPath } from "url";
+import { promisify } from "util";
+var __dirname = dirname(fileURLToPath(import.meta.url));
+var debugEnabled = null;
+async function debugLog(msg) {
+  if (debugEnabled === null) {
+    const config = await loadConfig();
+    debugEnabled = config.debug ?? false;
+  }
+  if (!debugEnabled) return;
+  const line = `[${(/* @__PURE__ */ new Date()).toISOString()}] ${msg}
+`;
+  appendFile2(join3(getDataDir(), "debug.log"), line).catch(() => {
+  });
+}
+var execFileAsync = promisify(execFile);
+var SEARCH_SCRIPT = process.env.LIFE_SEARCH_BIN || join3(__dirname, "scripts", "search_facts.py");
+async function searchRelevantEntities(query, lifeDir, limit = 10) {
+  const config = await loadConfig();
+  const pythonBin = config.life.pythonBin || "python3";
+  const { stdout } = await execFileAsync(pythonBin, [
+    SEARCH_SCRIPT,
+    query,
+    "--json",
+    "--limit",
+    String(limit),
+    "--life-dir",
+    lifeDir
+  ]);
+  const results = JSON.parse(stdout);
+  const seen = /* @__PURE__ */ new Set();
+  const entities = [];
+  for (const r of results) {
+    if (!seen.has(r.entity)) {
+      seen.add(r.entity);
+      entities.push(r.entity);
+    }
+  }
+  return { entities, facts: results };
+}
+async function discoverEntities(lifeDir) {
+  const entities = [];
+  async function scanDir(dir, collection) {
+    let entries;
+    try {
+      entries = await readdir(dir);
+    } catch {
+      return;
+    }
+    for (const entry of entries) {
+      const fullPath = join3(dir, entry);
+      const summaryPath = join3(fullPath, "summary.md");
+      try {
+        await stat(summaryPath);
+        entities.push({
+          name: entry,
+          collection,
+          summaryPath
+        });
+      } catch {
+        try {
+          const s = await stat(fullPath);
+          if (s.isDirectory()) {
+            await scanDir(fullPath, `${collection}/${entry}`);
+          }
+        } catch (err) {
+          await debugLog(`scanDir: skipping ${fullPath}: ${err}`);
+        }
+      }
+    }
+  }
+  for (const topLevel of ["projects", "areas", "resources"]) {
+    await scanDir(join3(lifeDir, topLevel), topLevel);
+  }
+  return entities;
+}
+async function buildLifeContext(query, maxChars) {
+  const config = await loadConfig();
+  const lifeDir = config.life.dir;
+  if (!lifeDir) return "";
+  const limit = maxChars ?? config.life.maxInjectionChars;
+  await debugLog(
+    `buildLifeContext called \u2014 lifeDir: ${lifeDir}, query: ${query?.slice(0, 80)}, limit: ${limit}`
+  );
+  if (query) {
+    try {
+      return await buildSearchedLifeContext(query, lifeDir, limit);
+    } catch (err) {
+      await debugLog(`PARA search failed, falling back to full scan: ${err}`);
+    }
+  } else {
+    await debugLog(`No query provided, skipping search`);
+  }
+  try {
+    const result = await buildFullLifeContext(lifeDir, limit);
+    await debugLog(`PARA full scan returned ${result.length} chars from dir: ${lifeDir}`);
+    return result;
+  } catch (err) {
+    await debugLog(`PARA full scan failed for dir ${lifeDir}: ${err}`);
+    return "";
+  }
+}
+async function findOwnerEntity(allEntities) {
+  for (const entity of allEntities) {
+    const itemsPath = join3(dirname(entity.summaryPath), "items.json");
+    try {
+      const raw = await readFile3(itemsPath, "utf-8");
+      const data = JSON.parse(raw);
+      if (data.category === "owner") return entity.name;
+    } catch {
+    }
+  }
+  return null;
+}
+async function buildSearchedLifeContext(query, lifeDir, limit) {
+  const { entities: relevantNames, facts } = await searchRelevantEntities(query, lifeDir);
+  await debugLog(`PARA search returned ${relevantNames.length} entities, ${facts.length} facts`);
+  const allEntities = await discoverEntities(lifeDir);
+  const entityMap = /* @__PURE__ */ new Map();
+  for (const e of allEntities) {
+    entityMap.set(e.name, e);
+  }
+  const ownerName = await findOwnerEntity(allEntities);
+  if (ownerName && !relevantNames.includes(ownerName)) {
+    relevantNames.unshift(ownerName);
+    await debugLog(`PARA injected owner entity: ${ownerName}`);
+  }
+  if (relevantNames.length === 0) return "";
+  const config = await loadConfig();
+  const maxEntityChars = config.life.maxEntityChars ?? 1500;
+  const parts = [];
+  let totalChars = 0;
+  for (const name of relevantNames) {
+    const entity = entityMap.get(name);
+    if (!entity) continue;
+    try {
+      const content = await readFile3(entity.summaryPath, "utf-8");
+      const trimmed = content.length > maxEntityChars ? content.slice(0, maxEntityChars) + "\n...(truncated)" : content;
+      const section = `## [${entity.collection}] ${entity.name}
+${trimmed}`;
+      if (totalChars + section.length > limit) break;
+      parts.push(section);
+      totalChars += section.length;
+    } catch (err) {
+      await debugLog(`buildSearchedLifeContext: failed to read ${entity.summaryPath}: ${err}`);
+    }
+  }
+  const topFacts = facts.slice(0, 15);
+  if (topFacts.length > 0) {
+    const factsSection = `## Relevant Facts
+${topFacts.map((f) => `- [${f.entity}] ${f.fact}`).join("\n")}`;
+    if (totalChars + factsSection.length <= limit) {
+      parts.push(factsSection);
+    }
+  }
+  await debugLog(`PARA searched context: ${parts.length} parts, ${totalChars} chars`);
+  if (parts.length === 0) return "";
+  return `You have the following life/PARA knowledge context relevant to this query:
+
+${parts.join("\n\n")}`;
+}
+async function buildFullLifeContext(lifeDir, limit) {
+  const config = await loadConfig();
+  const maxEntityChars = config.life.maxEntityChars ?? 1500;
+  const entities = await discoverEntities(lifeDir);
+  if (entities.length === 0) return "";
+  const parts = [];
+  let totalChars = 0;
+  try {
+    const index = await readFile3(join3(lifeDir, "index.md"), "utf-8");
+    const section = `## Life Overview
+${index}`;
+    if (section.length <= limit) {
+      parts.push(section);
+      totalChars += section.length;
+    }
+  } catch {
+  }
+  for (const entity of entities) {
+    try {
+      const content = await readFile3(entity.summaryPath, "utf-8");
+      const trimmed = content.length > maxEntityChars ? content.slice(0, maxEntityChars) + "\n...(truncated)" : content;
+      const section = `## [${entity.collection}] ${entity.name}
+${trimmed}`;
+      if (totalChars + section.length > limit) break;
+      parts.push(section);
+      totalChars += section.length;
+    } catch (err) {
+      await debugLog(`buildFullLifeContext: failed to read ${entity.summaryPath}: ${err}`);
+    }
+  }
+  if (parts.length === 0) return "";
+  return `You have the following life/PARA knowledge context about the user:
+
+${parts.join("\n\n")}`;
+}
+
+// src/lib/memory-store.ts
+import { readFile as readFile4, writeFile as writeFile2, readdir as readdir2, unlink } from "fs/promises";
+import { join as join4 } from "path";
+function getMemoryDir() {
+  return join4(getDataDir(), "memory");
+}
+function slugify(key) {
+  return key.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "");
+}
+function keyToFile(key) {
+  return join4(getMemoryDir(), `${slugify(key)}.md`);
+}
+async function setMemory(key, value) {
+  await ensureDataDir();
+  await writeFile2(keyToFile(key), value, "utf-8");
+}
+async function getMemory(key) {
+  try {
+    return await readFile4(keyToFile(key), "utf-8");
+  } catch {
+    return null;
+  }
+}
+async function listMemoryKeys() {
+  try {
+    const files = await readdir2(getMemoryDir());
+    return files.filter((f) => f.endsWith(".md")).map((f) => f.replace(/\.md$/, ""));
+  } catch {
+    return [];
+  }
+}
+async function searchMemory(query) {
+  const keys = await listMemoryKeys();
+  const lower = query.toLowerCase();
+  const results = [];
+  for (const key of keys) {
+    const content = await getMemory(key);
+    if (content && (key.toLowerCase().includes(lower) || content.toLowerCase().includes(lower))) {
+      results.push({ key, content });
+    }
+  }
+  return results;
+}
+async function deleteMemory(key) {
+  try {
+    await unlink(keyToFile(key));
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function buildMemoryContext(keys, maxChars = 4e3) {
+  const allKeys = keys?.length ? keys : await listMemoryKeys();
+  if (allKeys.length === 0) return "";
+  const parts = [];
+  let totalChars = 0;
+  for (const key of allKeys) {
+    const content = await getMemory(key);
+    if (!content) continue;
+    const section = `## ${key}
+${content}`;
+    if (totalChars + section.length > maxChars) break;
+    parts.push(section);
+    totalChars += section.length;
+  }
+  if (parts.length === 0) return "";
+  return `You have the following memory/context notes:
+
+${parts.join("\n\n")}`;
+}
+
+// src/lib/workspace-store.ts
+import { readFile as readFile5 } from "fs/promises";
+import { join as join5 } from "path";
+var DEFAULT_BOOTSTRAP_FILES = [
+  { file: "IDENTITY.md", header: "## Identity" },
+  { file: "SOUL.md", header: "## Soul / Personality" },
+  { file: "USER.md", header: "## User Profile" },
+  { file: "MEMORY.md", header: "## System Memory" }
+];
+async function buildWorkspaceContext(maxChars) {
+  const config = await loadConfig();
+  const ws = config.workspace;
+  if (!ws?.enabled || !ws?.dir) return "";
+  const dir = ws.dir;
+  const files = ws.files?.length ? ws.files : DEFAULT_BOOTSTRAP_FILES;
+  const limit = maxChars ?? ws.maxInjectionChars ?? 16e3;
+  const parts = [];
+  let totalChars = 0;
+  for (const { file, header } of files) {
+    try {
+      const content = (await readFile5(join5(dir, file), "utf-8")).trim();
+      if (!content) continue;
+      const section = `${header}
+
+${content}`;
+      if (totalChars + section.length > limit) break;
+      parts.push(section);
+      totalChars += section.length;
+    } catch (err) {
+      if (err.code !== "ENOENT" && config.debug) {
+        console.error(`[dproxy debug] workspace file ${file} error:`, err);
+      }
+    }
+  }
+  if (parts.length === 0) return "";
+  return parts.join("\n\n---\n\n");
+}
+
+// src/lib/context-builder.ts
+async function buildSystemPromptContext(opts, config) {
+  const parts = [];
+  let dayChatCtx = "";
+  if (opts.chatLog !== false) {
+    dayChatCtx = await buildDayChatContext();
+  }
+  if (opts.workspace !== false) {
+    const ctx = await buildWorkspaceContext();
+    if (ctx) parts.push(ctx);
+  }
+  if (opts.memory !== false) {
+    const keys = Array.isArray(opts.memory) ? opts.memory : config.memory.defaultKeys.length ? config.memory.defaultKeys : void 0;
+    const ctx = await buildMemoryContext(keys, config.memory.maxInjectionChars);
+    if (ctx) parts.push(ctx);
+  }
+  if (opts.life !== false && config.life.autoInject) {
+    const ctx = await buildLifeContext(opts.lifeQuery, config.life.maxInjectionChars);
+    if (ctx) parts.push(ctx);
+  }
+  if (dayChatCtx) {
+    parts.unshift(dayChatCtx);
+  }
+  if (parts.length === 0) return "";
+  return parts.join("\n\n---\n\n");
+}
+
+// src/lib/history-store.ts
+import { randomUUID } from "crypto";
+import { appendFile as appendFile3, readFile as readFile6 } from "fs/promises";
+import { join as join6 } from "path";
+function getHistoryPath() {
+  return join6(getDataDir(), "history.jsonl");
+}
+async function addHistoryEntry(entry) {
+  await ensureDataDir();
+  const full = {
+    id: randomUUID(),
+    timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+    ...entry
+  };
+  await appendFile3(getHistoryPath(), JSON.stringify(full) + "\n", "utf-8");
+  try {
+    const config = await loadConfig();
+    const maxEntries = config.history.maxEntries;
+    if (maxEntries > 0) {
+      const all = await readLines();
+      if (all.length > maxEntries) {
+        const kept = all.slice(-maxEntries);
+        await atomicWriteFile(
+          getHistoryPath(),
+          kept.map((e) => JSON.stringify(e)).join("\n") + "\n"
+        );
+      }
+    }
+  } catch (err) {
+    const cfg = await loadConfig();
+    if (cfg.debug) console.error("[dproxy debug] history pruning failed:", err);
+  }
+  return full;
+}
+async function listHistory(limit = 20) {
+  const lines = await readLines();
+  return lines.slice(-limit).reverse();
+}
+async function getHistoryEntry(id) {
+  const lines = await readLines();
+  return lines.find((e) => e.id === id || e.id.startsWith(id)) ?? null;
+}
+async function searchHistory(query) {
+  const lines = await readLines();
+  const lower = query.toLowerCase();
+  return lines.filter((e) => e.prompt.toLowerCase().includes(lower) || e.result.toLowerCase().includes(lower)).reverse();
+}
+async function clearHistory(before) {
+  const lines = await readLines();
+  if (!before) {
+    await atomicWriteFile(getHistoryPath(), "");
+    return lines.length;
+  }
+  const cutoff = new Date(before).getTime();
+  if (isNaN(cutoff)) throw new Error(`Invalid date: "${before}"`);
+  const kept = lines.filter((e) => new Date(e.timestamp).getTime() >= cutoff);
+  const removed = lines.length - kept.length;
+  await atomicWriteFile(
+    getHistoryPath(),
+    kept.map((e) => JSON.stringify(e)).join("\n") + (kept.length ? "\n" : "")
+  );
+  return removed;
+}
+async function readLines() {
+  try {
+    const content = await readFile6(getHistoryPath(), "utf-8");
+    return content.split("\n").filter((line) => line.trim()).flatMap((line) => {
+      try {
+        return [JSON.parse(line)];
+      } catch {
+        return [];
+      }
+    });
+  } catch {
+    return [];
+  }
+}
+
+// src/lib/session-state.ts
+import { readFile as readFile7 } from "fs/promises";
+import { join as join7 } from "path";
+function getStateFile() {
+  return join7(getDataDir(), "session-state.json");
+}
+async function loadState() {
+  try {
+    const raw = await readFile7(getStateFile(), "utf-8");
+    return JSON.parse(raw);
+  } catch {
+    return {};
+  }
+}
+async function saveState(state) {
+  await atomicWriteFile(getStateFile(), JSON.stringify(state, null, 2));
+}
+async function getSessionTokens(sessionId) {
+  const state = await loadState();
+  return state[sessionId]?.totalTokens ?? 0;
+}
+async function updateSessionTokens(sessionId, totalTokens) {
+  const state = await loadState();
+  state[sessionId] = { totalTokens, updatedAt: (/* @__PURE__ */ new Date()).toISOString() };
+  const cutoff = Date.now() - 7 * 24 * 60 * 60 * 1e3;
+  const pruned = Object.fromEntries(
+    Object.entries(state).filter(([, s]) => new Date(s.updatedAt).getTime() >= cutoff)
+  );
+  await saveState(pruned);
+}
+
+// src/commands/ask.ts
+function createAskCommand() {
+  return new Command("ask").description("Send a prompt to Claude").argument("[prompt...]", "The prompt to send").option("-m, --model <model>", "Model to use").option("--max-turns <n>", "Max agent turns", parseInt).option("--max-budget-usd <n>", "Max budget in USD", parseFloat).option("-o, --output-format <format>", "Output format: text, json, stream-json").option("--system-prompt <text>", "System prompt override").option("--no-memory", "Skip memory injection").option("--memory <keys>", "Inject only specific memory keys (comma-separated)").option("--no-life", "Skip life/PARA context injection").option("--no-history", "Don't save to history").option("--raw", "Print raw JSON response").option("--token-footer", "Append token usage footer to response text").option(
+    "--max-session-tokens <n>",
+    "Reset session if context exceeds this token count",
+    parseInt
+  ).option("-c, --continue", "Continue last conversation").option("-r, --resume <id>", "Resume a specific session").action(async (promptParts, opts) => {
+    try {
+      await runAsk(promptParts, opts);
+    } catch (err) {
+      console.error(chalk.red(err.message));
+      process.exit(1);
+    }
+  });
+}
+async function runAsk(promptParts, opts) {
+  const config = await loadConfig();
+  const stdinContent = await readStdin();
+  const promptText = promptParts.join(" ");
+  if (!promptText && !stdinContent) {
+    console.error(chalk.red('No prompt provided. Usage: dproxy ask "your question"'));
+    process.exit(1);
+  }
+  let fullPrompt = promptText;
+  if (stdinContent) {
+    fullPrompt = fullPrompt ? `${fullPrompt}
+
+---
+
+${stdinContent}` : stdinContent;
+  }
+  const memoryOpt = opts.memory === false ? false : typeof opts.memory === "string" ? opts.memory.split(",") : true;
+  const appendSystemPrompt = await buildSystemPromptContext(
+    {
+      memory: memoryOpt,
+      life: opts.life !== false,
+      workspace: true,
+      chatLog: true,
+      lifeQuery: fullPrompt
+    },
+    config
+  ) || void 0;
+  let resumeSessionId = opts.resume;
+  const maxSessionTokens = opts.maxSessionTokens;
+  if (resumeSessionId && maxSessionTokens) {
+    const currentTokens = await getSessionTokens(resumeSessionId);
+    if (currentTokens > maxSessionTokens) {
+      resumeSessionId = void 0;
+    }
+  }
+  const claudeOpts = {
+    prompt: fullPrompt,
+    model: opts.model ?? config.defaults.model,
+    maxTurns: opts.maxTurns ?? config.defaults.maxTurns,
+    maxBudgetUsd: opts.maxBudgetUsd,
+    systemPrompt: opts.systemPrompt,
+    appendSystemPrompt,
+    resumeSessionId,
+    continueSession: opts.continue
+  };
+  const result = await execClaude(claudeOpts);
+  const resultText = result.result;
+  if (result.sessionId && result.usage) {
+    await updateSessionTokens(result.sessionId, result.usage.total);
+  }
+  if (opts.tokenFooter && result.usage) {
+    const u = result.usage;
+    const parts = [];
+    if (u.cacheWrite > 0) parts.push(`cW:${u.cacheWrite.toLocaleString()}`);
+    if (u.cacheRead > 0) parts.push(`cR:${u.cacheRead.toLocaleString()}`);
+    parts.push(`in:${u.input.toLocaleString()}`);
+    parts.push(`out:${u.output.toLocaleString()}`);
+    parts.push(`~${u.total.toLocaleString()}`);
+    const footer = `
+
+\u2014\u2014\u2014\u2014\u2014\u2014\u2014\u2014\u2014\u2014\u2014\u2014\u2014
+\`${parts.join(" \xB7 ")}\``;
+    result.result += footer;
+    if (result.raw && typeof result.raw === "object") {
+      result.raw.result = result.result;
+    }
+  }
+  if (opts.raw) {
+    console.log(JSON.stringify(result.raw ?? result, null, 2));
+  } else if (opts.outputFormat === "json") {
+    console.log(
+      JSON.stringify(
+        { result: result.result, sessionId: result.sessionId, costUsd: result.costUsd },
+        null,
+        2
+      )
+    );
+  } else {
+    console.log(result.result);
+  }
+  if (opts.history !== false) {
+    await addHistoryEntry({
+      prompt: fullPrompt,
+      result: result.result,
+      sessionId: result.sessionId,
+      costUsd: result.costUsd,
+      durationMs: result.durationMs,
+      model: opts.model ?? config.defaults.model
+    });
+  }
+  void addChatLog(promptText, resultText);
+}
+
+// src/commands/chat.ts
+import { readFile as readFile8, writeFile as writeFile3 } from "fs/promises";
+import { join as join8 } from "path";
+import { createInterface } from "readline";
+import chalk2 from "chalk";
+import { Command as Command2 } from "commander";
+var SESSION_FILE = "current-session.json";
+async function loadSession() {
+  try {
+    const raw = await readFile8(join8(getDataDir(), SESSION_FILE), "utf-8");
+    return JSON.parse(raw);
+  } catch {
+    return null;
+  }
+}
+async function saveSession(session) {
+  await ensureDataDir();
+  await writeFile3(
+    join8(getDataDir(), SESSION_FILE),
+    JSON.stringify(session, null, 2) + "\n",
+    "utf-8"
+  );
+}
+function createChatCommand() {
+  return new Command2("chat").description("Start an interactive conversation with Claude").option("-c, --continue", "Continue last conversation").option("-r, --resume <id>", "Resume a specific session").option("-m, --model <model>", "Model to use").option("--max-turns <n>", "Max agent turns per message", parseInt).option("--no-memory", "Skip memory injection").option("--no-life", "Skip life/PARA context injection").action(async (opts) => {
+    try {
+      await runChat(opts);
+    } catch (err) {
+      console.error(chalk2.red(err.message));
+      process.exit(1);
+    }
+  });
+}
+async function runChat(opts) {
+  const config = await loadConfig();
+  let sessionId;
+  if (opts.resume) {
+    sessionId = opts.resume;
+    console.log(chalk2.dim(`Resuming session: ${sessionId}`));
+  } else if (opts.continue) {
+    const prev = await loadSession();
+    if (prev) {
+      sessionId = prev.sessionId;
+      console.log(chalk2.dim(`Continuing session: ${sessionId}`));
+    } else {
+      console.log(chalk2.dim("No previous session found. Starting new chat."));
+    }
+  }
+  const appendSystemPrompt = await buildSystemPromptContext(
+    {
+      memory: opts.memory !== false,
+      life: opts.life !== false,
+      workspace: true,
+      chatLog: true
+    },
+    config
+  ) || void 0;
+  console.log(chalk2.bold.blue("Claude Chat"));
+  console.log(chalk2.dim('Type "exit" or Ctrl+C to quit.\n'));
+  const rl = createInterface({
+    input: process.stdin,
+    output: process.stdout,
+    prompt: chalk2.green("you > ")
+  });
+  rl.prompt();
+  rl.on("line", async (line) => {
+    const input = line.trim();
+    if (!input) {
+      rl.prompt();
+      return;
+    }
+    if (input === "exit" || input === "quit") {
+      console.log(chalk2.dim("Bye!"));
+      rl.close();
+      return;
+    }
+    rl.pause();
+    try {
+      process.stdout.write(chalk2.dim("thinking...\r"));
+      const result = await execClaude({
+        prompt: input,
+        model: opts.model ?? config.defaults.model,
+        maxTurns: opts.maxTurns ?? config.defaults.maxTurns,
+        appendSystemPrompt,
+        resumeSessionId: sessionId
+      });
+      process.stdout.write("\r" + " ".repeat(20) + "\r");
+      console.log(chalk2.cyan("claude > ") + result.result);
+      console.log();
+      if (!sessionId && result.sessionId) {
+        sessionId = result.sessionId;
+        await saveSession({
+          sessionId,
+          startedAt: (/* @__PURE__ */ new Date()).toISOString()
+        });
+      }
+      await addHistoryEntry({
+        prompt: input,
+        result: result.result,
+        sessionId: result.sessionId,
+        costUsd: result.costUsd,
+        durationMs: result.durationMs,
+        model: opts.model ?? config.defaults.model
+      });
+      void addChatLog(input, result.result);
+    } catch (err) {
+      console.error(chalk2.red(err.message));
+    }
+    rl.resume();
+    rl.prompt();
+  });
+  rl.on("close", () => {
+    process.exit(0);
+  });
+}
+
+// src/commands/history.ts
+import chalk3 from "chalk";
+import { Command as Command3 } from "commander";
+function printEntryList(entries, showCost = true) {
+  if (entries.length === 0) {
+    console.log(chalk3.dim("No history entries."));
+    return;
+  }
+  for (const e of entries) {
+    const date = new Date(e.timestamp).toLocaleString();
+    const prompt = e.prompt.length > 60 ? e.prompt.slice(0, 60) + "\u2026" : e.prompt;
+    const cost = showCost && e.costUsd ? chalk3.dim(`$${e.costUsd.toFixed(4)}`) : "";
+    console.log(`${chalk3.dim(e.id.slice(0, 8))}  ${chalk3.blue(date)}  ${prompt}  ${cost}`);
+  }
+}
+function createHistoryCommand() {
+  const cmd = new Command3("history").description("Manage query history");
+  cmd.command("list").description("List recent queries").option("-l, --limit <n>", "Number of entries", parseInt, 20).action(async (opts) => {
+    const entries = await listHistory(opts.limit);
+    printEntryList(entries);
+  });
+  cmd.command("show <id>").description("Show a specific history entry").action(async (id) => {
+    const entry = await getHistoryEntry(id);
+    if (!entry) {
+      console.error(chalk3.red(`Entry not found: ${id}`));
+      process.exit(1);
+    }
+    console.log(chalk3.bold("Prompt:"));
+    console.log(entry.prompt);
+    console.log();
+    console.log(chalk3.bold("Response:"));
+    console.log(entry.result);
+    console.log();
+    console.log(
+      chalk3.dim(
+        `Session: ${entry.sessionId || "n/a"} | Cost: $${entry.costUsd.toFixed(4)} | Duration: ${entry.durationMs}ms | ${entry.timestamp}`
+      )
+    );
+  });
+  cmd.command("search <query>").description("Search history").action(async (query) => {
+    const entries = await searchHistory(query);
+    printEntryList(entries, false);
+  });
+  cmd.command("clear").description("Clear history").option("--before <date>", "Clear entries before this date").action(async (opts) => {
+    const removed = await clearHistory(opts.before);
+    console.log(chalk3.green(`Cleared ${removed} entries.`));
+  });
+  cmd.action(async () => {
+    const entries = await listHistory(20);
+    printEntryList(entries);
+  });
+  return cmd;
+}
+
+// src/commands/init.ts
+import { createInterface as createInterface2 } from "readline";
+import chalk4 from "chalk";
+import { Command as Command4 } from "commander";
+function ask(rl, question, def = "") {
+  const suffix = def ? chalk4.dim(` (${def})`) : "";
+  return new Promise((resolve) => {
+    rl.question(`${question}${suffix}: `, (answer) => {
+      resolve(answer.trim() || def);
+    });
+  });
+}
+function askBool(rl, question, def = false) {
+  const hint = def ? "Y/n" : "y/N";
+  return new Promise((resolve) => {
+    rl.question(`${question} ${chalk4.dim(`[${hint}]`)}: `, (answer) => {
+      const a = answer.trim().toLowerCase();
+      if (!a) return resolve(def);
+      resolve(a === "y" || a === "yes");
+    });
+  });
+}
+function createInitCommand() {
+  return new Command4("init").description("Interactive setup wizard \u2014 required before first use").action(async () => {
+    try {
+      await runInit();
+    } catch (err) {
+      console.error(chalk4.red(err.message));
+      process.exit(1);
+    }
+  });
+}
+async function runInit() {
+  const config = await loadConfig();
+  console.log();
+  console.log(chalk4.bold.blue("dproxy \u2014 Setup"));
+  console.log(chalk4.dim("Configure your environment. Press Enter to accept defaults.\n"));
+  const rl = createInterface2({
+    input: process.stdin,
+    output: process.stdout
+  });
+  try {
+    config.claude.bin = await ask(rl, "Claude binary path", config.claude.bin || "claude");
+    const model = await ask(
+      rl,
+      "Default model (leave empty for CLI default)",
+      config.defaults.model || ""
+    );
+    config.defaults.model = model || void 0;
+    config.claude.skipPermissions = await askBool(
+      rl,
+      "Skip Claude permission prompts (--dangerously-skip-permissions)?",
+      config.claude.skipPermissions
+    );
+    console.log();
+    console.log(chalk4.bold("Optional integrations"));
+    console.log(chalk4.dim("These inject extra context into every prompt.\n"));
+    const enableWorkspace = await askBool(
+      rl,
+      "Enable workspace context (IDENTITY.md, SOUL.md, USER.md, MEMORY.md)?",
+      config.workspace.enabled
+    );
+    config.workspace.enabled = enableWorkspace;
+    if (enableWorkspace) {
+      config.workspace.dir = await ask(rl, "  Workspace directory", config.workspace.dir || "");
+    }
+    const enableChatLog = await askBool(rl, "Enable daily chat log?", config.chatLog.enabled);
+    config.chatLog.enabled = enableChatLog;
+    if (enableChatLog) {
+      config.chatLog.dir = await ask(rl, "  Chat log directory", config.chatLog.dir || "");
+    }
+    const lifeDir = await ask(
+      rl,
+      "PARA knowledge base directory (leave empty to skip)",
+      config.life.dir || ""
+    );
+    config.life.dir = lifeDir;
+    config.debug = await askBool(rl, "Enable debug logging?", config.debug);
+    config.initialized = true;
+    await saveConfig(config);
+    console.log();
+    console.log(chalk4.green("Configuration saved to ") + chalk4.dim(getDataDir() + "/config.json"));
+    console.log(chalk4.green("You're ready to go! Try: ") + chalk4.bold('dproxy "hello"'));
+    console.log();
+  } finally {
+    rl.close();
+  }
+}
+async function requireInit() {
+  const config = await loadConfig();
+  if (config.initialized) return;
+  console.error(
+    chalk4.yellow("dproxy is not configured yet. Run ") + chalk4.bold("dproxy init") + chalk4.yellow(" to set up your environment.")
+  );
+  process.exit(1);
+}
+
+// src/commands/memory.ts
+import chalk5 from "chalk";
+import { Command as Command5 } from "commander";
+function printKeyList(keys) {
+  if (keys.length === 0) {
+    console.log(chalk5.dim("No memory entries."));
+    return;
+  }
+  for (const key of keys) {
+    console.log(chalk5.blue(key));
+  }
+}
+function createMemoryCommand() {
+  const cmd = new Command5("memory").description("Manage persistent memory");
+  cmd.command("set <key> <value...>").description("Set a memory entry").action(async (key, valueParts) => {
+    const value = valueParts.join(" ");
+    await setMemory(key, value);
+    console.log(chalk5.green(`Memory "${key}" saved.`));
+  });
+  cmd.command("get <key>").description("Get a memory entry").action(async (key) => {
+    const value = await getMemory(key);
+    if (value === null) {
+      console.error(chalk5.red(`Memory "${key}" not found.`));
+      process.exit(1);
+    }
+    console.log(value);
+  });
+  cmd.command("list").description("List all memory keys").action(async () => {
+    const keys = await listMemoryKeys();
+    printKeyList(keys);
+  });
+  cmd.command("search <query>").description("Search memory entries").action(async (query) => {
+    const results = await searchMemory(query);
+    if (results.length === 0) {
+      console.log(chalk5.dim("No matches."));
+      return;
+    }
+    for (const { key, content } of results) {
+      const preview = content.length > 80 ? content.slice(0, 80) + "\u2026" : content;
+      console.log(`${chalk5.blue(key)}: ${preview}`);
+    }
+  });
+  cmd.command("delete <key>").description("Delete a memory entry").action(async (key) => {
+    const deleted = await deleteMemory(key);
+    if (deleted) {
+      console.log(chalk5.green(`Memory "${key}" deleted.`));
+    } else {
+      console.error(chalk5.red(`Memory "${key}" not found.`));
+    }
+  });
+  cmd.action(async () => {
+    const keys = await listMemoryKeys();
+    printKeyList(keys);
+  });
+  return cmd;
+}
+
+// src/commands/template.ts
+import { readFile as readFile10 } from "fs/promises";
+import chalk6 from "chalk";
+import { Command as Command6 } from "commander";
+import { parse as parse2 } from "yaml";
+
+// src/lib/template-store.ts
+import { readFile as readFile9, writeFile as writeFile4, readdir as readdir3, unlink as unlink2 } from "fs/promises";
+import { join as join9 } from "path";
+import { parse, stringify } from "yaml";
+function getTemplateDir() {
+  return join9(getDataDir(), "templates");
+}
+function nameToFile(name) {
+  return join9(getTemplateDir(), `${name}.yaml`);
+}
+async function getTemplate(name) {
+  try {
+    const raw = await readFile9(nameToFile(name), "utf-8");
+    return parse(raw);
+  } catch {
+    return null;
+  }
+}
+async function saveTemplate(template) {
+  await ensureDataDir();
+  await writeFile4(nameToFile(template.name), stringify(template), "utf-8");
+}
+async function listTemplates() {
+  try {
+    const files = await readdir3(getTemplateDir());
+    const templates = [];
+    for (const f of files) {
+      if (!f.endsWith(".yaml")) continue;
+      const raw = await readFile9(join9(getTemplateDir(), f), "utf-8");
+      templates.push(parse(raw));
+    }
+    return templates;
+  } catch {
+    return [];
+  }
+}
+async function deleteTemplate(name) {
+  try {
+    await unlink2(nameToFile(name));
+    return true;
+  } catch {
+    return false;
+  }
+}
+function renderTemplate(template, vars) {
+  let prompt = template.prompt;
+  for (const [key, value] of Object.entries(vars)) {
+    prompt = prompt.replaceAll(`{{${key}}}`, value);
+  }
+  const unresolved = prompt.match(/\{\{([^}]+)\}\}/g);
+  if (unresolved) {
+    const names = unresolved.map((v) => v.slice(2, -2));
+    console.error(`Warning: unresolved template variable(s): ${names.join(", ")}`);
+    prompt = prompt.replace(/\{\{[^}]+\}\}/g, "");
+  }
+  return prompt;
+}
+
+// src/commands/template.ts
+function createTemplateCommand() {
+  const cmd = new Command6("template").description("Manage prompt templates");
+  cmd.command("list").description("List all templates").action(async () => {
+    const templates = await listTemplates();
+    if (templates.length === 0) {
+      console.log(chalk6.dim("No templates. Use 'dproxy template add <name>' to create one."));
+      return;
+    }
+    for (const t of templates) {
+      const desc = t.description ? chalk6.dim(` \u2014 ${t.description}`) : "";
+      console.log(`${chalk6.blue(t.name)}${desc}`);
+    }
+  });
+  cmd.command("show <name>").description("Show template details").action(async (name) => {
+    const t = await getTemplate(name);
+    if (!t) {
+      console.error(chalk6.red(`Template "${name}" not found.`));
+      process.exit(1);
+    }
+    console.log(chalk6.bold(t.name));
+    if (t.description) console.log(chalk6.dim(t.description));
+    console.log();
+    console.log(chalk6.bold("Prompt:"));
+    console.log(t.prompt);
+    if (t.variables?.length) {
+      console.log();
+      console.log(chalk6.bold("Variables:"));
+      for (const v of t.variables) {
+        const req = v.required ? chalk6.red("*") : "";
+        const def = v.default ? chalk6.dim(` (default: ${v.default})`) : "";
+        const src = v.source ? chalk6.dim(` [${v.source}]`) : "";
+        console.log(`  {{${v.name}}}${req}${def}${src}`);
+      }
+    }
+  });
+  cmd.command("add <name>").description("Add a template from a YAML file or interactively").option("-f, --file <path>", "Import from YAML file").option("-d, --description <text>", "Template description").option("-p, --prompt <text>", "Template prompt text").action(async (name, opts) => {
+    let template;
+    if (opts.file) {
+      const raw = await readFile10(opts.file, "utf-8");
+      template = parse2(raw);
+      template.name = name;
+    } else if (opts.prompt) {
+      template = {
+        name,
+        description: opts.description,
+        prompt: opts.prompt
+      };
+    } else {
+      console.error(chalk6.red("Provide --file or --prompt"));
+      process.exit(1);
+    }
+    await saveTemplate(template);
+    console.log(chalk6.green(`Template "${name}" saved.`));
+  });
+  cmd.command("run <name>").description("Run a template").option("--var <pairs...>", "Variables as key=value pairs").option("-m, --model <model>", "Model override").option("--raw", "Print raw JSON response").action(async (name, opts) => {
+    const t = await getTemplate(name);
+    if (!t) {
+      console.error(chalk6.red(`Template "${name}" not found.`));
+      process.exit(1);
+    }
+    const vars = {};
+    if (opts.var) {
+      for (const pair of opts.var) {
+        const eq = pair.indexOf("=");
+        if (eq === -1) continue;
+        vars[pair.slice(0, eq)] = pair.slice(eq + 1);
+      }
+    }
+    const stdinVar = t.variables?.find((v) => v.source === "stdin");
+    if (stdinVar) {
+      const stdinContent = await readStdin();
+      if (stdinContent) {
+        vars[stdinVar.name] = stdinContent;
+      }
+    }
+    if (t.variables) {
+      for (const v of t.variables) {
+        if (!(v.name in vars) && v.default) {
+          vars[v.name] = v.default;
+        }
+        if (v.required && !(v.name in vars)) {
+          console.error(chalk6.red(`Missing required variable: {{${v.name}}}`));
+          process.exit(1);
+        }
+      }
+    }
+    const rendered = renderTemplate(t, vars);
+    await runAsk([rendered], {
+      model: opts.model ?? t.claudeOptions?.model,
+      maxTurns: t.claudeOptions?.maxTurns,
+      maxBudgetUsd: t.claudeOptions?.maxBudgetUsd,
+      raw: opts.raw,
+      memory: true,
+      history: true,
+      templateUsed: name
+    });
+  });
+  cmd.command("delete <name>").description("Delete a template").action(async (name) => {
+    const deleted = await deleteTemplate(name);
+    if (deleted) {
+      console.log(chalk6.green(`Template "${name}" deleted.`));
+    } else {
+      console.error(chalk6.red(`Template "${name}" not found.`));
+    }
+  });
+  return cmd;
+}
+
+// src/index.ts
+var program = new Command7();
+program.name("dproxy").description("Universal adapter for invoking models via local CLIs").version("0.1.0");
+program.addCommand(createInitCommand());
+var guarded = (cmd) => {
+  cmd.hook("preAction", async () => {
+    await requireInit();
+  });
+  return cmd;
+};
+program.addCommand(guarded(createAskCommand()));
+program.addCommand(guarded(createChatCommand()));
+program.addCommand(guarded(createHistoryCommand()));
+program.addCommand(guarded(createMemoryCommand()));
+program.addCommand(guarded(createTemplateCommand()));
+var configCmd = new Command7("config").description("Manage configuration");
+configCmd.command("set <key> <value>").description("Set a config value (e.g., memory.autoInject true)").action(async (key, value) => {
+  await setConfigValue(key, value);
+  console.log(chalk7.green(`${key} = ${value}`));
+});
+configCmd.command("get <key>").description("Get a config value").action(async (key) => {
+  const value = await getConfigValue(key);
+  if (value === void 0) {
+    console.error(chalk7.red(`Config key "${key}" not found.`));
+    process.exit(1);
+  }
+  console.log(JSON.stringify(value, null, 2));
+});
+configCmd.action(async () => {
+  const config = await loadConfig();
+  console.log(JSON.stringify(config, null, 2));
+});
+program.addCommand(guarded(configCmd));
+program.argument("[prompt...]", "Send a quick prompt (shorthand for 'dproxy ask')").option("-m, --model <model>", "Model to use").option("--max-turns <n>", "Max agent turns", parseInt).option("--max-budget-usd <n>", "Max budget in USD", parseFloat).option("-o, --output-format <format>", "Output format").option("--no-memory", "Skip memory injection").option("--memory <keys>", "Inject specific memory keys").option("--no-life", "Skip life/PARA context injection").option("--no-history", "Don't save to history").option("--raw", "Print raw JSON response").option("--token-footer", "Append token usage footer to response text").option("--max-session-tokens <n>", "Reset session if context exceeds this token count", parseInt).option("-c, --continue", "Continue last conversation").option("-r, --resume <id>", "Resume a specific session").action(async (promptParts, opts) => {
+  if (promptParts.length === 0) {
+    program.help();
+    return;
+  }
+  await requireInit();
+  try {
+    await runAsk(promptParts, opts);
+  } catch (err) {
+    console.error(chalk7.red(err.message));
+    process.exit(1);
+  }
+});
+program.parse();