@orion-agents/orion-code 0.3.22 → 0.3.25

package/dist/services/repo-intelligence/recall.js

@@ -0,0 +1,115 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.recallFiles = recallFiles;
+exports.selectWithinBudget = selectWithinBudget;
+const basenameOf = (path) => path.split('/').pop() ?? path;
+const testPairOf = (path) => {
+    const normalized = path.split('\\').join('/');
+    const testMatch = /^(?:tests?\/)(.+)\.(?:test|spec)\.[cm]?[jt]sx?$/.exec(normalized);
+    if (testMatch) {
+        const base = testMatch[1];
+        for (const candidate of [`src/${base}.ts`, `src/${base}.tsx`, `src/${base}.js`]) {
+            return candidate;
+        }
+    }
+    const srcMatch = /^src\/(.+)\.[cm]?[jt]sx?$/.exec(normalized);
+    if (srcMatch) {
+        const base = srcMatch[1];
+        return `tests/${base}.test.ts`;
+    }
+    return undefined;
+};
+function recallFiles(index, options) {
+    const limit = options.limit ?? 20;
+    const snapshot = index.getSnapshot();
+    const intentLower = options.intent.toLowerCase();
+    const activeSet = new Set(options.activeFiles.map(path => path.split('\\').join('/')));
+    const changedSet = new Set((options.changedFiles ?? []).map(path => path.split('\\').join('/')));
+    // Symbols explicitly named in the intent (quoted or camel-cased tokens).
+    const intentSymbols = new Set();
+    for (const match of options.intent.matchAll(/[A-Za-z_$][\w$]{2,}/g)) {
+        intentSymbols.add(match[0]);
+    }
+    const scores = new Map();
+    const bump = (path, points, reason) => {
+        const normalized = path.split('\\').join('/');
+        const entry = scores.get(normalized) ?? { score: 0, reasons: new Set() };
+        entry.score += points;
+        entry.reasons.add(reason);
+        scores.set(normalized, entry);
+    };
+    for (const [path, record] of snapshot) {
+        const base = basenameOf(path);
+        // Direct mention: the intent names the file path or its basename.
+        if (intentLower.includes(path.toLowerCase()) || intentLower.includes(base.toLowerCase())) {
+            bump(path, 50, 'mentioned in the task intent');
+        }
+        // Symbol match: an intent token matches a symbol defined in this file.
+        for (const symbol of record.symbols) {
+            if (symbol.name.length >= 4 && intentSymbols.has(symbol.name)) {
+                bump(path, 30, `defines symbol ${symbol.name}`);
+                break;
+            }
+        }
+        // Import adjacency to active files.
+        for (const active of activeSet) {
+            if (record.imports.includes(active)) {
+                bump(path, 20, `imports the active file ${active}`);
+            }
+            if (snapshot.get(active)?.imports.includes(path)) {
+                bump(path, 20, `imported by the active file ${active}`);
+            }
+        }
+        // Test pairing.
+        const pair = testPairOf(path);
+        if (pair && (activeSet.has(pair) || changedSet.has(pair))) {
+            bump(path, 15, `paired with ${pair}`);
+        }
+        // Recent change.
+        if (changedSet.has(path)) {
+            bump(path, 10, 'in the current change-set');
+        }
+    }
+    return [...scores.entries()]
+        .map(([path, entry]) => ({
+        path,
+        score: entry.score,
+        reasons: [...entry.reasons].sort(),
+    }))
+        .sort((left, right) => right.score - left.score || left.path.localeCompare(right.path))
+        .slice(0, limit);
+}
+/**
+ * Budget-aware selection: rank candidates, deduplicate by directory concentration
+ * (at most `maxPerDirectory` per immediate directory), and always keep explicitly
+ * active files (the user touched them — they are never dropped for budget).
+ */
+function selectWithinBudget(candidates, options) {
+    const maxFiles = options.maxFiles ?? 12;
+    const maxPerDirectory = options.maxPerDirectory ?? 4;
+    const activeSet = new Set(options.activeFiles.map(path => path.split('\\').join('/')));
+    const perDirectory = new Map();
+    const selected = [];
+    for (const candidate of candidates) {
+        const normalized = candidate.path.split('\\').join('/');
+        if (selected.length >= maxFiles)
+            break;
+        const directory = normalized.split('/').slice(0, -1).join('/');
+        const isProtected = activeSet.has(normalized);
+        const count = perDirectory.get(directory) ?? 0;
+        if (!isProtected && count >= maxPerDirectory)
+            continue;
+        selected.push(candidate);
+        perDirectory.set(directory, count + 1);
+    }
+    // Active files that scoring missed are still kept (user-touched is sacred).
+    for (const active of activeSet) {
+        if (selected.length >= maxFiles)
+            break;
+        if (!selected.some(candidate => candidate.path === active)) {
+            selected.push({ path: active, score: 0, reasons: ['active file (user-pinned)'] });
+        }
+    }
+    return selected;
+}
+//# sourceMappingURL=recall.js.map

