engineering-memory 1.11.15 → 1.11.16

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "engineering-memory",
-  "version": "1.11.15",
+  "version": "1.11.16",
   "description": "Installs the Engineering Memory skill and its local MCP bridge. Sign in after installing; your organization and project are resolved from your account.",
   "license": "UNLICENSED",
   "type": "module",

package/runtime/build.json

@@ -1,3 +1,3 @@
 {
-  "gitHead": "52f278262fad1afde8d11aa6e2343b3de5e8fe78"
+  "gitHead": "9623849ae66a8cc72716533cb131790a4c517ac7"
 }

package/runtime/dist/src/runtime/bridge-service.js

@@ -544,7 +544,7 @@ export class BridgeService {
                 if ((!sourceCommit && !(previous && previous.baseCommit === null && !previous.managed)) ||
                     branch === undefined)
                     throw refuse('The task branch and base must be restored before resuming its worktree.', 'worktree.reconcile');
-                const allocation = await pool.allocate({
+                const allocation = await pool.prepare(await pool.allocate({
                     projectId,
                     projectName: projectId,
                     repoFingerprint: repository.repoFingerprint,
@@ -554,7 +554,7 @@ export class BridgeService {
                     baseCommit: sourceCommit ?? null,
                     keepCurrent: previous ? !previous.managed : false,
                     resume: true,
-                }, await this.poolPolicy());
+                }, await this.poolPolicy()));
                 await pool.bind(projectId, allocation.repoRoot, allocation.generation, pointer.taskId);
                 allocation.taskId = pointer.taskId;
                 this.poolAllocations.set(allocation.repoRoot, allocation);
@@ -2615,7 +2615,7 @@ export class BridgeService {
         const allocationTimer = startPhaseTimer('task.branch.allocate');
         const allocationPolicy = await this.poolPolicy(true);
         allocationTimer.mark('policy');
-        const allocation = await pool.allocate({
+        const allocation = await pool.prepare(await pool.allocate({
             projectId,
             projectName: preferences.projectName ?? projectId,
             repoFingerprint: repository.repoFingerprint,
@@ -2626,7 +2626,7 @@ export class BridgeService {
             keepCurrent: input.keepCurrent,
             inPlace: !existing && input.inPlace,
             resume: Boolean(existing),
-        }, allocationPolicy);
+        }, allocationPolicy));
         allocationTimer.mark('pool_allocate');
         allocationTimer.finish();
         this.poolAllocations.set(allocation.repoRoot, allocation);
@@ -2648,7 +2648,7 @@ export class BridgeService {
         return asJsonValue({
             ...allocation,
             kept: !allocation.managed,
-            nextAction: 'Run every file, terminal, lifecycle and delivery operation from this repoRoot. Use task.heartbeat during long work. Pause before handing the task to another client.',
+            nextAction: 'Run every file, terminal, lifecycle and delivery operation from this repoRoot. Inspect readiness separately: a file problem does not cancel the task, and an editor request does not prove its window is visible. Resolve reported local file issues without overwriting existing files, then retry task.branch or session.resume. Use task.heartbeat during long work and pause before handoff.',
         });
     }
     adoptOwned(repoRoot, entry) {

package/runtime/dist/src/runtime/worktree-editor.js

@@ -0,0 +1,184 @@
+import { spawn } from 'node:child_process';
+import { constants } from 'node:fs';
+import { access, open, realpath, stat } from 'node:fs/promises';
+import { delimiter, dirname, isAbsolute, join, resolve } from 'node:path';
+export var WorktreeEditorStatus;
+(function (WorktreeEditorStatus) {
+    WorktreeEditorStatus["Requested"] = "requested";
+    WorktreeEditorStatus["Unavailable"] = "unavailable";
+    WorktreeEditorStatus["Failed"] = "failed";
+    WorktreeEditorStatus["Skipped"] = "skipped";
+})(WorktreeEditorStatus || (WorktreeEditorStatus = {}));
+export async function openWorktreeInEditor(repoRoot) {
+    if (!['win32', 'darwin', 'linux'].includes(process.platform) ||
+        (process.env.CI && !/^(false|0)$/i.test(process.env.CI)) ||
+        process.env.SSH_CONNECTION ||
+        process.env.SSH_CLIENT ||
+        process.env.SSH_TTY ||
+        process.env.VSCODE_AGENT_FOLDER ||
+        process.env.VSCODE_REMOTE_NAME ||
+        process.env.WSL_DISTRO_NAME ||
+        process.env.CODESPACES === 'true' ||
+        process.env.SESSIONNAME?.toLowerCase() === 'services' ||
+        (process.platform === 'linux' && !process.env.DISPLAY && !process.env.WAYLAND_DISPLAY)) {
+        return {
+            status: WorktreeEditorStatus.Skipped,
+            detail: 'A local desktop session is not available.',
+        };
+    }
+    let folder;
+    try {
+        if (!repoRoot.trim())
+            throw new Error();
+        folder = await realpath(resolve(repoRoot));
+        if (!(await stat(folder)).isDirectory())
+            throw new Error();
+    }
+    catch {
+        return {
+            status: WorktreeEditorStatus.Failed,
+            detail: 'The worktree folder is not accessible.',
+        };
+    }
+    const command = await findEditor().catch(() => null);
+    if (!command) {
+        return {
+            status: WorktreeEditorStatus.Unavailable,
+            detail: 'An installed local VS Code CLI was not found.',
+        };
+    }
+    if (/[\\/](?:\.vscode-server(?:-insiders)?|remote-cli)[\\/]/i.test(command.executable)) {
+        return {
+            status: WorktreeEditorStatus.Skipped,
+            detail: 'The available VS Code CLI belongs to a remote session.',
+        };
+    }
+    const env = { ...process.env };
+    delete env.VSCODE_DEV;
+    if (process.platform === 'win32')
+        env.ELECTRON_RUN_AS_NODE = '1';
+    try {
+        return await new Promise((resolveResult) => {
+            const child = spawn(command.executable, [...command.args, '--new-window', folder], {
+                cwd: folder,
+                env,
+                shell: false,
+                windowsHide: true,
+                stdio: ['ignore', 'pipe', 'pipe'],
+            });
+            let settled = false;
+            let outputBytes = 0;
+            const timer = setTimeout(() => stop('The VS Code request timed out; window state is unknown.'), 10_000);
+            const finish = (status, detail) => {
+                if (settled)
+                    return;
+                settled = true;
+                clearTimeout(timer);
+                child.stdout.destroy();
+                child.stderr.destroy();
+                child.unref();
+                resolveResult({ status, detail });
+            };
+            const stop = (detail) => {
+                if (settled)
+                    return;
+                try {
+                    child.kill('SIGKILL');
+                }
+                finally {
+                    finish(WorktreeEditorStatus.Failed, detail);
+                }
+            };
+            const discardOutput = (chunk) => {
+                outputBytes += chunk.length;
+                if (outputBytes > 65_536) {
+                    stop('The VS Code CLI exceeded the output limit; window state is unknown.');
+                }
+            };
+            child.stdout.on('data', discardOutput);
+            child.stderr.on('data', discardOutput);
+            child.once('error', () => finish(WorktreeEditorStatus.Failed, 'The VS Code CLI could not start.'));
+            child.once('close', (code) => finish(code === 0 ? WorktreeEditorStatus.Requested : WorktreeEditorStatus.Failed, code === 0
+                ? 'VS Code launch requested; window state was not verified.'
+                : 'The VS Code CLI failed; window state is unknown.'));
+        });
+    }
+    catch {
+        return { status: WorktreeEditorStatus.Failed, detail: 'The VS Code CLI could not start.' };
+    }
+}
+async function findEditor() {
+    const directories = (process.env.PATH ?? '')
+        .split(delimiter)
+        .map((directory) => directory.replace(/^"(.+)"$/, '$1'))
+        .filter(isAbsolute)
+        .slice(0, 128);
+    if (process.platform === 'win32') {
+        for (const root of [
+            process.env.LOCALAPPDATA && join(process.env.LOCALAPPDATA, 'Programs'),
+            process.env.ProgramFiles,
+            process.env['ProgramFiles(x86)'],
+        ]) {
+            if (root && isAbsolute(root))
+                directories.push(join(root, 'Microsoft VS Code', 'bin'));
+        }
+    }
+    for (const directory of new Set(directories)) {
+        if (process.platform === 'win32') {
+            const command = await windowsEditor(directory);
+            if (command)
+                return command;
+        }
+        else {
+            const executable = join(directory, 'code');
+            if (await executableFile(executable)) {
+                return { executable: await realpath(executable), args: [] };
+            }
+        }
+    }
+    return null;
+}
+async function windowsEditor(bin) {
+    let handle;
+    try {
+        const launcher = await realpath(join(bin, 'code.cmd'));
+        handle = await open(launcher, 'r');
+        const info = await handle.stat();
+        if (!info.isFile() || info.size > 16_384)
+            return null;
+        const bytes = Buffer.alloc(16_385);
+        const { bytesRead } = await handle.read(bytes, 0, bytes.length, 0);
+        if (bytesRead > 16_384)
+            return null;
+        const match = bytes
+            .subarray(0, bytesRead)
+            .toString('utf8')
+            .match(/^[ \t]*"%~dp0\.\.\\Code\.exe"[ \t]+"%~dp0\.\.\\((?:[a-f0-9]{7,40}\\)?resources\\app\\out\\cli\.js)"[ \t]+%\*[ \t]*\r?$/im);
+        if (!match)
+            return null;
+        const installation = resolve(dirname(launcher), '..');
+        const executable = join(installation, 'Code.exe');
+        const cli = join(installation, match[1]);
+        if (!(await executableFile(executable)) || !(await stat(cli)).isFile())
+            return null;
+        return { executable, args: [cli] };
+    }
+    catch {
+        return null;
+    }
+    finally {
+        await handle?.close();
+    }
+}
+async function executableFile(path) {
+    try {
+        if (!(await stat(path)).isFile())
+            return false;
+        await access(path, process.platform === 'win32' ? constants.F_OK : constants.X_OK);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+//# sourceMappingURL=worktree-editor.js.map

package/runtime/dist/src/runtime/worktree-gradle.js

@@ -0,0 +1,318 @@
+function unsupported() {
+    throw new Error('Unsupported or ambiguous Gradle signing configuration');
+}
+function tokenize(text) {
+    if (text.length > 256 * 1024)
+        unsupported();
+    const tokens = [];
+    let cursor = 0;
+    while (cursor < text.length) {
+        if (/\s/.test(text[cursor])) {
+            cursor++;
+            continue;
+        }
+        if (text.startsWith('//', cursor)) {
+            while (cursor < text.length && !/[\r\n]/.test(text[cursor]))
+                cursor++;
+            continue;
+        }
+        if (text.startsWith('/*', cursor)) {
+            let depth = 1;
+            cursor += 2;
+            while (cursor < text.length && depth) {
+                if (text.startsWith('/*', cursor)) {
+                    depth++;
+                    cursor += 2;
+                }
+                else if (text.startsWith('*/', cursor)) {
+                    depth--;
+                    cursor += 2;
+                }
+                else
+                    cursor++;
+            }
+            if (depth)
+                unsupported();
+            continue;
+        }
+        const start = cursor;
+        const quote = text[cursor];
+        if (quote === '"' || quote === "'") {
+            if (text.startsWith(quote.repeat(3), cursor)) {
+                const end = text.indexOf(quote.repeat(3), cursor + 3);
+                if (end < 0)
+                    unsupported();
+                cursor = end + 3;
+                tokens.push({ kind: 'string', value: '', literal: false, start, end: cursor });
+                continue;
+            }
+            cursor++;
+            let value = '';
+            let literal = true;
+            while (cursor < text.length && text[cursor] !== quote) {
+                let character = text[cursor++];
+                if (/[\r\n]/.test(character))
+                    unsupported();
+                if (character === '\\') {
+                    character = text[cursor++] ?? '';
+                    if (character === 'u') {
+                        const digits = text.slice(cursor, cursor + 4);
+                        if (!/^[a-fA-F0-9]{4}$/.test(digits))
+                            unsupported();
+                        value += String.fromCharCode(parseInt(digits, 16));
+                        cursor += 4;
+                    }
+                    else if ('\\\'"'.includes(character) && character)
+                        value += character;
+                    else {
+                        literal = false;
+                        value += character;
+                    }
+                }
+                else {
+                    if (character === '$')
+                        literal = false;
+                    value += character;
+                }
+            }
+            if (text[cursor++] !== quote)
+                unsupported();
+            tokens.push({ kind: 'string', value, literal, start, end: cursor });
+            continue;
+        }
+        const word = /^[A-Za-z_$][A-Za-z0-9_$]*/.exec(text.slice(cursor))?.[0];
+        cursor += word?.length ?? 1;
+        tokens.push({ kind: word ? 'word' : 'symbol', value: word ?? quote, start, end: cursor });
+    }
+    return tokens;
+}
+export function parseGradleSigning(text) {
+    const tokens = tokenize(text);
+    const signing = tokens.flatMap((token, index) => token.kind === 'word' && ['storeFile', 'setStoreFile'].includes(token.value) ? [index] : []);
+    if (!signing.length)
+        return null;
+    const value = (index) => tokens[index]?.value;
+    const expect = (index, expected) => {
+        if (value(index) !== expected || tokens[index]?.kind === 'string')
+            unsupported();
+        return index + 1;
+    };
+    const word = (index) => {
+        if (tokens[index]?.kind !== 'word')
+            unsupported();
+        return tokens[index].value;
+    };
+    const literal = (index) => {
+        const token = tokens[index];
+        if (token?.kind !== 'string' || !token.literal || !token.value || token.value.includes('$'))
+            unsupported();
+        return token.value;
+    };
+    const scopes = [];
+    const braces = [];
+    for (const [index, token] of tokens.entries()) {
+        scopes.push(braces.at(-1) ?? -1);
+        if (token.kind !== 'symbol')
+            continue;
+        if (token.value === '{')
+            braces.push(index);
+        if (token.value === '}' && braces.pop() === undefined)
+            unsupported();
+    }
+    if (braces.length)
+        unsupported();
+    const startStatement = (index) => {
+        if (!index ||
+            (tokens[index - 1]?.kind === 'symbol' && [';', '{', '}'].includes(value(index - 1))))
+            return;
+        const previous = value(index - 1);
+        if (!/[\r\n]/.test(text.slice(tokens[index - 1].end, tokens[index].start)) ||
+            ['=', '(', '[', ',', '.', '?', ':', '+', '-', '*', '/', 'else', 'do'].includes(previous))
+            unsupported();
+        if (previous === ')') {
+            let cursor = index - 1;
+            let depth = 0;
+            do {
+                if (tokens[cursor]?.kind !== 'string') {
+                    if (value(cursor) === ')')
+                        depth++;
+                    if (value(cursor) === '(')
+                        depth--;
+                }
+                cursor--;
+            } while (cursor >= 0 && depth);
+            if (['if', 'for', 'while', 'when', 'catch'].includes(value(cursor)))
+                unsupported();
+        }
+    };
+    const endStatement = (index) => {
+        if (index === tokens.length ||
+            (tokens[index]?.kind === 'symbol' && [';', '}'].includes(value(index))))
+            return;
+        const gap = text.slice(tokens[index - 1].end, tokens[index].start);
+        if (!/[\r\n]/.test(gap) ||
+            [
+                '.',
+                '?',
+                '+',
+                '-',
+                '*',
+                '/',
+                '%',
+                '[',
+                '(',
+                '=',
+                '&',
+                '|',
+                '^',
+                '<',
+                '>',
+                '!',
+                '{',
+                ':',
+                ',',
+                'as',
+                'in',
+                'instanceof',
+            ].includes(value(index)))
+            unsupported();
+    };
+    const fileCall = (index) => {
+        word(index);
+        const root = value(index) === 'rootProject';
+        if (root || value(index) === 'project')
+            index = expect(index + 1, '.');
+        index = expect(index, 'file');
+        return { index: expect(index, '('), root };
+    };
+    const access = (index) => {
+        if (value(index) === '[') {
+            const key = literal(index + 1);
+            return { key, next: expect(index + 2, ']') };
+        }
+        index = expect(index, '.');
+        index = expect(index, 'getProperty');
+        index = expect(index, '(');
+        const key = literal(index++);
+        return { key, next: expect(index, ')') };
+    };
+    const declaration = (name, type) => {
+        const matches = tokens.flatMap((token, index) => {
+            if (token.kind !== 'word' ||
+                token.value !== name ||
+                tokens[index - 1]?.kind !== 'word' ||
+                !['def', 'val', 'var', type].includes(value(index - 1)))
+                return [];
+            if (scopes[index] !== -1)
+                unsupported();
+            startStatement(index - 1);
+            let next = index + 1;
+            if (value(next) === ':')
+                next = expect(next + 1, type);
+            return [{ index, next: expect(next, '=') }];
+        });
+        if (matches.length !== 1)
+            unsupported();
+        return matches[0];
+    };
+    let propertiesName;
+    let keyRoot = false;
+    const signingReads = new Set();
+    for (const start of signing) {
+        startStatement(start);
+        if (value(start) !== 'storeFile' || ['.', 'def', 'val', 'var'].includes(value(start - 1)))
+            unsupported();
+        let index = start + 1;
+        if (value(index) === '=')
+            index++;
+        const call = fileCall(index);
+        index = call.index;
+        const name = word(index);
+        signingReads.add(index++);
+        if (propertiesName && (propertiesName !== name || keyRoot !== call.root))
+            unsupported();
+        propertiesName = name;
+        keyRoot = call.root;
+        const read = access(index);
+        if (read.key !== 'storeFile')
+            unsupported();
+        index = read.next;
+        if (value(index) === 'as')
+            index = expect(index + 1, 'String');
+        endStatement(expect(index, ')'));
+    }
+    const properties = declaration(propertiesName, 'Properties');
+    let index = properties.next;
+    if (value(index) === 'new')
+        index++;
+    index = expect(index, 'Properties');
+    index = expect(index, '(');
+    endStatement(expect(index, ')'));
+    const loads = [];
+    for (const [position, token] of tokens.entries()) {
+        if (token.kind !== 'word' ||
+            token.value !== propertiesName ||
+            position === properties.index ||
+            signingReads.has(position))
+            continue;
+        if (value(position - 1) === '.')
+            unsupported();
+        if (value(position + 1) === '.' && value(position + 2) === 'load') {
+            let next = expect(position + 3, '(');
+            if (value(next) === 'new')
+                next++;
+            next = expect(next, 'FileInputStream');
+            next = expect(next, '(');
+            const fileIndex = next;
+            const fileName = word(next++);
+            next = expect(next, ')');
+            endStatement(expect(next, ')'));
+            loads.push({ index: position, fileIndex, fileName });
+        }
+        else {
+            const read = access(position + 1);
+            if (tokens[read.next]?.kind === 'symbol' &&
+                ![')', ']', '}', ',', ';'].includes(value(read.next)))
+                unsupported();
+        }
+    }
+    if (loads.length !== 1)
+        unsupported();
+    const load = loads[0];
+    startStatement(load.index);
+    const scope = scopes[load.index];
+    if (scope !== -1) {
+        if (scopes[scope] !== -1)
+            unsupported();
+        let guard = scope - 8;
+        if (guard < 0)
+            unsupported();
+        startStatement(guard);
+        for (const expected of ['if', '(', load.fileName, '.', 'exists', '(', ')', ')']) {
+            guard = expect(guard, expected);
+        }
+    }
+    if (properties.index >= load.index || signing.some((position) => position <= load.index))
+        unsupported();
+    const source = declaration(load.fileName, 'File');
+    if (source.index >= load.index)
+        unsupported();
+    const call = fileCall(source.next);
+    const propertiesPath = literal(call.index);
+    endStatement(expect(call.index + 1, ')'));
+    for (const [position, token] of tokens.entries()) {
+        if (token.kind !== 'word' ||
+            token.value !== load.fileName ||
+            position === source.index ||
+            position === load.fileIndex)
+            continue;
+        if (value(position - 1) === '.')
+            unsupported();
+        let next = expect(position + 1, '.');
+        next = expect(next, 'exists');
+        next = expect(next, '(');
+        expect(next, ')');
+    }
+    return { propertiesPath, propertiesRoot: call.root, keyRoot };
+}
+//# sourceMappingURL=worktree-gradle.js.map