auvrynt 1.0.1

package/dist/processes.js

@@ -0,0 +1,218 @@
+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 { }
+            }
+        }
+    }
+}

package/dist/review-checkpoints.js

@@ -0,0 +1,142 @@
+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 });
+}

package/dist/roots.js

@@ -0,0 +1,53 @@
+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);
+}

package/dist/search-discovery.js

@@ -0,0 +1,271 @@
+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,
+    };
+}