package/dist/services/repo-intelligence/symbol-index.d.ts

@@ -0,0 +1,52 @@
+export interface RepoSymbolEntryV1 {
+    readonly name: string;
+    readonly kind: 'function' | 'class' | 'interface' | 'type' | 'enum' | 'const' | 'let' | 'var' | 'method';
+    readonly file: string;
+    readonly line: number;
+    readonly exported: boolean;
+}
+export interface RepoFileRecordV1 {
+    /** Workspace-relative POSIX-style path. */
+    readonly path: string;
+    readonly mtimeMs: number;
+    readonly size: number;
+    readonly symbols: readonly RepoSymbolEntryV1[];
+    /** Workspace-relative paths this file imports (relative specifiers only). */
+    readonly imports: readonly string[];
+    readonly exportedNames: readonly string[];
+}
+export interface RepoIndexStatsV1 {
+    readonly files: number;
+    readonly parsed: number;
+    readonly skipped: number;
+    readonly symbols: number;
+    readonly durationMs: number;
+    readonly incremental: boolean;
+}
+export interface RepoSymbolIndexOptionsV1 {
+    readonly include?: readonly string[];
+    readonly ignore?: readonly string[];
+    readonly maxFiles?: number;
+}
+/**
+ * The workspace symbol index. Construction does not parse anything; call
+ * `build()` (full) or `update()` (incremental).
+ */
+export declare class RepoSymbolIndexV1 {
+    private readonly root;
+    private readonly ignore;
+    private readonly maxFiles;
+    private readonly files;
+    private readonly digests;
+    constructor(root: string, options?: RepoSymbolIndexOptionsV1);
+    get workspaceRoot(): string;
+    /** Full build: parse every source file under the root. */
+    build(): RepoIndexStatsV1;
+    /** Incremental update: re-parse only files whose digest changed or that are new. */
+    update(): RepoIndexStatsV1;
+    getSnapshot(): ReadonlyMap<string, RepoFileRecordV1>;
+    findSymbol(name: string): readonly RepoSymbolEntryV1[];
+    importersOf(relativePath: string): readonly string[];
+    invalidate(relativePath: string): void;
+}
+//# sourceMappingURL=symbol-index.d.ts.map

package/dist/services/repo-intelligence/symbol-index.js

