@qilin-agent/workspace-changes 0.0.0-stage → 3.1.4

package/lib/types/recorder.js

@@ -0,0 +1,370 @@
+/** Per-Session turn recorder: snapshots, captures around file-tool edits, the turn-end diff, and the records kept until disposal. */
+import { mkdtemp, readFile, realpath, rm } from 'node:fs/promises';
+import { homedir } from 'node:os';
+import { join, relative, resolve } from 'node:path';
+import { captureFile, mutationPath, sameCapture } from "./capture.js";
+import { compareText } from "./compare.js";
+import { blobText, diffTrees, gitlinkPaths, ignoredPaths, locateGitWorkspace, snapshotTree, treeBlob, } from "./git.js";
+import { canonicalPath, compareDisplay, displayPathOf, durablePathOf, isInside, isTemporaryPath, temporaryRoots, toPosix } from "./paths.js";
+function freshState(turn) {
+    return { turn, baseline: null, captures: new Map(), lastToolResultSeq: -1, attemptedAfterSeq: -1, recordedAfterSeq: -1 };
+}
+/** A snapshot side larger than the byte cap. */
+const OVERSIZED = Symbol('oversized');
+/**
+ * Serializes one Session's recording work: the turn-start snapshot, the
+ * whole-file capture before each file-tool mutation, the turn-end snapshot
+ * with its diff, and the appended `workspace/changes` event whose summary and
+ * comparisons this recorder keeps. Snapshot objects and captured copies live in
+ * a temporary directory owned by the recorder; disposal removes it together
+ * with the summaries. Tool execution waits for pending work so a snapshot or
+ * capture never races a mutation. A working directory outside any repository,
+ * or a Host without git, gets no snapshot; its summary lists the files the file
+ * tools changed.
+ */
+export class TurnRecorder {
+    session;
+    cwd;
+    env;
+    chain = Promise.resolve();
+    /** The open turn; before the first `turn/start` it is an empty placeholder no event can match. */
+    state = freshState(0);
+    /** Canonical paths, resolved by the first turn. */
+    paths;
+    /** The located repository, reused across turns once found; null keeps retrying each turn. */
+    repository = null;
+    /** Temporary directory holding this Session's snapshot objects, scratch indexes, and captured copies. */
+    scratch;
+    /** Records by the sequence of the event that announced them. */
+    records = new Map();
+    lifetime = new AbortController();
+    constructor(session, cwd, env) {
+        this.session = session;
+        this.cwd = cwd;
+        this.env = env;
+    }
+    /**
+     * Open a turn with fresh per-turn state and queue its baseline snapshot.
+     * @param turn - the turn number from `turn/start`.
+     */
+    start(turn) {
+        const state = freshState(turn);
+        this.state = state;
+        void this.enqueue(async (signal) => {
+            try {
+                this.paths ??= { cwd: await realpath(this.cwd), home: await canonicalPath(homedir()), temporaryRoots: await temporaryRoots() };
+                const repository = await this.locate(this.paths.cwd, signal);
+                if (repository === null)
+                    return;
+                const tree = await snapshotTree(repository.git, repository.workspace, signal);
+                state.baseline = { ...repository, tree };
+            }
+            catch (error) {
+                // A repository whose snapshot failed must not be summarized as if it had none.
+                state.baseline = 'failed';
+                throw error;
+            }
+        });
+    }
+    /**
+     * Queue the capture of the path a file tool is about to mutate, before the
+     * tool runs; only the turn's first mutation of a path captures it. Await
+     * {@link settled} afterwards so the tool cannot overtake the capture.
+     * @param name - wire tool name.
+     * @param args - parsed call arguments.
+     */
+    capture(name, args) {
+        const path = mutationPath(name, args);
+        if (path === undefined)
+            return;
+        const state = this.state;
+        void this.enqueue(async () => {
+            const paths = this.paths;
+            if (paths === undefined)
+                return;
+            const absolute = await canonicalPath(resolve(paths.cwd, path));
+            if (state.captures.has(absolute))
+                return;
+            const capture = await captureFile(absolute, join(await this.scratchDir(), 'captures'), this.env.maxFileBytes);
+            if (capture !== undefined)
+                state.captures.set(absolute, capture);
+        });
+    }
+    /**
+     * Remember a settled tool result, so a record after `turn/end` covers it.
+     * @param event - the appended `tool/result` event.
+     */
+    observe(event) {
+        const state = this.state;
+        if (event.data.turn === state.turn)
+            state.lastToolResultSeq = event.seq;
+    }
+    /**
+     * Record the turn's changes inside the turn, before `turn/end` commits.
+     * @param turn - the stopping turn.
+     * @returns after the event is appended or the attempt failed.
+     */
+    stopping(turn) {
+        const state = this.state;
+        if (turn !== state.turn)
+            return Promise.resolve();
+        return this.enqueue(signal => this.record(state, signal));
+    }
+    /**
+     * Record after `turn/end` unless a record was already attempted after the turn's last tool result.
+     * @param turn - the turn number from `turn/end`.
+     */
+    end(turn) {
+        const state = this.state;
+        if (turn !== state.turn || state.attemptedAfterSeq >= state.lastToolResultSeq)
+            return;
+        void this.enqueue(signal => this.record(state, signal));
+    }
+    /** Resolves once every queued snapshot, capture, and record has settled. */
+    settled() {
+        return this.chain;
+    }
+    /**
+     * The summary announced by one `workspace/changes` event of this Session.
+     * @param seq - the event's sequence number.
+     * @returns the summary, or undefined for a sequence this recorder did not announce.
+     */
+    summary(seq) {
+        return this.records.get(seq)?.summary;
+    }
+    /**
+     * Every file this Session's recorded turns changed, folded by path.
+     *
+     * The per-file counts and flags come from the LATEST turn that listed the
+     * file, so a rewrite reads as the delta it left rather than as the churn of
+     * every rewrite; `turns` carries that churn. The Session totals come from
+     * each turn's own complete counts, which include files that turn's list cap
+     * omitted.
+     * @returns the folded list in `display` order, empty before the first recorded turn.
+     */
+    sessionChanges() {
+        const folded = new Map();
+        let added = 0;
+        let deleted = 0;
+        for (const [seq, record] of [...this.records].sort(([left], [right]) => left - right)) {
+            const { turn, files, added: turnAdded, deleted: turnDeleted } = record.summary;
+            added += turnAdded;
+            deleted += turnDeleted;
+            files.forEach((file, index) => {
+                const previous = folded.get(file.path);
+                folded.set(file.path, {
+                    path: file.path,
+                    display: file.display,
+                    added: file.added,
+                    deleted: file.deleted,
+                    turns: (previous?.turns ?? 0) + 1,
+                    lastTurn: turn,
+                    lastSeq: seq,
+                    lastIndex: index,
+                    ...(file.binary === true ? { binary: true } : {}),
+                    ...(file.oversized === true ? { oversized: true } : {}),
+                });
+            });
+        }
+        const files = [...folded.values()].sort((left, right) => left.display < right.display ? -1 : left.display > right.display ? 1 : 0);
+        return { cwd: this.cwd, files, total: files.length, added, deleted };
+    }
+    /**
+     * Compare one listed file's contents at turn start and turn end.
+     * @param seq - the announcing event's sequence number.
+     * @param index - the file's index in the summary's `files`.
+     * @param signal - cancels the reads.
+     * @returns the comparison, or undefined for an unknown sequence or index, or once disposed.
+     * @throws when a read fails while the recorder lives.
+     */
+    async diff(seq, index, signal) {
+        const record = this.records.get(seq);
+        const file = record?.summary.files[index];
+        const sources = record?.sources[index];
+        if (file === undefined || sources === undefined)
+            return undefined;
+        const { path, display } = file;
+        if (sources.refusal !== undefined)
+            return { kind: sources.refusal, path, display };
+        const combined = AbortSignal.any([signal, this.lifetime.signal]);
+        try {
+            const [before, after] = await Promise.all([this.readSide(sources.before, combined), this.readSide(sources.after, combined)]);
+            if (before === OVERSIZED || after === OVERSIZED)
+                return { kind: 'oversized', path, display };
+            const { hunks, coarse } = compareText(before, after, this.env.diffTimeoutMs);
+            return { kind: 'text', path, display, before: before !== null, after: after !== null, hunks, coarse };
+        }
+        catch (error) {
+            // Disposal removes the temporary directory under a running read; the Session is gone either way.
+            if (this.lifetime.signal.aborted)
+                return undefined;
+            throw error;
+        }
+    }
+    /**
+     * Abort queued work, forget every record, and remove the temporary directory.
+     * @returns once the temporary directory is gone.
+     */
+    async dispose() {
+        this.lifetime.abort();
+        this.records.clear();
+        await this.chain;
+        if (this.scratch !== undefined)
+            await rm(await this.scratch, { recursive: true, force: true });
+    }
+    enqueue(task) {
+        const run = this.chain.then(async () => {
+            if (this.lifetime.signal.aborted)
+                return;
+            try {
+                await task(this.lifetime.signal);
+            }
+            catch (error) {
+                this.warnUnlessDisposed(error);
+            }
+        });
+        this.chain = run;
+        return run;
+    }
+    /** A failure after disposal is expected cancellation and stays silent. */
+    warnUnlessDisposed(error) {
+        if (!this.lifetime.signal.aborted)
+            this.env.warn(`workspace-changes: ${String(error)}`);
+    }
+    /** This Session's temporary directory, created on first use. */
+    scratchDir() {
+        this.scratch ??= mkdtemp(join(this.env.tempRoot, 'qilin-workspace-changes-'));
+        return this.scratch;
+    }
+    /** The repository enclosing the working directory, located once; null keeps retrying each turn. */
+    async locate(cwd, signal) {
+        if (this.repository !== null)
+            return this.repository;
+        const git = await this.env.git;
+        if (git === null)
+            return null;
+        const workspace = await locateGitWorkspace(git, cwd, () => this.scratchDir(), signal);
+        if (workspace === null)
+            return null;
+        this.repository = { git, workspace };
+        return this.repository;
+    }
+    /** One side's text, null for an absent file, or {@link OVERSIZED} for a snapshot side beyond the byte cap. */
+    async readSide(source, signal) {
+        switch (source.kind) {
+            case 'absent': return null;
+            case 'file': return readFile(source.file, { encoding: 'utf8', signal });
+            case 'snapshot': {
+                const { git, workspace } = source.repository;
+                const blob = await treeBlob(git, workspace, source.tree, source.path, signal);
+                if (blob === null)
+                    return null;
+                if (blob.size > this.env.maxFileBytes)
+                    return OVERSIZED;
+                return blobText(git, workspace, blob.oid, this.env.maxFileBytes, signal);
+            }
+        }
+    }
+    async record(state, signal) {
+        const paths = this.paths;
+        const { baseline } = state;
+        if (paths === undefined || baseline === 'failed' || state.lastToolResultSeq < 0)
+            return;
+        state.attemptedAfterSeq = state.lastToolResultSeq;
+        // Without a snapshot the working directory itself bounds the workspace.
+        const root = baseline?.workspace.root ?? paths.cwd;
+        const listed = new Map();
+        let snapshot;
+        if (baseline !== null) {
+            const after = await snapshotTree(baseline.git, baseline.workspace, signal);
+            snapshot = { before: baseline.tree, after };
+            const repository = { git: baseline.git, workspace: baseline.workspace };
+            for (const entry of await diffTrees(baseline.git, baseline.workspace, baseline.tree, after, signal)) {
+                const absolute = resolve(root, entry.path);
+                listed.set(absolute, {
+                    file: changedFile(paths, root, absolute, entry),
+                    sources: entry.binary ? { refusal: 'binary' } : {
+                        before: { kind: 'snapshot', repository, tree: baseline.tree, path: entry.oldPath ?? entry.path },
+                        after: { kind: 'snapshot', repository, tree: after, path: entry.path },
+                    },
+                });
+            }
+        }
+        // Captured paths the snapshots do not cover are compared from their copies.
+        const captured = [...state.captures.keys()].filter(absolute => !listed.has(absolute));
+        const workTreePath = (absolute) => toPosix(relative(root, absolute));
+        let inWorkspace = captured.filter(absolute => isInside(root, absolute));
+        if (baseline !== null && inWorkspace.length > 0) {
+            // Nested repositories and submodules are gitlinks: their contents never enter the summary.
+            const gitlinks = await gitlinkPaths(baseline.git, baseline.workspace, signal);
+            inWorkspace = inWorkspace.filter(absolute => ![...gitlinks].some(link => isInside(resolve(root, link), absolute)));
+        }
+        // A snapshot covers every workspace file except the ignored ones; without one, every file-tool edit counts.
+        const uncoveredInWorkspace = baseline === null
+            ? new Set(inWorkspace.map(workTreePath))
+            : await ignoredPaths(baseline.git, baseline.workspace, inWorkspace.map(workTreePath), signal);
+        for (const absolute of captured) {
+            // Outside the workspace, scratch files under a temporary root stay out.
+            const uncovered = isInside(root, absolute)
+                ? uncoveredInWorkspace.has(workTreePath(absolute))
+                : !isTemporaryPath(absolute, paths.temporaryRoots);
+            if (!uncovered)
+                continue;
+            const before = state.captures.get(absolute);
+            const after = await captureFile(absolute, join(await this.scratchDir(), 'captures'), this.env.maxFileBytes);
+            if (after === undefined || sameCapture(before, after))
+                continue;
+            listed.set(absolute, await this.compared(paths, root, absolute, before, after));
+        }
+        const sorted = [...listed.values()].sort((a, b) => compareDisplay(a.file, b.file));
+        // An empty list after an earlier in-turn record supersedes that record.
+        if (sorted.length === 0 && state.recordedAfterSeq < 0)
+            return;
+        const event = this.session.append('workspace/changes', { turn: state.turn });
+        const kept = sorted.slice(0, this.env.maxFiles);
+        this.records.set(event.seq, {
+            summary: {
+                turn: state.turn,
+                cwd: this.cwd,
+                files: kept.map(entry => entry.file),
+                total: sorted.length,
+                added: sorted.reduce((sum, entry) => sum + entry.file.added, 0),
+                deleted: sorted.reduce((sum, entry) => sum + entry.file.deleted, 0),
+                ...snapshot === undefined ? {} : { snapshot },
+            },
+            sources: kept.map(entry => entry.sources),
+        });
+        state.recordedAfterSeq = event.seq;
+    }
+    /**
+     * The listing of a captured pair: an oversized side lists the file without
+     * counts and refuses its comparison, a binary side likewise, and two text
+     * sides carry the counts of their line comparison.
+     */
+    async compared(paths, root, absolute, before, after) {
+        const list = (counts, sources) => ({ file: changedFile(paths, root, absolute, counts), sources });
+        if (before.kind === 'oversized' || after.kind === 'oversized') {
+            return list({ added: 0, deleted: 0, binary: false, oversized: true }, { refusal: 'oversized' });
+        }
+        if (isBinary(before) || isBinary(after))
+            return list({ added: 0, deleted: 0, binary: true }, { refusal: 'binary' });
+        const text = async (side) => side.kind === 'file' ? readFile(side.file, 'utf8') : null;
+        const { added, deleted } = compareText(await text(before), await text(after), this.env.diffTimeoutMs);
+        return list({ added, deleted, binary: false }, { before, after });
+    }
+}
+/** Whether a captured side holds binary content. */
+function isBinary(capture) {
+    return capture.kind === 'file' && capture.binary;
+}
+function changedFile({ cwd, home }, root, absolute, counts) {
+    return {
+        path: durablePathOf(absolute, cwd),
+        display: displayPathOf(absolute, cwd, root, home),
+        added: counts.added,
+        deleted: counts.deleted,
+        ...counts.binary ? { binary: true } : {},
+        ...counts.oversized === true ? { oversized: true } : {},
+    };
+}
+//# sourceMappingURL=recorder.js.map

