zames_pro 2.72.8 → 2.73.0

package/dist/provider-handoff.js

@@ -0,0 +1,73 @@
+// Provider-switch HANDOFF: when the operator changes `/provider` in the middle
+// of a session, the current chat does NOT exist on the new backend (a chat id
+// is meaningful only to the provider that created it), so the conversation
+// would be lost. Instead we summarize the current chat on the OLD provider and
+// persist a HANDOFF for the target provider; on the next launch the new
+// provider opens a fresh chat and posts the summary as its first message.
+//
+// This mirrors /compact's carryover, but the summary crosses a provider
+// boundary and survives a restart, so it is written to disk.
+import fs from 'fs';
+import path from 'path';
+import os from 'os';
+import { writeJsonAtomic } from './fsutil.js';
+const ZAMES_HOME = path.join(os.homedir(), '.zames');
+const HANDOFF_FILE = path.join(ZAMES_HOME, 'provider-handoff.json');
+const NL = String.fromCharCode(10);
+/**
+ * Wrap a cross-provider summary into the first message of the new provider's
+ * chat. PURE (unit-tested): the wording must make clear this is carried-over
+ * context from ANOTHER assistant, so the model treats it as history, not as a
+ * fresh instruction to redo the work.
+ */
+export function buildHandoffText(h) {
+    const body = String(h.summary ?? '').trim();
+    const goal = String(h.task ?? '').trim();
+    let out = `Context carried over from a previous session with another assistant ` +
+        `(${h.from} -> ${h.to}). Treat it as the history of the work so far and ` +
+        `continue from the current state. Do NOT redo what is already done.`;
+    out += NL + NL + body;
+    if (goal)
+        out += NL + NL + 'Original task: ' + goal;
+    return out;
+}
+/** Persist a handoff for a provider. Best-effort (never throws to the caller). */
+export function saveProviderHandoff(h) {
+    try {
+        fs.mkdirSync(ZAMES_HOME, { recursive: true });
+        writeJsonAtomic(HANDOFF_FILE, h);
+    }
+    catch { }
+}
+/**
+ * Read the pending handoff, but ONLY when it targets `provider` and `workdir`:
+ * a handoff for a different provider or project must not be posted into the
+ * wrong chat. Returns null when there is none / it does not match.
+ */
+export function readProviderHandoff(provider, workdir) {
+    try {
+        const raw = JSON.parse(fs.readFileSync(HANDOFF_FILE, 'utf-8'));
+        if (!raw || typeof raw.summary !== 'string' || !raw.summary.trim()) {
+            return null;
+        }
+        if (raw.provider !== provider)
+            return null;
+        if ((raw.workdir || '') !== (workdir || ''))
+            return null;
+        return raw;
+    }
+    catch {
+        return null;
+    }
+}
+/** Remove the handoff once it has been posted (or is stale). Best-effort. */
+export function clearProviderHandoff() {
+    try {
+        fs.unlinkSync(HANDOFF_FILE);
+    }
+    catch { }
+}
+/** For tests: the file the handoff lives in. */
+export function providerHandoffFile() {
+    return HANDOFF_FILE;
+}

package/dist/providers.js

@@ -0,0 +1,50 @@
+// Provider registry — the SINGLE source of truth for the chat backends zames
+// can drive. Adding a new backend (ChatGPT, Gemini, …) means:
+//   1. add an entry here (id, label, chat URL prefix, extra config section);
+//   2. add the provider's `<name>-ui.ts` + `<name>-net-capture.ts` +
+//      `<name>-browser.ts` (implementing ChatProvider, see types.ts);
+//   3. register the class in `createBrowser()` in index.ts.
+// Everything else (config enum, /provider validation, sessions tagging, the
+// /doctor row, the {provider} label in operator messages, /chat URL) reads
+// from HERE, so nothing else has to be touched.
+//
+// This module is PURE (no imports, no side effects) so it can be imported from
+// anywhere without pulling in Playwright.
+export const PROVIDERS = {
+    deepseek: {
+        id: 'deepseek',
+        label: 'DeepSeek',
+        chatUrlPrefix: 'https://chat.deepseek.com/a/chat/s',
+        isDefault: true,
+    },
+    qwen: {
+        id: 'qwen',
+        label: 'Qwen',
+        chatUrlPrefix: 'https://chat.qwen.ai/c',
+        isDefault: false,
+    },
+};
+/** All provider ids, in a stable order (default first). */
+export const PROVIDER_IDS = Object.keys(PROVIDERS).sort((a, b) => PROVIDERS[a].isDefault === PROVIDERS[b].isDefault
+    ? a.localeCompare(b)
+    : PROVIDERS[a].isDefault
+        ? -1
+        : 1);
+/** True when `v` is a known provider id. Narrows the type for callers. */
+export function isProviderId(v) {
+    return (typeof v === 'string' && Object.prototype.hasOwnProperty.call(PROVIDERS, v));
+}
+/** Resolve an unknown value to a provider id, falling back to the default. */
+export function asProviderId(v) {
+    if (isProviderId(v))
+        return v;
+    return PROVIDER_IDS.find((id) => PROVIDERS[id].isDefault) || PROVIDER_IDS[0];
+}
+/** The human label of a provider ('Qwen', 'DeepSeek'). */
+export function providerLabel(id) {
+    return isProviderId(id) ? PROVIDERS[id].label : String(id);
+}
+/** The base chat URL of a provider, used by /chat. */
+export function providerChatUrlPrefix(id) {
+    return isProviderId(id) ? PROVIDERS[id].chatUrlPrefix : '';
+}