@@ -0,0 +1,258 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RepoSymbolIndexV1 = void 0;
+/**
+ * v0.3.23 T23-B1/B2 — lightweight repository symbol index.
+ *
+ * Parses TypeScript/JavaScript sources with the compiler API (already a
+ * dependency) into a per-file record: symbols (functions/classes/interfaces/
+ * types/enums), their exportedness, and resolved relative import edges.
+ *
+ * Maintenance is incremental: each file keeps a mtime+size digest, and
+ * `update()` re-parses only the stale subset. The index never reads file
+ * CONTENT beyond parsing — it follows the workspace root and skips the usual
+ * high-noise directories (node_modules, dist, .git, hidden, build outputs).
+ */
+const fs_1 = require("fs");
+const path_1 = require("path");
+const typescript_1 = __importDefault(require("typescript"));
+const DEFAULT_IGNORE = [
+    'node_modules',
+    'dist',
+    'build',
+    'out',
+    '.git',
+    'coverage',
+    '.cache',
+    'target',
+    'vendor',
+    '__pycache__',
+];
+const SOURCE_EXTENSIONS = new Set(['.ts', '.tsx', '.js', '.jsx', '.mjs', '.cjs']);
+function isSourceFile(path) {
+    return SOURCE_EXTENSIONS.has(path.slice(path.lastIndexOf('.')));
+}
+/** Walk the workspace root collecting source files (bounded). */
+function walkSources(root, ignore, maxFiles) {
+    const paths = [];
+    let skipped = 0;
+    const visit = (directory) => {
+        if (paths.length >= maxFiles)
+            return;
+        let entries;
+        try {
+            entries = (0, fs_1.readdirSync)(directory);
+        }
+        catch {
+            return;
+        }
+        for (const entry of entries) {
+            if (paths.length >= maxFiles)
+                return;
+            if (entry.startsWith('.') || ignore.has(entry))
+                continue;
+            const absolute = (0, path_1.join)(directory, entry);
+            let stats;
+            try {
+                stats = (0, fs_1.statSync)(absolute);
+            }
+            catch {
+                continue;
+            }
+            if (stats.isDirectory())
+                visit(absolute);
+            else if (stats.isFile() && isSourceFile(entry)) {
+                if (paths.length < maxFiles)
+                    paths.push(absolute);
+                else
+                    skipped += 1;
+            }
+        }
+    };
+    visit(root);
+    return { paths, skipped };
+}
+function fileDigest(stats) {
+    return `${Math.round(stats.mtimeMs)}:${stats.size}`;
+}
+/** Extract symbols + import edges from one source file. */
+function parseSource(root, absolutePath) {
+    const relativePath = (0, path_1.relative)(root, absolutePath).split('\\').join('/');
+    const source = typescript_1.default.createSourceFile(absolutePath, (0, fs_1.readFileSync)(absolutePath, 'utf8'), typescript_1.default.ScriptTarget.Latest, true);
+    const symbols = [];
+    const imports = [];
+    const exportedNames = [];
+    const lineOf = (node) => source.getLineAndCharacterOfPosition(node.getStart(source)).line + 1;
+    const push = (node, name, kind, exported) => {
+        if (!name)
+            return;
+        symbols.push({ name, kind, file: relativePath, line: lineOf(node), exported });
+        if (exported)
+            exportedNames.push(name);
+    };
+    const visit = (node) => {
+        if (typescript_1.default.isImportDeclaration(node) && typescript_1.default.isStringLiteral(node.moduleSpecifier)) {
+            const specifier = node.moduleSpecifier.text;
+            if (specifier.startsWith('.')) {
+                const resolvedBase = (0, path_1.resolve)((0, path_1.dirname)(absolutePath), specifier);
+                for (const candidate of [
+                    resolvedBase,
+                    `${resolvedBase}.ts`,
+                    `${resolvedBase}.tsx`,
+                    `${resolvedBase}.js`,
+                    `${resolvedBase}.jsx`,
+                    (0, path_1.join)(resolvedBase, 'index.ts'),
+                    (0, path_1.join)(resolvedBase, 'index.js'),
+                ]) {
+                    if ((0, fs_1.existsSync)(candidate) && !(0, fs_1.statSync)(candidate).isDirectory()) {
+                        imports.push((0, path_1.relative)(root, candidate).split('\\').join('/'));
+                        break;
+                    }
+                }
+            }
+        }
+        if (typescript_1.default.isFunctionDeclaration(node) && node.name)
+            push(node, node.name.text, 'function', node.modifiers?.some(m => m.kind === typescript_1.default.SyntaxKind.ExportKeyword) === true);
+        else if (typescript_1.default.isClassDeclaration(node) && node.name)
+            push(node, node.name.text, 'class', node.modifiers?.some(m => m.kind === typescript_1.default.SyntaxKind.ExportKeyword) === true);
+        else if (typescript_1.default.isInterfaceDeclaration(node) && node.name)
+            push(node, node.name.text, 'interface', node.modifiers?.some(m => m.kind === typescript_1.default.SyntaxKind.ExportKeyword) === true);
+        else if (typescript_1.default.isTypeAliasDeclaration(node) && node.name)
+            push(node, node.name.text, 'type', node.modifiers?.some(m => m.kind === typescript_1.default.SyntaxKind.ExportKeyword) === true);
+        else if (typescript_1.default.isEnumDeclaration(node) && node.name)
+            push(node, node.name.text, 'enum', node.modifiers?.some(m => m.kind === typescript_1.default.SyntaxKind.ExportKeyword) === true);
+        else if (typescript_1.default.isVariableStatement(node)) {
+            const exported = node.modifiers?.some(m => m.kind === typescript_1.default.SyntaxKind.ExportKeyword) === true;
+            for (const declaration of node.declarationList.declarations) {
+                if (typescript_1.default.isIdentifier(declaration.name)) {
+                    const kind = declaration.name.getText(source).length > 0 &&
+                        node.declarationList.flags & typescript_1.default.NodeFlags.Const
+                        ? 'const'
+                        : node.declarationList.flags & typescript_1.default.NodeFlags.Let
+                            ? 'let'
+                            : 'var';
+                    push(node, declaration.name.text, kind, exported);
+                }
+            }
+        }
+        else if ((typescript_1.default.isMethodDeclaration(node) || typescript_1.default.isPropertyDeclaration(node)) &&
+            typescript_1.default.isIdentifier(node.name)) {
+            push(node, node.name.text, 'method', false);
+        }
+        typescript_1.default.forEachChild(node, visit);
+    };
+    typescript_1.default.forEachChild(source, visit);
+    return { symbols, imports, exportedNames };
+}
+/**
+ * The workspace symbol index. Construction does not parse anything; call
+ * `build()` (full) or `update()` (incremental).
+ */
+class RepoSymbolIndexV1 {
+    constructor(root, options = {}) {
+        this.files = new Map();
+        this.digests = new Map();
+        this.root = (0, path_1.resolve)(root);
+        this.ignore = new Set([...DEFAULT_IGNORE, ...(options.ignore ?? [])]);
+        this.maxFiles = options.maxFiles ?? 5000;
+    }
+    get workspaceRoot() {
+        return this.root;
+    }
+    /** Full build: parse every source file under the root. */
+    build() {
+        this.files.clear();
+        this.digests.clear();
+        return this.update();
+    }
+    /** Incremental update: re-parse only files whose digest changed or that are new. */
+    update() {
+        const startedAt = Date.now();
+        const { paths, skipped } = walkSources(this.root, this.ignore, this.maxFiles);
+        const seen = new Set();
+        let parsed = 0;
+        let symbolCount = 0;
+        for (const absolute of paths) {
+            const relativePath = (0, path_1.relative)(this.root, absolute).split('\\').join('/');
+            seen.add(relativePath);
+            let stats;
+            try {
+                stats = (0, fs_1.statSync)(absolute);
+            }
+            catch {
+                continue;
+            }
+            const digest = fileDigest(stats);
+            const existing = this.digests.get(relativePath);
+            if (existing === digest && this.files.has(relativePath)) {
+                symbolCount += this.files.get(relativePath)?.symbols.length ?? 0;
+                continue;
+            }
+            try {
+                const parsedFile = parseSource(this.root, absolute);
+                const record = {
+                    path: relativePath,
+                    mtimeMs: stats.mtimeMs,
+                    size: stats.size,
+                    symbols: parsedFile.symbols,
+                    imports: parsedFile.imports,
+                    exportedNames: parsedFile.exportedNames,
+                };
+                this.files.set(relativePath, record);
+                this.digests.set(relativePath, digest);
+                parsed += 1;
+                symbolCount += record.symbols.length;
+            }
+            catch {
+                // Unparsable source: skip it; a later update will retry.
+            }
+        }
+        // Drop records for files that no longer exist.
+        for (const path of [...this.files.keys()]) {
+            if (!seen.has(path)) {
+                this.files.delete(path);
+                this.digests.delete(path);
+            }
+        }
+        return {
+            files: this.files.size,
+            parsed,
+            skipped,
+            symbols: symbolCount,
+            durationMs: Math.max(0, Date.now() - startedAt),
+            incremental: this.files.size > 0 && parsed < this.files.size,
+        };
+    }
+    getSnapshot() {
+        return new Map(this.files);
+    }
+    findSymbol(name) {
+        const results = [];
+        for (const record of this.files.values()) {
+            for (const symbol of record.symbols) {
+                if (symbol.name === name)
+                    results.push(symbol);
+            }
+        }
+        return results;
+    }
+    importersOf(relativePath) {
+        const normalized = relativePath.split('\\').join('/');
+        const results = [];
+        for (const record of this.files.values()) {
+            if (record.imports.includes(normalized))
+                results.push(record.path);
+        }
+        return results;
+    }
+    invalidate(relativePath) {
+        const normalized = relativePath.split('\\').join('/');
+        this.files.delete(normalized);
+        this.digests.delete(normalized);
+    }
+}
+exports.RepoSymbolIndexV1 = RepoSymbolIndexV1;
+//# sourceMappingURL=symbol-index.js.map

