auvrynt 1.0.2 → 1.0.5

package/dist/processes.js

@@ -1,218 +1 @@
-import { randomUUID } from "node:crypto";
-import { spawn } from "node:child_process";
-import { execFile } from "node:child_process";
-import { promisify } from "node:util";
-const execFileAsync = promisify(execFile);
-const SECRET_KEYWORD_REGEX = /(TOKEN|SECRET|PASSWORD|KEY|CONNECTION_STRING)/i;
-const URL_REGEX = /https?:\/\/(localhost|127\.0\.0\.1|\[::1\]|0\.0\.0\.0)(:\d+)?(\/[^\s]*)?/gi;
-function secretValues(environment) {
-    return Object.entries({ ...process.env, ...(environment ?? {}) })
-        .filter(([key, value]) => SECRET_KEYWORD_REGEX.test(key) && Boolean(value) && value.length >= 4)
-        .map(([, value]) => value)
-        .sort((a, b) => b.length - a.length);
-}
-export function redactProcessText(text, environment) {
-    return secretValues(environment).reduce((result, secret) => result.split(secret).join("[REDACTED]"), text);
-}
-export function sanitizeEnv(env) {
-    if (!env)
-        return {};
-    const sanitized = {};
-    for (const [key, value] of Object.entries(env)) {
-        if (SECRET_KEYWORD_REGEX.test(key)) {
-            sanitized[key] = "[REDACTED]";
-        }
-        else {
-            sanitized[key] = value;
-        }
-    }
-    return sanitized;
-}
-export class ProcessManager {
-    registry;
-    processes = new Map();
-    constructor(registry) {
-        this.registry = registry;
-    }
-    startProcess(input) {
-        const workspace = this.registry.getWorkspace(input.workspaceId);
-        const cwd = this.registry.resolveWorkingDirectory(workspace, input.workingDirectory);
-        const processId = `proc_${randomUUID()}`;
-        const maxLogLines = 1000;
-        const childEnv = { ...process.env, ...(input.environment ?? {}) };
-        const redactionEnvironment = input.environment;
-        const useShell = input.useShell ?? true;
-        const child = spawn(input.command, {
-            cwd,
-            env: childEnv,
-            shell: useShell,
-            detached: false,
-        });
-        const tracked = {
-            id: processId,
-            workspaceId: input.workspaceId,
-            command: input.command,
-            workingDirectory: cwd,
-            startTime: new Date().toISOString(),
-            child,
-            pid: child.pid,
-            status: "running",
-            stdoutLogs: [],
-            stderrLogs: [],
-            combinedLogs: [],
-            detectedUrls: new Set(),
-            maxLogLines,
-        };
-        const appendLog = (line, stream) => {
-            const trimmed = redactProcessText(line.trimEnd(), redactionEnvironment);
-            if (!trimmed)
-                return;
-            const matches = trimmed.match(URL_REGEX);
-            if (matches) {
-                for (const match of matches) {
-                    tracked.detectedUrls.add(match);
-                }
-            }
-            const formatted = `[${stream}] ${trimmed}`;
-            tracked.combinedLogs.push(formatted);
-            if (stream === "stdout")
-                tracked.stdoutLogs.push(trimmed);
-            if (stream === "stderr")
-                tracked.stderrLogs.push(trimmed);
-            if (tracked.combinedLogs.length > maxLogLines) {
-                tracked.combinedLogs.shift();
-            }
-            if (tracked.stdoutLogs.length > maxLogLines) {
-                tracked.stdoutLogs.shift();
-            }
-            if (tracked.stderrLogs.length > maxLogLines) {
-                tracked.stderrLogs.shift();
-            }
-        };
-        child.stdout?.on("data", (data) => {
-            const text = data.toString("utf8");
-            for (const line of text.split(/\r?\n/)) {
-                appendLog(line, "stdout");
-            }
-        });
-        child.stderr?.on("data", (data) => {
-            const text = data.toString("utf8");
-            for (const line of text.split(/\r?\n/)) {
-                appendLog(line, "stderr");
-            }
-        });
-        child.on("exit", (code) => {
-            tracked.status = "exited";
-            tracked.exitCode = code ?? undefined;
-        });
-        child.on("error", (err) => {
-            appendLog(`Process error: ${err.message}`, "stderr");
-            tracked.status = "exited";
-            tracked.exitCode = 1;
-        });
-        this.processes.set(processId, tracked);
-        return {
-            processId,
-            status: tracked.status,
-            exitCode: tracked.exitCode,
-            detectedUrls: Array.from(tracked.detectedUrls),
-            recentOutput: tracked.combinedLogs.slice(-20),
-        };
-    }
-    getProcessLogs(input) {
-        const tracked = this.getTrackedProcess(input.workspaceId, input.processId);
-        const stream = input.stream ?? "both";
-        let sourceLogs;
-        if (stream === "stdout")
-            sourceLogs = tracked.stdoutLogs;
-        else if (stream === "stderr")
-            sourceLogs = tracked.stderrLogs;
-        else
-            sourceLogs = tracked.combinedLogs;
-        const limit = Math.min(Math.max(input.lines ?? 100, 1), 500);
-        const recent = sourceLogs.slice(-limit);
-        return {
-            processId: tracked.id,
-            lines: recent,
-            totalLinesAvailable: sourceLogs.length,
-        };
-    }
-    listProcesses(input) {
-        const list = [];
-        for (const tracked of this.processes.values()) {
-            if (tracked.workspaceId === input.workspaceId) {
-                list.push({
-                    processId: tracked.id,
-                    command: tracked.command,
-                    workingDirectory: tracked.workingDirectory,
-                    startTime: tracked.startTime,
-                    status: tracked.status,
-                    exitCode: tracked.exitCode,
-                    detectedUrls: Array.from(tracked.detectedUrls),
-                });
-            }
-        }
-        return list;
-    }
-    async stopProcess(input) {
-        const tracked = this.getTrackedProcess(input.workspaceId, input.processId);
-        if (tracked.status === "exited") {
-            return { processId: tracked.id, stopped: true, exitCode: tracked.exitCode };
-        }
-        const pid = tracked.pid;
-        if (!pid) {
-            tracked.child.kill("SIGKILL");
-            tracked.status = "exited";
-            return { processId: tracked.id, stopped: true };
-        }
-        if (input.force) {
-            await this.killProcessTree(pid);
-            tracked.status = "exited";
-            return { processId: tracked.id, stopped: true };
-        }
-        // Try graceful kill first
-        tracked.child.kill("SIGTERM");
-        // Wait up to 1.5 seconds for graceful exit
-        const exited = await this.waitForExit(tracked, 1500);
-        if (!exited) {
-            await this.killProcessTree(pid);
-            tracked.status = "exited";
-        }
-        return { processId: tracked.id, stopped: true, exitCode: tracked.exitCode };
-    }
-    getTrackedProcess(workspaceId, processId) {
-        const tracked = this.processes.get(processId);
-        if (!tracked || tracked.workspaceId !== workspaceId) {
-            throw new Error(`Process ${processId} not found in workspace ${workspaceId}`);
-        }
-        return tracked;
-    }
-    async waitForExit(tracked, timeoutMs) {
-        const start = Date.now();
-        while (Date.now() - start < timeoutMs) {
-            if (tracked.status === "exited")
-                return true;
-            await new Promise((resolve) => setTimeout(resolve, 100));
-        }
-        return tracked.status === "exited";
-    }
-    async killProcessTree(pid) {
-        if (process.platform === "win32") {
-            try {
-                await execFileAsync("taskkill", ["/F", "/T", "/PID", String(pid)]);
-            }
-            catch { }
-        }
-        else {
-            try {
-                process.kill(-pid, "SIGKILL");
-            }
-            catch {
-                try {
-                    process.kill(pid, "SIGKILL");
-                }
-                catch { }
-            }
-        }
-    }
-}
+export * from "./process/processes.js";

