shennian 0.3.85 → 0.3.86

package/dist/src/native-fusion/codex-user-input.js

@@ -1,5 +1,102 @@
-import{normalizeText as s}from"./parser-common.js";function E(t){return Array.isArray(t)?t.map(e=>{if(typeof e=="string")return e;if(typeof e!="object"||e===null)return"";const n=e;return typeof n.text=="string"?n.text:""}).map(e=>s(e)).filter(Boolean).join(`
-
-`):""}function x(t){return s(t.replace(/<image>\s*<\/image>/gi,""))}const g=/^<in-app-browser-context\b(?=[^>]*\bsource=["']ambient-ui-state["'])[^>]*>[\s\S]*?<\/in-app-browser-context>\s*\n+##\s+My request(?: for Codex)?:\s*([\s\S]*)$/i;function m(t){const e=s(t);if(!e)return{text:"",strippedWrapper:!1};const n=e.match(g);if(n?.[1])return{text:x(n[1]),strippedWrapper:!0};const p=e.match(/My request for Codex:\s*([\s\S]*)$/i);if(p?.[1])return{text:x(p[1]),strippedWrapper:!0};const a=e.match(/^# Files mentioned by the user:\s*[\s\S]*?\n+## My request:\s*([\s\S]*)$/i);return a?.[1]?{text:x(a[1]),strippedWrapper:!0}:{text:e,strippedWrapper:!1}}const y=/^<image\b[^>]*\bpath="([^"]+)"[^>]*>\s*$/i,h=/^<\/image>\s*$/i;function b(t){if(!Array.isArray(t))return{text:"",imagePaths:[],strippedWrapper:!1};const e=new Set,n=[];for(let r=0;r+2<t.length;r+=1){const i=t[r],o=t[r+1],u=t[r+2];if(typeof i!="object"||i===null||typeof o!="object"||o===null||typeof u!="object"||u===null)continue;const c=i,l=o,f=u;if(c.type!=="input_text"||typeof c.text!="string"||l.type!=="input_image"||f.type!=="input_text"||typeof f.text!="string"||!h.test(s(f.text)))continue;const d=s(c.text).match(y)?.[1];d&&(n.push(d),e.add(r),e.add(r+2))}const p=t.map((r,i)=>{if(e.has(i))return"";if(typeof r=="string")return r;if(typeof r!="object"||r===null)return"";const o=r;return o.type==="input_text"&&typeof o.text=="string"?o.text:""}).map(r=>s(r)).filter(Boolean).join(`
-
-`);return{...m(p),imagePaths:n}}function R(t){if(t.namespace!=="codex_app"||typeof t.output!="string")return null;const e=s(t.output);if(!e.startsWith("<codex_delegation>")||!e.endsWith("</codex_delegation>"))return null;const n=e.match(/<input>([\s\S]*?)<\/input>\s*<\/codex_delegation>$/)?.[1];return n?s(n):null}export{R as parseCodexDelegationInput,b as parseCodexResponseUserInput,E as parseCodexTextElements,m as stripCodexUserMessageWrapper};
+// @arch docs/architecture/cli/native-session-fusion.md
+// @test src/__tests__/native-fusion-codex-delegation.test.ts
+// @test src/__tests__/native-fusion-codex-current-input.test.ts
+import { normalizeText } from './parser-common.js';
+export function parseCodexTextElements(value) {
+    if (!Array.isArray(value))
+        return '';
+    return value
+        .map((item) => {
+        if (typeof item === 'string')
+            return item;
+        if (typeof item !== 'object' || item === null)
+            return '';
+        const record = item;
+        return typeof record.text === 'string' ? record.text : '';
+    })
+        .map((text) => normalizeText(text))
+        .filter(Boolean)
+        .join('\n\n');
+}
+function stripCodexImagePlaceholders(text) {
+    return normalizeText(text.replace(/<image>\s*<\/image>/gi, ''));
+}
+const CODEX_AMBIENT_BROWSER_REQUEST_RE = /^<in-app-browser-context\b(?=[^>]*\bsource=["']ambient-ui-state["'])[^>]*>[\s\S]*?<\/in-app-browser-context>\s*\n+##\s+My request(?: for Codex)?:\s*([\s\S]*)$/i;
+export function stripCodexUserMessageWrapper(text) {
+    const normalized = normalizeText(text);
+    if (!normalized)
+        return { text: '', strippedWrapper: false };
+    const ambientBrowserRequestMatch = normalized.match(CODEX_AMBIENT_BROWSER_REQUEST_RE);
+    if (ambientBrowserRequestMatch?.[1]) {
+        return {
+            text: stripCodexImagePlaceholders(ambientBrowserRequestMatch[1]),
+            strippedWrapper: true,
+        };
+    }
+    const requestMatch = normalized.match(/My request for Codex:\s*([\s\S]*)$/i);
+    if (requestMatch?.[1]) {
+        return { text: stripCodexImagePlaceholders(requestMatch[1]), strippedWrapper: true };
+    }
+    const attachmentRequestMatch = normalized.match(/^# Files mentioned by the user:\s*[\s\S]*?\n+## My request:\s*([\s\S]*)$/i);
+    if (attachmentRequestMatch?.[1]) {
+        return { text: stripCodexImagePlaceholders(attachmentRequestMatch[1]), strippedWrapper: true };
+    }
+    return { text: normalized, strippedWrapper: false };
+}
+const CODEX_IMAGE_OPEN_TAG_RE = /^<image\b[^>]*\bpath="([^"]+)"[^>]*>\s*$/i;
+const CODEX_IMAGE_CLOSE_TAG_RE = /^<\/image>\s*$/i;
+export function parseCodexResponseUserInput(content) {
+    if (!Array.isArray(content))
+        return { text: '', imagePaths: [], strippedWrapper: false };
+    const ignoredTextIndexes = new Set();
+    const imagePaths = [];
+    for (let index = 0; index + 2 < content.length; index += 1) {
+        const opening = content[index];
+        const image = content[index + 1];
+        const closing = content[index + 2];
+        if (typeof opening !== 'object' || opening === null ||
+            typeof image !== 'object' || image === null ||
+            typeof closing !== 'object' || closing === null)
+            continue;
+        const openingRecord = opening;
+        const imageRecord = image;
+        const closingRecord = closing;
+        if (openingRecord.type !== 'input_text' || typeof openingRecord.text !== 'string' ||
+            imageRecord.type !== 'input_image' ||
+            closingRecord.type !== 'input_text' || typeof closingRecord.text !== 'string' ||
+            !CODEX_IMAGE_CLOSE_TAG_RE.test(normalizeText(closingRecord.text)))
+            continue;
+        const imagePath = normalizeText(openingRecord.text).match(CODEX_IMAGE_OPEN_TAG_RE)?.[1];
+        if (!imagePath)
+            continue;
+        imagePaths.push(imagePath);
+        ignoredTextIndexes.add(index);
+        ignoredTextIndexes.add(index + 2);
+    }
+    const rawText = content
+        .map((part, index) => {
+        if (ignoredTextIndexes.has(index))
+            return '';
+        if (typeof part === 'string')
+            return part;
+        if (typeof part !== 'object' || part === null)
+            return '';
+        const record = part;
+        return record.type === 'input_text' && typeof record.text === 'string' ? record.text : '';
+    })
+        .map((text) => normalizeText(text))
+        .filter(Boolean)
+        .join('\n\n');
+    const stripped = stripCodexUserMessageWrapper(rawText);
+    return { ...stripped, imagePaths };
+}
+export function parseCodexDelegationInput(payload) {
+    if (payload.namespace !== 'codex_app' || typeof payload.output !== 'string')
+        return null;
+    const normalized = normalizeText(payload.output);
+    if (!normalized.startsWith('<codex_delegation>') || !normalized.endsWith('</codex_delegation>')) {
+        return null;
+    }
+    const input = normalized.match(/<input>([\s\S]*?)<\/input>\s*<\/codex_delegation>$/)?.[1];
+    return input ? normalizeText(input) : null;
+}

package/dist/src/native-fusion/config.js

@@ -1 +1,5 @@
-function n(e=process.env){return e.SHENNIAN_NATIVE_FUSION_DISABLED!=="1"}export{n as isNativeFusionEnabled};
+// @arch docs/architecture/cli/native-session-fusion.md
+// @test src/__tests__/native-fusion-config.test.ts
+export function isNativeFusionEnabled(env = process.env) {
+    return env.SHENNIAN_NATIVE_FUSION_DISABLED !== '1';
+}

package/dist/src/native-fusion/file-watcher.js

@@ -1 +1,191 @@
-import o from"node:fs";import a from"node:path";const y=250;class W{onChanged;directoryWatchFactory;fileWatchFactory;directoryWatchers=new Map;fileWatchers=new Map;filesByDirectory=new Map;debounceTimers=new Map;constructor(t,r=(s,i)=>o.watch(s,i),e=(s,i)=>o.watch(s,i)){this.onChanged=t,this.directoryWatchFactory=r,this.fileWatchFactory=e}refresh(t,r=[]){const e=new Set(t),s=new Map;for(const c of t){const n=a.dirname(c),f=s.get(n)??new Set;f.add(c),s.set(n,f)}const i=new Set(s.keys());for(const c of r)this.collectDirectories(c,i);for(const[c,n]of this.directoryWatchers.entries())i.has(c)||(n.close(),this.directoryWatchers.delete(c));for(const[c,n]of this.fileWatchers.entries())e.has(c)||(n.close(),this.fileWatchers.delete(c));this.filesByDirectory=s;for(const c of i)this.trackDirectory(c);for(const c of e)this.trackFile(c)}trackFile(t){const r=a.dirname(t),e=this.filesByDirectory.get(r)??new Set;if(e.add(t),this.filesByDirectory.set(r,e),this.trackDirectory(r),!this.fileWatchers.has(t))try{const s=this.fileWatchFactory(t,()=>this.schedule(t));this.fileWatchers.set(t,s)}catch(s){console.warn(`[native-fusion] unable to watch transcript ${t}`,s)}}untrackFile(t){this.fileWatchers.get(t)?.close(),this.fileWatchers.delete(t);const r=a.dirname(t),e=this.filesByDirectory.get(r);e?.delete(t),e?.size===0&&this.filesByDirectory.delete(r)}stop(){for(const t of this.directoryWatchers.values())t.close();for(const t of this.fileWatchers.values())t.close();this.directoryWatchers.clear(),this.fileWatchers.clear(),this.filesByDirectory.clear();for(const t of this.debounceTimers.values())clearTimeout(t);this.debounceTimers.clear()}handleChange(t,r){const e=r?a.join(t,r.toString()):null;if(e)try{const i=o.statSync(e);if(i.isDirectory()){this.trackDirectoryTree(e,!0);return}if(i.isFile()&&l(e)){this.trackFile(e),this.schedule(e);return}}catch{if(l(e)){this.untrackFile(e),this.schedule(e);return}}const s=[...this.filesByDirectory.get(t)??[]];for(const i of s)this.schedule(i)}trackDirectory(t){if(!this.directoryWatchers.has(t))try{const r=this.directoryWatchFactory(t,(e,s)=>{this.handleChange(t,s)});this.directoryWatchers.set(t,r)}catch(r){console.warn(`[native-fusion] unable to watch ${t}`,r)}}collectDirectories(t,r){if(!o.existsSync(t))return;let e;try{e=o.statSync(t)}catch{return}if(!e.isDirectory())return;r.add(t);let s;try{s=o.readdirSync(t,{withFileTypes:!0})}catch{return}for(const i of s)i.isDirectory()&&this.collectDirectories(a.join(t,i.name),r)}trackDirectoryTree(t,r){this.trackDirectory(t);let e;try{e=o.readdirSync(t,{withFileTypes:!0})}catch{return}for(const s of e){const i=a.join(t,s.name);s.isDirectory()?this.trackDirectoryTree(i,r):s.isFile()&&l(i)&&(this.trackFile(i),r&&this.schedule(i))}}schedule(t){const r=this.debounceTimers.get(t);r&&clearTimeout(r);const e=setTimeout(()=>{this.debounceTimers.delete(t),this.onChanged([t])},y);this.debounceTimers.set(t,e)}}function l(h){return h.endsWith(".jsonl")||h.endsWith(".opencode-session.json")}export{W as NativeFusionFileWatcher};
+// @arch docs/architecture/cli/native-session-fusion.md#51-watcher-拓扑与事件规则
+// @test src/__tests__/native-fusion-file-watcher.test.ts
+import fs from 'node:fs';
+import path from 'node:path';
+const WATCH_DEBOUNCE_MS = 250;
+export class NativeFusionFileWatcher {
+    onChanged;
+    directoryWatchFactory;
+    fileWatchFactory;
+    directoryWatchers = new Map();
+    fileWatchers = new Map();
+    filesByDirectory = new Map();
+    debounceTimers = new Map();
+    constructor(onChanged, directoryWatchFactory = (directory, listener) => (fs.watch(directory, listener)), fileWatchFactory = (filePath, listener) => fs.watch(filePath, listener)) {
+        this.onChanged = onChanged;
+        this.directoryWatchFactory = directoryWatchFactory;
+        this.fileWatchFactory = fileWatchFactory;
+    }
+    refresh(filePaths, rootDirectories = []) {
+        const nextFiles = new Set(filePaths);
+        const nextFilesByDirectory = new Map();
+        for (const filePath of filePaths) {
+            const directory = path.dirname(filePath);
+            const files = nextFilesByDirectory.get(directory) ?? new Set();
+            files.add(filePath);
+            nextFilesByDirectory.set(directory, files);
+        }
+        const nextDirectories = new Set(nextFilesByDirectory.keys());
+        for (const root of rootDirectories) {
+            this.collectDirectories(root, nextDirectories);
+        }
+        for (const [directory, watcher] of this.directoryWatchers.entries()) {
+            if (nextDirectories.has(directory))
+                continue;
+            watcher.close();
+            this.directoryWatchers.delete(directory);
+        }
+        for (const [filePath, watcher] of this.fileWatchers.entries()) {
+            if (nextFiles.has(filePath))
+                continue;
+            watcher.close();
+            this.fileWatchers.delete(filePath);
+        }
+        this.filesByDirectory = nextFilesByDirectory;
+        for (const directory of nextDirectories)
+            this.trackDirectory(directory);
+        // A directory watcher is sufficient for file creation/rename on all supported
+        // platforms, but macOS does not reliably report content appends to an existing
+        // child. Watch known transcript files directly so resumed native sessions stay
+        // realtime; the periodic full scan remains the fallback when a handle fails.
+        for (const filePath of nextFiles)
+            this.trackFile(filePath);
+    }
+    /** Install the append watcher before parsing a newly discovered transcript. */
+    trackFile(filePath) {
+        const directory = path.dirname(filePath);
+        const files = this.filesByDirectory.get(directory) ?? new Set();
+        files.add(filePath);
+        this.filesByDirectory.set(directory, files);
+        this.trackDirectory(directory);
+        if (this.fileWatchers.has(filePath))
+            return;
+        try {
+            const watcher = this.fileWatchFactory(filePath, () => this.schedule(filePath));
+            this.fileWatchers.set(filePath, watcher);
+        }
+        catch (error) {
+            console.warn(`[native-fusion] unable to watch transcript ${filePath}`, error);
+        }
+    }
+    untrackFile(filePath) {
+        this.fileWatchers.get(filePath)?.close();
+        this.fileWatchers.delete(filePath);
+        const directory = path.dirname(filePath);
+        const files = this.filesByDirectory.get(directory);
+        files?.delete(filePath);
+        if (files?.size === 0)
+            this.filesByDirectory.delete(directory);
+    }
+    stop() {
+        for (const watcher of this.directoryWatchers.values())
+            watcher.close();
+        for (const watcher of this.fileWatchers.values())
+            watcher.close();
+        this.directoryWatchers.clear();
+        this.fileWatchers.clear();
+        this.filesByDirectory.clear();
+        for (const timer of this.debounceTimers.values())
+            clearTimeout(timer);
+        this.debounceTimers.clear();
+    }
+    handleChange(directory, filename) {
+        const changedPath = filename ? path.join(directory, filename.toString()) : null;
+        if (changedPath) {
+            try {
+                const stat = fs.statSync(changedPath);
+                if (stat.isDirectory()) {
+                    this.trackDirectoryTree(changedPath, true);
+                    return;
+                }
+                if (stat.isFile() && isNativeTranscriptPath(changedPath)) {
+                    this.trackFile(changedPath);
+                    this.schedule(changedPath);
+                    return;
+                }
+            }
+            catch {
+                if (isNativeTranscriptPath(changedPath)) {
+                    this.untrackFile(changedPath);
+                    this.schedule(changedPath);
+                    return;
+                }
+            }
+        }
+        const targets = [...(this.filesByDirectory.get(directory) ?? [])];
+        for (const target of targets)
+            this.schedule(target);
+    }
+    trackDirectory(directory) {
+        if (this.directoryWatchers.has(directory))
+            return;
+        try {
+            const watcher = this.directoryWatchFactory(directory, (_eventType, filename) => {
+                this.handleChange(directory, filename);
+            });
+            this.directoryWatchers.set(directory, watcher);
+        }
+        catch (error) {
+            console.warn(`[native-fusion] unable to watch ${directory}`, error);
+        }
+    }
+    collectDirectories(directory, output) {
+        if (!fs.existsSync(directory))
+            return;
+        let stat;
+        try {
+            stat = fs.statSync(directory);
+        }
+        catch {
+            return;
+        }
+        if (!stat.isDirectory())
+            return;
+        output.add(directory);
+        let entries;
+        try {
+            entries = fs.readdirSync(directory, { withFileTypes: true });
+        }
+        catch {
+            return;
+        }
+        for (const entry of entries) {
+            if (entry.isDirectory())
+                this.collectDirectories(path.join(directory, entry.name), output);
+        }
+    }
+    trackDirectoryTree(directory, scheduleDiscoveredFiles) {
+        this.trackDirectory(directory);
+        let entries;
+        try {
+            entries = fs.readdirSync(directory, { withFileTypes: true });
+        }
+        catch {
+            return;
+        }
+        for (const entry of entries) {
+            const fullPath = path.join(directory, entry.name);
+            if (entry.isDirectory()) {
+                this.trackDirectoryTree(fullPath, scheduleDiscoveredFiles);
+            }
+            else if (entry.isFile() && isNativeTranscriptPath(fullPath)) {
+                this.trackFile(fullPath);
+                if (scheduleDiscoveredFiles)
+                    this.schedule(fullPath);
+            }
+        }
+    }
+    schedule(filePath) {
+        const previous = this.debounceTimers.get(filePath);
+        if (previous)
+            clearTimeout(previous);
+        const timer = setTimeout(() => {
+            this.debounceTimers.delete(filePath);
+            this.onChanged([filePath]);
+        }, WATCH_DEBOUNCE_MS);
+        this.debounceTimers.set(filePath, timer);
+    }
+}
+function isNativeTranscriptPath(filePath) {
+    return filePath.endsWith('.jsonl') || filePath.endsWith('.opencode-session.json');
+}