package/lib/types/types.d.ts

@@ -0,0 +1,163 @@
+/** Per-turn workspace change summaries, the Session event announcing them, and the Host service serving them with their comparisons. */
+import type { SessionId } from '@qilin-agent/session/types';
+/** One file changed during a turn, with line counts from git or from the whole-file captures around its file-tool edits. */
+export interface WorkspaceChangedFile {
+    /** Path relative to the Session working directory, or an absolute Host path outside it. */
+    path: string;
+    /**
+     * Sort key and label: the relative path inside the working directory, a
+     * `../` path for repository files above it, a `~` path under the home
+     * directory, otherwise the absolute path. Always slash-separated.
+     */
+    display: string;
+    /** Lines added; zero for a binary or oversized file. */
+    added: number;
+    /** Lines deleted; zero for a binary or oversized file. */
+    deleted: number;
+    /** Present when git reported the file as binary, or when a captured side holds a NUL byte. */
+    binary?: true;
+    /** Present when a captured side exceeded the plugin's `maxFileBytes`; the file is listed without counts or comparison. */
+    oversized?: true;
+}
+/** Files changed during one top-level turn, kept on the Host until its Session is disposed. */
+export interface WorkspaceChangesSummary {
+    /** The turn whose file changes this summary describes. */
+    turn: number;
+    /** The Session working directory `path` values are relative to. */
+    cwd: string;
+    /** Changed files in `display` order, capped at the plugin's `maxFiles`. */
+    files: WorkspaceChangedFile[];
+    /** Complete changed-file count, including files omitted by the cap. */
+    total: number;
+    /** Lines added over every changed file, including files omitted by the cap. */
+    added: number;
+    /** Lines deleted over every changed file, including files omitted by the cap. */
+    deleted: number;
+    /** Git tree ids of the turn-start and turn-end snapshots; absent when no snapshot was taken. */
+    snapshot?: {
+        before: string;
+        after: string;
+    };
+}
+/** One unified-diff hunk with three context lines; every line keeps its `+`, `-`, or space prefix. */
+export interface WorkspaceDiffHunk {
+    /** First line of the hunk in the turn-start content, 1-based; a side without lines starts at 1 with zero lines. */
+    oldStart: number;
+    /** Lines of the hunk taken from the turn-start content. */
+    oldLines: number;
+    /** First line of the hunk in the turn-end content, 1-based; a side without lines starts at 1 with zero lines. */
+    newStart: number;
+    /** Lines of the hunk taken from the turn-end content. */
+    newLines: number;
+    /** Hunk body in order, each line prefixed with `+`, `-`, or a space. */
+    lines: string[];
+}
+/** The comparison of one listed file's turn-start and turn-end contents, computed when asked for. */
+export type WorkspaceFileDiff = {
+    kind: 'text';
+    /** The listed file's `path`. */
+    path: string;
+    /** The listed file's `display`. */
+    display: string;
+    /** Whether the file existed at turn start. */
+    before: boolean;
+    /** Whether the file existed at turn end. */
+    after: boolean;
+    /** Hunks in file order; empty when both sides hold the same lines. */
+    hunks: WorkspaceDiffHunk[];
+    /** True when the line comparison exceeded the plugin's `diffTimeoutMs` and every line is shown as replaced. */
+    coarse: boolean;
+}
+/** A side git reported as binary or that holds a NUL byte; no lines are served. */
+ | {
+    kind: 'binary';
+    path: string;
+    display: string;
+}
+/** A side larger than the plugin's `maxFileBytes`; no lines are served. */
+ | {
+    kind: 'oversized';
+    path: string;
+    display: string;
+};
+/** One file the whole Session changed, folded over the turns whose summaries listed it. */
+export interface WorkspaceSessionChangedFile {
+    /** Path relative to the Session working directory, or an absolute Host path outside it. */
+    path: string;
+    /** Sort key and label, as the per-turn summary reports it. */
+    display: string;
+    /** Lines added by the latest turn that changed the file; zero for a binary or oversized file. */
+    added: number;
+    /** Lines deleted by the latest turn that changed the file; zero for a binary or oversized file. */
+    deleted: number;
+    /** How many turns listed the file, so a rewrite in a later turn counts again. */
+    turns: number;
+    /** The latest turn that changed the file. */
+    lastTurn: number;
+    /** The `workspace/changes` event of that latest turn. */
+    lastSeq: number;
+    /** The file's index in that event's summary, which `diff` addresses it by. */
+    lastIndex: number;
+    /** Present when the latest turn reported the file as binary. */
+    binary?: true;
+    /** Present when a captured side exceeded the plugin's `maxFileBytes` in the latest turn. */
+    oversized?: true;
+}
+/** Every file change one Session recorded, folded by path across its turns. */
+export interface WorkspaceSessionChanges {
+    /** The Session working directory `path` values are relative to. */
+    cwd: string;
+    /** Distinct changed files in `display` order. */
+    files: WorkspaceSessionChangedFile[];
+    /** Distinct changed files: the length of `files`. */
+    total: number;
+    /** Lines added over every turn, from the per-turn complete counts. */
+    added: number;
+    /** Lines deleted over every turn, from the per-turn complete counts. */
+    deleted: number;
+}
+/** Serves the summaries and file comparisons the recorder keeps for live Sessions. */
+export interface WorkspaceChanges {
+    /**
+     * The summary announced by one `workspace/changes` event.
+     * @param sessionId - the Session that appended the event.
+     * @param seq - the event's sequence number.
+     * @returns the summary, or undefined once its Session was disposed or when this Host never recorded it.
+     */
+    summary(sessionId: SessionId, seq: number): WorkspaceChangesSummary | undefined;
+    /**
+     * Every file the Session's recorded turns changed, folded by path.
+     * @param sessionId - the Session that appended the events.
+     * @returns the folded list, or undefined once its Session was disposed or when it recorded no turn.
+     */
+    session(sessionId: SessionId): WorkspaceSessionChanges | undefined;
+    /**
+     * Compare one listed file's contents at turn start and turn end.
+     * @param sessionId - the Session that appended the event.
+     * @param seq - the event's sequence number.
+     * @param index - the file's index in the summary's `files`.
+     * @param signal - cancels the reads.
+     * @returns the comparison, or undefined once its Session was disposed, when this Host never recorded it, or when no file has that index.
+     * @throws when a snapshot read fails for a live Session.
+     */
+    diff(sessionId: SessionId, seq: number, index: number, signal: AbortSignal): Promise<WorkspaceFileDiff | undefined>;
+}
+declare module '@qilin-agent/session/types' {
+    interface SessionEventMap {
+        /**
+         * A completed top-level turn's changed files were summarized; the summary itself stays on the
+         * Host and is served by `workspaceChanges.summary` for the event's sequence while the Session
+         * lives. The latest event for one turn replaces earlier ones.
+         */
+        'workspace/changes': {
+            turn: number;
+        };
+    }
+}
+declare module '@qilin-agent/kylin' {
+    interface Context {
+        /** Per-turn changed-file summaries and comparisons of live Sessions. */
+        workspaceChanges: WorkspaceChanges;
+    }
+}
+//# sourceMappingURL=types.d.ts.map