package/dist/request-context.js

@@ -0,0 +1 @@
+export * from "./infrastructure/request-context.js";

package/dist/review-checkpoints.js

@@ -1,142 +1 @@
-import { mkdtemp, rm } from "node:fs/promises";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
-import { git, getGitEligibility, safeWorkspaceRefSegment } from "./git.js";
-const REVIEW_REF_PREFIX = "refs/auvrynt/review";
-export function createReviewCheckpointManager() {
-    const states = new Map();
-    return {
-        async initializeWorkspace({ workspaceId, root }) {
-            const refs = reviewRefs(workspaceId);
-            const state = { root, ...refs };
-            states.set(workspaceId, state);
-            try {
-                const eligibility = await getGitEligibility(root);
-                if (!eligibility.ok || !eligibility.gitRoot) {
-                    state.diagnostic = eligibility.message ?? "show_changes requires a Git workspace in this version.";
-                    return;
-                }
-                state.gitRoot = eligibility.gitRoot;
-                const commit = await createWorkingTreeSnapshot(eligibility.gitRoot);
-                await git(eligibility.gitRoot, ["update-ref", state.openRef, commit]);
-                await git(eligibility.gitRoot, ["update-ref", state.baselineRef, commit]);
-            }
-            catch (error) {
-                state.diagnostic = error instanceof Error ? error.message : String(error);
-            }
-        },
-        async reviewChanges({ workspaceId, root, since = "last_shown", markReviewed = true }) {
-            let state = states.get(workspaceId);
-            if (!state) {
-                await this.initializeWorkspace({ workspaceId, root });
-                state = states.get(workspaceId);
-            }
-            if (!state?.gitRoot) {
-                throw new Error(state?.diagnostic ?? "show_changes requires a Git workspace in this version.");
-            }
-            const baselineRef = since === "workspace_open" ? state.openRef : state.baselineRef;
-            const baseline = (await git(state.gitRoot, ["rev-parse", "--verify", `${baselineRef}^{commit}`])).stdout.trim();
-            const current = await createWorkingTreeSnapshot(state.gitRoot);
-            const patch = (await git(state.gitRoot, ["diff", "--binary", "--no-color", baseline, current], {
-                maxBuffer: 50 * 1024 * 1024,
-            })).stdout;
-            const numstat = (await git(state.gitRoot, ["diff", "--numstat", "-z", baseline, current], {
-                maxBuffer: 50 * 1024 * 1024,
-            })).stdout;
-            const files = parseNumstat(numstat);
-            const summary = summarizeFiles(files);
-            if (markReviewed) {
-                await git(state.gitRoot, ["update-ref", state.baselineRef, current]);
-            }
-            return {
-                result: summary.files === 0
-                    ? `No changes since ${since === "workspace_open" ? "workspace open" : "last shown changes"}.`
-                    : `Changed ${summary.files} ${summary.files === 1 ? "file" : "files"} (+${summary.additions} -${summary.removals}).`,
-                summary,
-                files,
-                patch,
-            };
-        },
-    };
-}
-function reviewRefs(workspaceId) {
-    const segment = safeWorkspaceRefSegment(workspaceId);
-    return {
-        openRef: `${REVIEW_REF_PREFIX}/${segment}/open`,
-        baselineRef: `${REVIEW_REF_PREFIX}/${segment}/baseline`,
-    };
-}
-async function createWorkingTreeSnapshot(gitRoot) {
-    const tempDir = await mkdtemp(join(tmpdir(), "auvrynt-review-index-"));
-    const indexPath = join(tempDir, "index");
-    const env = checkpointEnv(indexPath);
-    try {
-        await git(gitRoot, ["read-tree", "HEAD"], { env });
-        await git(gitRoot, ["add", "-A", "--", "."], { env });
-        const tree = (await git(gitRoot, ["write-tree"], { env })).stdout.trim();
-        const parent = (await git(gitRoot, ["rev-parse", "--verify", "HEAD^{commit}"])).stdout.trim();
-        return (await git(gitRoot, ["commit-tree", tree, "-p", parent, "-m", "Auvrynt review snapshot"], { env })).stdout.trim();
-    }
-    finally {
-        await rm(tempDir, { recursive: true, force: true });
-    }
-}
-function checkpointEnv(indexPath) {
-    return {
-        GIT_INDEX_FILE: indexPath,
-        GIT_AUTHOR_NAME: "Auvrynt",
-        GIT_AUTHOR_EMAIL: "auvrynt@users.noreply.local",
-        GIT_COMMITTER_NAME: "Auvrynt",
-        GIT_COMMITTER_EMAIL: "auvrynt@users.noreply.local",
-    };
-}
-function parseNumstat(output) {
-    const fields = output.split("\0").filter((field) => field.length > 0);
-    const files = [];
-    for (let index = 0; index < fields.length;) {
-        const header = fields[index++] ?? "";
-        const parts = header.split("\t");
-        const additions = parseStatNumber(parts[0]);
-        const removals = parseStatNumber(parts[1]);
-        if (parts.length >= 3) {
-            const path = parts[2] ?? "";
-            if (path)
-                files.push({ path, type: fileType(path, undefined, additions, removals), additions, removals });
-            continue;
-        }
-        const previousPath = fields[index++];
-        const path = fields[index++];
-        if (!path)
-            continue;
-        files.push({
-            path,
-            previousPath,
-            type: fileType(path, previousPath, additions, removals),
-            additions,
-            removals,
-        });
-    }
-    return files;
-}
-function parseStatNumber(value) {
-    if (!value || value === "-")
-        return 0;
-    const parsed = Number(value);
-    return Number.isFinite(parsed) ? parsed : 0;
-}
-function fileType(path, previousPath, additions, removals) {
-    if (previousPath)
-        return additions === 0 && removals === 0 ? "rename-pure" : "rename-changed";
-    if (additions > 0 && removals === 0)
-        return "new";
-    if (additions === 0 && removals > 0)
-        return "deleted";
-    return "change";
-}
-function summarizeFiles(files) {
-    return files.reduce((summary, file) => ({
-        files: summary.files + 1,
-        additions: summary.additions + file.additions,
-        removals: summary.removals + file.removals,
-    }), { files: 0, additions: 0, removals: 0 });
-}
+export * from "./workspace/review-checkpoints.js";

