@memorax/memorax-code 0.1.0

package/lib/memorax-code-backend/dist/repository-memory-context.js

@@ -0,0 +1,134 @@
+import { memoraxConfigFromEnv, } from "./memorax-config.js";
+import { repositoryMemoryScopeContainsWorkspace, repositoryMemoryScopeKind, repositoryMemoryScopesMatch, resolveRepositoryMemoryScope, } from "./repository-memory-scope.js";
+const sessionScopes = new WeakMap();
+const scopeResolutionQueues = new WeakMap();
+export function createRepositoryMemorySessionRuntime() {
+    const owner = {};
+    return {
+        async resolve(input) {
+            return await resolveConfiguredRepositoryMemoryForSession({ owner, ...input });
+        },
+        close() {
+            sessionScopes.delete(owner);
+            scopeResolutionQueues.delete(owner);
+        },
+    };
+}
+export async function resolveConfiguredRepositoryMemory(input) {
+    const sourceEnv = input.env ?? process.env;
+    const env = input.memoraxCodeHome ? { ...sourceEnv, MEMORAX_CODE_HOME: input.memoraxCodeHome } : sourceEnv;
+    const configResult = memoraxConfigFromEnv(env);
+    if (!configResult.ok)
+        return { ok: false, reason: "config_missing", error: configResult.error };
+    const scopeResult = await resolveRepositoryMemoryScope({
+        workspaceRoot: input.workspaceRoot,
+        workspaceKind: input.workspaceKind,
+        baseUserId: configResult.config.userId,
+    });
+    if (!scopeResult.ok)
+        return scopeResult;
+    return { ok: true, memory: { config: configResult.config, scope: scopeResult.scope } };
+}
+export async function resolveConfiguredRepositoryMemoryForSession(input) {
+    const sourceEnv = input.env ?? process.env;
+    const env = input.memoraxCodeHome ? { ...sourceEnv, MEMORAX_CODE_HOME: input.memoraxCodeHome } : sourceEnv;
+    const configResult = memoraxConfigFromEnv(env);
+    if (!configResult.ok)
+        return { ok: false, reason: "config_missing", error: configResult.error };
+    const sessionId = input.sessionId?.trim();
+    if (!sessionId) {
+        return await resolveConfiguredRepositoryMemory({
+            workspaceRoot: input.workspaceRoot,
+            workspaceKind: input.workspaceKind,
+            memoraxCodeHome: input.memoraxCodeHome,
+            env,
+        });
+    }
+    const bindingKey = JSON.stringify([input.client, sessionId]);
+    return await withScopeResolution(input.owner, `session:${bindingKey}`, async () => {
+        let scopes = sessionScopes.get(input.owner);
+        if (!scopes) {
+            scopes = new Map();
+            sessionScopes.set(input.owner, scopes);
+        }
+        const cached = scopes.get(bindingKey);
+        if (cached?.scope.baseUserId === configResult.config.userId && cached.mismatch) {
+            return repositoryScopeMismatch();
+        }
+        const cachedScope = cached?.scope.baseUserId === configResult.config.userId ? cached.scope : undefined;
+        if (input.requireBoundScope === true && !cachedScope) {
+            return {
+                ok: false,
+                reason: "workspace_scope_unavailable",
+                error: "memory scope authority is unavailable for this session",
+            };
+        }
+        const workspaceKind = input.workspaceKind?.trim().toLowerCase();
+        let workspaceRoot = input.workspaceRoot?.trim() ? input.workspaceRoot : undefined;
+        if (cachedScope
+            && repositoryMemoryScopeKind(cachedScope) === "local-directory"
+            && workspaceKind !== "projectless"
+            && await repositoryMemoryScopeContainsWorkspace(cachedScope, workspaceRoot)) {
+            workspaceRoot = cachedScope.boundWorkspaceRoot;
+        }
+        if (!workspaceRoot && cachedScope?.boundWorkspaceRoot)
+            workspaceRoot = cachedScope.boundWorkspaceRoot;
+        const effectiveWorkspaceKind = input.workspaceKind
+            ?? (cachedScope && repositoryMemoryScopeKind(cachedScope) === "codex-projectless"
+                ? "projectless"
+                : undefined);
+        if (!workspaceRoot && effectiveWorkspaceKind?.trim().toLowerCase() !== "projectless") {
+            return {
+                ok: false,
+                reason: "workspace_scope_unavailable",
+                error: "a session workspace is required for workspace-scoped memory",
+            };
+        }
+        const scopeResult = await resolveRepositoryMemoryScope({
+            workspaceRoot,
+            workspaceKind: effectiveWorkspaceKind,
+            baseUserId: configResult.config.userId,
+        });
+        if (!scopeResult.ok)
+            return scopeResult;
+        if (cached?.scope.baseUserId === configResult.config.userId) {
+            if (!repositoryMemoryScopesMatch(cached.scope, scopeResult.scope)) {
+                cached.mismatch = true;
+                return repositoryScopeMismatch();
+            }
+            return { ok: true, memory: { config: configResult.config, scope: cached.scope } };
+        }
+        scopes.set(bindingKey, { scope: scopeResult.scope, mismatch: false });
+        return { ok: true, memory: { config: configResult.config, scope: scopeResult.scope } };
+    });
+}
+function repositoryScopeMismatch() {
+    return {
+        ok: false,
+        reason: "workspace_scope_mismatch",
+        error: "memory scope changed for this session; start a new session for the other workspace",
+    };
+}
+async function withScopeResolution(owner, key, fn) {
+    let queues = scopeResolutionQueues.get(owner);
+    if (!queues) {
+        queues = new Map();
+        scopeResolutionQueues.set(owner, queues);
+    }
+    const previous = queues.get(key) ?? Promise.resolve();
+    let release = () => undefined;
+    const current = new Promise((resolveCurrent) => {
+        release = resolveCurrent;
+    });
+    const tail = previous.then(() => current);
+    queues.set(key, tail);
+    await previous;
+    try {
+        return await fn();
+    }
+    finally {
+        release();
+        if (queues.get(key) === tail)
+            queues.delete(key);
+    }
+}