package/lib/types/types.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=types.js.map

package/package.json

@@ -1,6 +1,59 @@
 {
   "name": "@qilin-agent/workspace-changes",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
+  "description": "Per-turn workspace file changes recorded from git working-tree snapshots and whole-file captures, with per-file comparisons, for the QiLin",
+  "version": "3.1.4",
+  "publishConfig": {
+    "access": "public"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/kkutysllb/QiLin.git",
+    "directory": "packages/deliverables/workspace-changes"
+  },
+  "engines": {
+    "node": "^22.19.0 || >=24.0.0"
+  },
+  "type": "module",
+  "main": "lib/index.js",
+  "types": "lib/types/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./lib/types/index.d.ts",
+      "default": "./lib/index.js"
+    },
+    "./types": {
+      "types": "./lib/types/types.d.ts",
+      "default": "./lib/types/types.js"
+    },
+    "./src/*": "./src/*",
+    "./package.json": "./package.json"
+  },
+  "license": "MIT",
+  "files": [
+    "lib/index.js",
+    "lib/types/**/*.js",
+    "lib/types/**/*.d.ts"
+  ],
+  "dependencies": {
+    "diff": "^9.0.0",
+    "@qilin-agent/schemastery": "~3.18.3"
+  },
+  "peerDependencies": {
+    "@qilin-agent/kylin": "~4.0.3",
+    "@qilin-agent/agent": "3.1.4",
+    "@qilin-agent/session": "3.1.4",
+    "@qilin-agent/subprocess": "3.1.4",
+    "@qilin-agent/tools": "3.1.4"
+  },
+  "devDependencies": {
+    "@qilin-agent/kylin-plugin-include": "~1.0.8",
+    "@qilin-agent/kylin-plugin-loader": "~1.0.4",
+    "@qilin-agent/agent": "3.1.4",
+    "@qilin-agent/session": "3.1.4",
+    "@qilin-agent/kylin": "~4.0.3",
+    "@qilin-agent/subprocess-local": "3.1.4",
+    "@qilin-agent/subprocess": "3.1.4",
+    "@qilin-agent/tools": "3.1.4",
+    "@qilin-agent/llm": "3.1.4"
+  }
 }