package/dist/room-registry.js

@@ -0,0 +1 @@
+export * from "./auth/room-registry.js";

package/dist/roots.js

@@ -1,53 +1 @@
-import { homedir } from "node:os";
-import { basename, dirname, relative, resolve, sep } from "node:path";
-import { existsSync, realpathSync } from "node:fs";
-export class AccessDeniedError extends Error {
-    constructor(message) {
-        super(message);
-        this.name = "AccessDeniedError";
-    }
-}
-export function expandHomePath(path) {
-    if (path === "~")
-        return homedir();
-    if (path.startsWith("~/") || path.startsWith("~\\")) {
-        return resolve(homedir(), path.slice(2));
-    }
-    return path;
-}
-export function isPathInsideRoot(path, root) {
-    const resolvedPath = canonicalizePath(path);
-    const resolvedRoot = canonicalizePath(root);
-    const relationship = relative(resolvedRoot, resolvedPath);
-    return (relationship === "" ||
-        (!relationship.startsWith("..") && relationship !== ".." && !relationship.includes(`..${sep}`)));
-}
-export function assertAllowedPath(path, allowedRoots) {
-    const resolvedPath = canonicalizePath(path);
-    if (allowedRoots.some((root) => isPathInsideRoot(resolvedPath, root))) {
-        return resolve(expandHomePath(path));
-    }
-    throw new AccessDeniedError(`Path is outside allowed roots: ${path}`);
-}
-export function resolveAllowedPath(inputPath, cwd, allowedRoots) {
-    const absolutePath = resolve(cwd, inputPath);
-    return assertAllowedPath(absolutePath, allowedRoots);
-}
-/**
- * Resolve the existing portion of a path through symlinks/junctions before
- * applying workspace boundaries. This also handles new files whose parent
- * directory already exists behind a link.
- */
-function canonicalizePath(path) {
-    const resolved = resolve(expandHomePath(path));
-    const missing = [];
-    let existing = resolved;
-    while (!existsSync(existing)) {
-        const parent = dirname(existing);
-        if (parent === existing)
-            return resolved;
-        missing.unshift(basename(existing));
-        existing = parent;
-    }
-    return resolve(realpathSync.native(existing), ...missing);
-}
+export * from "./workspace/roots.js";