package/lib/memorax-code-backend/dist/repository-memory-scope.js

@@ -0,0 +1,490 @@
+import { createHash } from "node:crypto";
+import fs from "node:fs/promises";
+import { basename, dirname, isAbsolute, join, resolve, sep } from "node:path";
+const CODEX_PROJECTLESS_SLUG = "Codex-General";
+const MAX_GIT_POINTER_BYTES = 64 * 1024;
+const MAX_GIT_CONFIG_BYTES = 1024 * 1024;
+export async function resolveRepositoryMemoryScope(input) {
+    const baseUserId = input.baseUserId.trim();
+    if (!baseUserId) {
+        return {
+            ok: false,
+            reason: "effective_user_id_invalid",
+            error: "base MemoraX user id is required for workspace-scoped memory",
+        };
+    }
+    const workspaceKind = input.workspaceKind?.trim().toLowerCase();
+    if (workspaceKind === "projectless") {
+        const workspace = await resolveWorkspace(input.workspaceRoot);
+        return {
+            ok: true,
+            scope: memoryScope({
+                baseUserId,
+                repositoryKey: identityKey("codex-projectless", CODEX_PROJECTLESS_SLUG),
+                repositorySlug: CODEX_PROJECTLESS_SLUG,
+                identitySource: "codex-projectless",
+                scopeKind: "codex-projectless",
+                boundWorkspaceRoot: workspace,
+            }),
+        };
+    }
+    const workspace = await resolveWorkspace(input.workspaceRoot);
+    if (!workspace) {
+        return {
+            ok: false,
+            reason: "workspace_scope_unavailable",
+            error: "a readable workspace directory is required for workspace-scoped memory",
+        };
+    }
+    const gitRepository = await resolveGitRepository(workspace);
+    if (gitRepository.kind === "invalid") {
+        return {
+            ok: false,
+            reason: "workspace_scope_unavailable",
+            error: "Git repository metadata is invalid or unavailable",
+        };
+    }
+    if (gitRepository.kind === "repository") {
+        return {
+            ok: true,
+            scope: memoryScope({
+                baseUserId,
+                repositoryKey: identityKey("git-common-dir", gitRepository.commonDir),
+                repositorySlug: gitRepository.repositoryName,
+                identitySource: gitRepository.identitySource,
+                scopeKind: "git-repository",
+                boundWorkspaceRoot: gitRepository.workspaceRoot,
+            }),
+        };
+    }
+    const workspaceName = sanitizeWorkspaceName(basename(workspace));
+    if (!workspaceName) {
+        return {
+            ok: false,
+            reason: "workspace_scope_unavailable",
+            error: "the workspace root must have a usable folder name",
+        };
+    }
+    return {
+        ok: true,
+        scope: memoryScope({
+            baseUserId,
+            repositoryKey: identityKey("workspace-directory", workspace),
+            repositorySlug: workspaceName,
+            identitySource: "workspace-directory",
+            scopeKind: "local-directory",
+            boundWorkspaceRoot: workspace,
+        }),
+    };
+}
+export function repositoryMemoryScopesMatch(left, right) {
+    return left.repositoryKey === right.repositoryKey
+        && left.baseUserId === right.baseUserId
+        && left.effectiveUserId === right.effectiveUserId;
+}
+export async function repositoryMemoryScopeContainsWorkspace(scope, workspaceRoot) {
+    if (!scope.boundWorkspaceRoot || !workspaceRoot?.trim())
+        return false;
+    const workspace = await resolveWorkspace(workspaceRoot);
+    if (!workspace)
+        return false;
+    if (scope.scopeKind === "git-repository") {
+        const gitRepository = await resolveGitRepository(workspace);
+        return gitRepository.kind === "repository"
+            && identityKey("git-common-dir", gitRepository.commonDir) === scope.repositoryKey
+            && gitRepository.repositoryName === scope.repositorySlug;
+    }
+    if (!pathContains(scope.boundWorkspaceRoot, workspace))
+        return false;
+    return scope.scopeKind !== "local-directory"
+        || !await hasGitMarkerBetween(workspace, scope.boundWorkspaceRoot);
+}
+export function repositoryMemoryScopeKind(scope) {
+    return scope.scopeKind;
+}
+function memoryScope(input) {
+    return {
+        schemaVersion: "workspace-memory-scope.v1",
+        baseUserId: input.baseUserId,
+        effectiveUserId: `${input.baseUserId}@${input.repositorySlug}`,
+        repositoryKey: input.repositoryKey,
+        repositorySlug: input.repositorySlug,
+        repositoryName: input.repositorySlug,
+        identitySource: input.identitySource,
+        scopeKind: input.scopeKind,
+        ...(input.boundWorkspaceRoot ? { boundWorkspaceRoot: input.boundWorkspaceRoot } : {}),
+    };
+}
+function sanitizeWorkspaceName(value) {
+    const normalized = value
+        .normalize("NFKC")
+        .trim()
+        .replace(/[@/\\\s\p{Cc}]+/gu, "-")
+        .replace(/[^\p{L}\p{N}._~-]+/gu, "-")
+        .replace(/^-+|-+$/g, "");
+    return [...normalized].slice(0, 120).join("").replace(/-+$/g, "");
+}
+async function resolveGitRepository(workspace) {
+    let marker;
+    try {
+        marker = await findNearestGitMarker(workspace);
+    }
+    catch {
+        return { kind: "invalid" };
+    }
+    if (!marker)
+        return { kind: "none" };
+    try {
+        const gitDir = await resolveGitDir(marker.path);
+        await validateGitHead(gitDir);
+        const commonDir = await resolveGitCommonDir(gitDir);
+        await validateGitCommonDir(commonDir);
+        const remotes = await readCommonConfigRemotes(commonDir);
+        const remoteName = selectedRemoteRepositoryName(remotes);
+        return {
+            kind: "repository",
+            commonDir,
+            repositoryName: remoteName ?? repositoryNameFromCommonDir(commonDir),
+            identitySource: remoteName ? "origin-remote" : "git-common-dir",
+            workspaceRoot: marker.workspaceRoot,
+        };
+    }
+    catch {
+        return { kind: "invalid" };
+    }
+}
+async function findNearestGitMarker(workspace) {
+    let current = workspace;
+    while (true) {
+        const marker = join(current, ".git");
+        try {
+            await fs.lstat(marker);
+            return { path: marker, workspaceRoot: current };
+        }
+        catch (error) {
+            if (!isNodeErrorCode(error, "ENOENT"))
+                throw error;
+        }
+        const parent = dirname(current);
+        if (parent === current)
+            return undefined;
+        current = parent;
+    }
+}
+async function hasGitMarkerBetween(workspace, boundary) {
+    let current = workspace;
+    while (true) {
+        try {
+            await fs.lstat(join(current, ".git"));
+            return true;
+        }
+        catch (error) {
+            if (!isNodeErrorCode(error, "ENOENT"))
+                return true;
+        }
+        if (current === boundary)
+            return false;
+        const parent = dirname(current);
+        if (parent === current)
+            return true;
+        current = parent;
+    }
+}
+async function resolveGitDir(marker) {
+    if ((await fs.lstat(marker)).isSymbolicLink())
+        throw new Error("symbolic Git metadata marker is not allowed");
+    const markerStat = await fs.stat(marker);
+    if (markerStat.isDirectory())
+        return await canonicalDirectory(marker);
+    if (!markerStat.isFile())
+        throw new Error("invalid Git metadata marker");
+    const line = await readSingleLine(marker, MAX_GIT_POINTER_BYTES);
+    const match = /^gitdir:[ \t]*(.+)$/i.exec(line);
+    const gitDir = match?.[1]?.trim();
+    if (!gitDir)
+        throw new Error("invalid Git metadata pointer");
+    return await canonicalDirectory(resolveMetadataPath(dirname(marker), gitDir));
+}
+async function resolveGitCommonDir(gitDir) {
+    const path = join(gitDir, "commondir");
+    try {
+        await fs.lstat(path);
+    }
+    catch (error) {
+        if (isNodeErrorCode(error, "ENOENT"))
+            return gitDir;
+        throw error;
+    }
+    const commonDir = (await readSingleLine(path, MAX_GIT_POINTER_BYTES)).trim();
+    if (!commonDir)
+        throw new Error("invalid Git common directory pointer");
+    return await canonicalDirectory(resolveMetadataPath(gitDir, commonDir));
+}
+function resolveMetadataPath(base, value) {
+    if (value.includes("\0"))
+        throw new Error("invalid Git metadata path");
+    return isAbsolute(value) ? value : resolve(base, value);
+}
+async function canonicalDirectory(path) {
+    const canonical = await fs.realpath(path);
+    if (!(await fs.stat(canonical)).isDirectory())
+        throw new Error("Git metadata path is not a directory");
+    return canonical;
+}
+async function validateGitHead(gitDir) {
+    const head = (await readSingleLine(join(gitDir, "HEAD"), MAX_GIT_POINTER_BYTES)).trim();
+    if (!/^ref: refs\/[^\0\r\n]+$/.test(head) && !/^(?:[a-fA-F0-9]{40}|[a-fA-F0-9]{64})$/.test(head)) {
+        throw new Error("invalid Git HEAD");
+    }
+}
+async function validateGitCommonDir(commonDir) {
+    if (!(await fs.stat(join(commonDir, "objects"))).isDirectory()) {
+        throw new Error("invalid Git objects directory");
+    }
+    const hasRefs = await isDirectory(join(commonDir, "refs"));
+    const hasReftable = await isDirectory(join(commonDir, "reftable"));
+    if (!hasRefs && !hasReftable)
+        throw new Error("invalid Git references directory");
+}
+async function isDirectory(path) {
+    try {
+        return (await fs.stat(path)).isDirectory();
+    }
+    catch (error) {
+        if (isNodeErrorCode(error, "ENOENT"))
+            return false;
+        throw error;
+    }
+}
+async function readSingleLine(path, maxBytes) {
+    let value = await readBoundedTextFile(path, maxBytes);
+    if (value.endsWith("\r\n"))
+        value = value.slice(0, -2);
+    else if (value.endsWith("\n"))
+        value = value.slice(0, -1);
+    if (!value || value.includes("\0") || value.includes("\r") || value.includes("\n")) {
+        throw new Error("invalid single-line Git metadata");
+    }
+    return value;
+}
+async function readBoundedTextFile(path, maxBytes) {
+    const file = await fs.stat(path);
+    if (!file.isFile() || file.size > maxBytes)
+        throw new Error("invalid Git metadata file");
+    const value = await fs.readFile(path, "utf8");
+    if (Buffer.byteLength(value, "utf8") > maxBytes || value.includes("\0")) {
+        throw new Error("invalid Git metadata file");
+    }
+    return value;
+}
+async function readCommonConfigRemotes(commonDir) {
+    const path = join(commonDir, "config");
+    let source;
+    try {
+        source = await readBoundedTextFile(path, MAX_GIT_CONFIG_BYTES);
+    }
+    catch (error) {
+        if (isNodeErrorCode(error, "ENOENT"))
+            return new Map();
+        throw error;
+    }
+    return parseDirectRemoteUrls(source);
+}
+function parseDirectRemoteUrls(source) {
+    const remotes = new Map();
+    let remote;
+    for (const line of logicalGitConfigLines(source)) {
+        const trimmed = line.trim();
+        if (!trimmed || trimmed.startsWith("#") || trimmed.startsWith(";"))
+            continue;
+        if (trimmed.startsWith("[")) {
+            const section = parseGitConfigSection(trimmed);
+            remote = section?.name.toLowerCase() === "remote" ? section.subsection : undefined;
+            continue;
+        }
+        if (!remote)
+            continue;
+        const assignment = /^[ \t]*([A-Za-z][A-Za-z0-9-]*)[ \t]*(?:=[ \t]*)?(.*)$/.exec(line);
+        if (!assignment)
+            throw new Error("invalid Git config assignment");
+        if (assignment[1]?.toLowerCase() !== "url")
+            continue;
+        remotes.set(remote, parseGitConfigValue(assignment[2] ?? ""));
+    }
+    return remotes;
+}
+function logicalGitConfigLines(source) {
+    const lines = [];
+    let pending = "";
+    for (const physical of source.split("\n")) {
+        const line = physical.endsWith("\r") ? physical.slice(0, -1) : physical;
+        const combined = `${pending}${line}`;
+        if (hasUnescapedTrailingBackslash(combined)) {
+            pending = combined.slice(0, -1);
+        }
+        else {
+            lines.push(combined);
+            pending = "";
+        }
+    }
+    if (pending)
+        throw new Error("unterminated Git config continuation");
+    return lines;
+}
+function hasUnescapedTrailingBackslash(value) {
+    let count = 0;
+    for (let index = value.length - 1; index >= 0 && value[index] === "\\"; index -= 1)
+        count += 1;
+    return count % 2 === 1;
+}
+function parseGitConfigSection(line) {
+    const match = /^\[[ \t]*([A-Za-z0-9][A-Za-z0-9.-]*)[ \t]*(?:"((?:[^"\\]|\\.)*)")?[ \t]*\](?:[ \t]*[#;].*)?$/.exec(line);
+    if (!match?.[1])
+        throw new Error("invalid Git config section");
+    if (!match[2] && match[1].includes(".")) {
+        const separator = match[1].indexOf(".");
+        return {
+            name: match[1].slice(0, separator),
+            subsection: match[1].slice(separator + 1),
+        };
+    }
+    return {
+        name: match[1],
+        ...(match[2] !== undefined ? { subsection: unescapeGitConfigText(match[2]) } : {}),
+    };
+}
+function parseGitConfigValue(value) {
+    const input = value.trimStart();
+    if (!input.startsWith('"')) {
+        const comment = input.search(/[#;]/);
+        return unescapeGitConfigText((comment >= 0 ? input.slice(0, comment) : input).trimEnd());
+    }
+    let result = "";
+    let escaped = false;
+    for (let index = 1; index < input.length; index += 1) {
+        const character = input[index];
+        if (escaped) {
+            result += unescapeGitConfigCharacter(character);
+            escaped = false;
+            continue;
+        }
+        if (character === "\\") {
+            escaped = true;
+            continue;
+        }
+        if (character !== '"') {
+            result += character;
+            continue;
+        }
+        const trailing = input.slice(index + 1).trim();
+        if (trailing && !trailing.startsWith("#") && !trailing.startsWith(";")) {
+            throw new Error("invalid Git config value");
+        }
+        return result;
+    }
+    throw new Error("unterminated Git config value");
+}
+function unescapeGitConfigText(value) {
+    let result = "";
+    for (let index = 0; index < value.length; index += 1) {
+        const character = value[index];
+        if (character !== "\\") {
+            result += character;
+            continue;
+        }
+        const escaped = value[index + 1];
+        if (escaped === undefined)
+            throw new Error("invalid Git config escape");
+        result += unescapeGitConfigCharacter(escaped);
+        index += 1;
+    }
+    return result;
+}
+function unescapeGitConfigCharacter(value) {
+    if (value === "n")
+        return "\n";
+    if (value === "t")
+        return "\t";
+    if (value === "b")
+        return "\b";
+    if (value === '"' || value === "\\")
+        return value;
+    throw new Error("invalid Git config escape");
+}
+function selectedRemoteRepositoryName(remotes) {
+    const origin = remotes.get("origin");
+    if (origin !== undefined)
+        return repositoryNameFromRemoteUrl(origin);
+    if (remotes.size !== 1)
+        return undefined;
+    return repositoryNameFromRemoteUrl(remotes.values().next().value ?? "");
+}
+function repositoryNameFromRemoteUrl(value) {
+    const raw = value.trim();
+    if (!raw
+        || raw.startsWith("/")
+        || raw.startsWith("./")
+        || raw.startsWith("../")
+        || raw.startsWith("\\\\")
+        || /^[a-zA-Z]:[\\/]/.test(raw))
+        return undefined;
+    try {
+        const parsed = new URL(raw);
+        if (!["http:", "https:", "ssh:", "git:", "git+ssh:", "git+https:"].includes(parsed.protocol)) {
+            return undefined;
+        }
+        if (!parsed.hostname.trim())
+            return undefined;
+        return repositoryNameFromRemotePath(parsed.pathname);
+    }
+    catch {
+        const scp = /^(?:[^@/:\s]+@)?[^/:\s]+:(.+)$/.exec(raw);
+        return scp?.[1] ? repositoryNameFromRemotePath(scp[1]) : undefined;
+    }
+}
+function repositoryNameFromRemotePath(value) {
+    const path = value
+        .split(/[?#]/, 1)[0]
+        ?.replace(/[\\/]+$/, "");
+    let name = path?.split(/[\\/]/).filter(Boolean).at(-1);
+    if (!name)
+        return undefined;
+    try {
+        name = decodeURIComponent(name);
+    }
+    catch {
+        return undefined;
+    }
+    name = name.replace(/\.git$/i, "");
+    return sanitizeWorkspaceName(name) || undefined;
+}
+function repositoryNameFromCommonDir(commonDir) {
+    const commonName = basename(commonDir);
+    const name = commonName.toLowerCase() === ".git"
+        ? basename(dirname(commonDir))
+        : commonName.replace(/\.git$/i, "");
+    const normalized = sanitizeWorkspaceName(name);
+    if (!normalized)
+        throw new Error("Git common directory has no usable repository name");
+    return normalized;
+}
+function identityKey(source, value) {
+    return createHash("sha256").update(`${source}:${value}`).digest("hex");
+}
+async function resolveWorkspace(value) {
+    if (!value?.trim())
+        return undefined;
+    try {
+        const path = await fs.realpath(value);
+        return (await fs.stat(path)).isDirectory() ? path : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+function pathContains(root, candidate) {
+    return candidate === root || candidate.startsWith(root.endsWith(sep) ? root : `${root}${sep}`);
+}
+function isNodeErrorCode(error, code) {
+    return Boolean(error && typeof error === "object" && "code" in error && error.code === code);
+}