package/dist/services/session-storage.d.ts

@@ -412,6 +412,8 @@ export declare function getProjectKey(projectPath: string): string;
 export declare function isSessionMetaFile(file: string): boolean;
 /** Shared exclusion list for session sidecar files. */
 export declare const SESSION_SIDECAR_SUFFIXES: string[];
+/** Warm/rebuild the global read model without synchronous lock retry or scan. */
+export declare function prepareSessionCatalogAsync(waitMs?: number): Promise<void>;
 /** Capture the append-only transcript identity before preparing a compact candidate. */
 export declare function prepareSessionCompactSourceReceipt(sessionId: string): CompactPrepareSourceReceipt;
 /**
@@ -422,8 +424,22 @@ export declare function prepareSessionCompactSourceReceipt(sessionId: string): C
 export declare function advanceSessionCompactSourceReceipt(receipt: CompactPrepareSourceReceipt, appendedMessages: readonly SessionMessage[]): CompactPrepareSourceReceipt;
 /**
  * 创建新会话
- */
-export declare function createSession(projectPath: string, model: string): SessionMeta;
+ * @param options Optional pre-probed Git metadata. Supplying this object skips synchronous Git.
+ */
+export declare function createSession(projectPath: string, model: string, options?: {
+    readonly gitBranch?: string;
+}): SessionMeta;
+/**
+ * Web creation waits for cross-process metadata/catalog locks asynchronously.
+ * Both locks are acquired before any Session bytes are written. The original
+ * synchronous lock owner/recovery and atomic publication remain authoritative.
+ */
+export declare function createSessionAsync(projectPath: string, model: string, options?: {
+    readonly gitBranch?: string;
+    readonly name?: string;
+    readonly waitMs?: number;
+    readonly beforeCommit?: () => void;
+}): Promise<SessionMeta>;
 /**
  * 保存会话元数据
  */