package/dist/search-discovery.js

@@ -1,271 +1 @@
-import { readdir, readFile, stat } from "node:fs/promises";
-import { join, relative } from "node:path";
-const DEFAULT_IGNORED_DIRS = new Set([
-    ".git",
-    ".auvrynt-run",
-    "node_modules",
-    "dist",
-    "build",
-    "bin",
-    "obj",
-    ".next",
-    ".godot",
-    "__pycache__",
-]);
-export async function globFiles(registry, input) {
-    const workspace = registry.getWorkspace(input.workspaceId);
-    const baseDir = input.basePath
-        ? registry.resolvePath(workspace, input.basePath)
-        : workspace.root;
-    const maxResults = Math.min(Math.max(input.maxResults ?? 100, 1), 1000);
-    const matchedFiles = [];
-    let truncated = false;
-    // Convert glob pattern to simple Regex
-    const regexPattern = input.pattern
-        .replace(/\./g, "\\.")
-        .replace(/\*\*/g, ".*")
-        .replace(/\*/g, "[^/\\\\]*")
-        .replace(/\?/g, ".");
-    const patternRegex = new RegExp(`^${regexPattern}$`, "i");
-    async function walk(dir) {
-        if (matchedFiles.length >= maxResults) {
-            truncated = true;
-            return;
-        }
-        let entries;
-        try {
-            entries = await readdir(dir, { withFileTypes: true });
-        }
-        catch {
-            return;
-        }
-        for (const entry of entries) {
-            if (matchedFiles.length >= maxResults) {
-                truncated = true;
-                return;
-            }
-            if (entry.isDirectory()) {
-                if (DEFAULT_IGNORED_DIRS.has(entry.name))
-                    continue;
-                await walk(join(dir, entry.name));
-            }
-            else if (entry.isFile()) {
-                const fullPath = join(dir, entry.name);
-                const relPath = relative(workspace.root, fullPath).replace(/\\/g, "/");
-                if (patternRegex.test(entry.name) || patternRegex.test(relPath)) {
-                    matchedFiles.push(relPath);
-                }
-            }
-        }
-    }
-    await walk(baseDir);
-    return {
-        files: matchedFiles,
-        total: matchedFiles.length,
-        truncated,
-    };
-}
-export async function searchText(registry, input) {
-    const workspace = registry.getWorkspace(input.workspaceId);
-    const searchRoot = workspace.root;
-    const maxResults = Math.min(Math.max(input.maxResults ?? 50, 1), 500);
-    const caseSensitive = input.caseSensitive ?? false;
-    const flags = caseSensitive ? "g" : "gi";
-    const searchRegex = new RegExp(input.query.replace(/[.*+?^${}()|[\]\\]/g, "\\$&"), flags);
-    const fileFilterRegex = input.filePattern
-        ? new RegExp(input.filePattern
-            .replace(/\./g, "\\.")
-            .replace(/\*/g, ".*"), "i")
-        : null;
-    const matches = [];
-    let truncated = false;
-    async function searchInFile(fullPath) {
-        if (matches.length >= maxResults) {
-            truncated = true;
-            return;
-        }
-        let text;
-        try {
-            const stats = await stat(fullPath);
-            // Skip binary/huge files > 2 MB
-            if (stats.size > 2 * 1024 * 1024)
-                return;
-            text = await readFile(fullPath, "utf8");
-        }
-        catch {
-            return;
-        }
-        const lines = text.split(/\r?\n/);
-        const relPath = relative(workspace.root, fullPath).replace(/\\/g, "/");
-        for (let i = 0; i < lines.length; i++) {
-            if (matches.length >= maxResults) {
-                truncated = true;
-                return;
-            }
-            const lineText = lines[i];
-            searchRegex.lastIndex = 0;
-            const matchExec = searchRegex.exec(lineText);
-            if (matchExec) {
-                const startCtx = Math.max(0, i - 1);
-                const endCtx = Math.min(lines.length - 1, i + 1);
-                const context = lines.slice(startCtx, endCtx + 1);
-                matches.push({
-                    path: relPath,
-                    line: i + 1,
-                    column: matchExec.index + 1,
-                    match: lineText.trim(),
-                    context,
-                });
-            }
-        }
-    }
-    async function walk(dir) {
-        if (matches.length >= maxResults) {
-            truncated = true;
-            return;
-        }
-        let entries;
-        try {
-            entries = await readdir(dir, { withFileTypes: true });
-        }
-        catch {
-            return;
-        }
-        for (const entry of entries) {
-            if (matches.length >= maxResults) {
-                truncated = true;
-                return;
-            }
-            if (entry.isDirectory()) {
-                if (DEFAULT_IGNORED_DIRS.has(entry.name))
-                    continue;
-                await walk(join(dir, entry.name));
-            }
-            else if (entry.isFile()) {
-                if (fileFilterRegex && !fileFilterRegex.test(entry.name))
-                    continue;
-                await searchInFile(join(dir, entry.name));
-            }
-        }
-    }
-    const targetDirs = input.paths?.length
-        ? input.paths.map((p) => registry.resolvePath(workspace, p))
-        : [searchRoot];
-    for (const dir of targetDirs) {
-        const s = await stat(dir).catch(() => null);
-        if (s?.isDirectory()) {
-            await walk(dir);
-        }
-        else if (s?.isFile()) {
-            await searchInFile(dir);
-        }
-    }
-    return {
-        matches,
-        total: matches.length,
-        truncated,
-    };
-}
-export async function inspectProject(registry, input) {
-    const workspace = registry.getWorkspace(input.workspaceId);
-    const targetDir = input.path
-        ? registry.resolvePath(workspace, input.path)
-        : workspace.root;
-    const projectTypes = [];
-    const packageManagers = [];
-    const frameworks = [];
-    const configFiles = [];
-    const recommendedCommands = {};
-    const details = {};
-    let entries = [];
-    try {
-        entries = await readdir(targetDir);
-    }
-    catch { }
-    const entrySet = new Set(entries);
-    // Check Node.js / TypeScript
-    if (entrySet.has("package.json")) {
-        projectTypes.push("nodejs");
-        configFiles.push("package.json");
-        try {
-            const pkgContent = await readFile(join(targetDir, "package.json"), "utf8");
-            const pkgJson = JSON.parse(pkgContent);
-            details.packageName = pkgJson.name;
-            details.scripts = pkgJson.scripts ?? {};
-            if (pkgJson.scripts?.build)
-                recommendedCommands.build = "npm run build";
-            if (pkgJson.scripts?.dev)
-                recommendedCommands.run = "npm run dev";
-            else if (pkgJson.scripts?.start)
-                recommendedCommands.run = "npm start";
-            if (pkgJson.scripts?.test)
-                recommendedCommands.test = "npm test";
-            if (pkgJson.scripts?.lint)
-                recommendedCommands.lint = "npm run lint";
-            const allDeps = { ...(pkgJson.dependencies ?? {}), ...(pkgJson.devDependencies ?? {}) };
-            if (allDeps.next)
-                frameworks.push("nextjs");
-            if (allDeps.vite)
-                frameworks.push("vite");
-            if (allDeps.react)
-                frameworks.push("react");
-            if (allDeps.express)
-                frameworks.push("express");
-        }
-        catch { }
-    }
-    if (entrySet.has("package-lock.json"))
-        packageManagers.push("npm");
-    if (entrySet.has("pnpm-lock.yaml"))
-        packageManagers.push("pnpm");
-    if (entrySet.has("yarn.lock"))
-        packageManagers.push("yarn");
-    if (entrySet.has("bun.lockb") || entrySet.has("bun.lock"))
-        packageManagers.push("bun");
-    if (entrySet.has("tsconfig.json")) {
-        projectTypes.push("typescript");
-        configFiles.push("tsconfig.json");
-    }
-    // Check .NET
-    const dotnetFiles = entries.filter((e) => e.endsWith(".csproj") || e.endsWith(".fsproj") || e.endsWith(".sln"));
-    if (dotnetFiles.length > 0) {
-        projectTypes.push("dotnet");
-        configFiles.push(...dotnetFiles);
-        recommendedCommands.build = recommendedCommands.build ?? "dotnet build";
-        recommendedCommands.run = recommendedCommands.run ?? "dotnet run";
-        recommendedCommands.test = recommendedCommands.test ?? "dotnet test";
-        recommendedCommands.format = recommendedCommands.format ?? "dotnet format";
-        details.dotnetFiles = dotnetFiles;
-    }
-    // Check Godot
-    if (entrySet.has("project.godot")) {
-        projectTypes.push("godot");
-        configFiles.push("project.godot");
-        recommendedCommands.run = recommendedCommands.run ?? "godot --path .";
-        details.godotProject = true;
-    }
-    // Check Python
-    if (entrySet.has("pyproject.toml") || entrySet.has("requirements.txt") || entrySet.has("setup.py")) {
-        projectTypes.push("python");
-        if (entrySet.has("pyproject.toml"))
-            configFiles.push("pyproject.toml");
-        if (entrySet.has("requirements.txt"))
-            configFiles.push("requirements.txt");
-        recommendedCommands.run = recommendedCommands.run ?? "python main.py";
-    }
-    // Check Git
-    if (entrySet.has(".git")) {
-        configFiles.push(".git");
-        details.gitRepository = true;
-    }
-    return {
-        workspaceId: input.workspaceId,
-        root: targetDir,
-        projectTypes,
-        packageManagers,
-        frameworks,
-        configFiles,
-        recommendedCommands,
-        details,
-    };
-}
+export * from "./workspace/search-discovery.js";