auvrynt 1.0.2 → 1.0.5

package/dist/workspace/git-worktrees.js

@@ -0,0 +1,141 @@
+import { randomBytes } from "node:crypto";
+import { execFile } from "node:child_process";
+import { promisify } from "node:util";
+import { mkdir, readdir, realpath, rm, stat } from "node:fs/promises";
+import { basename, join, relative, resolve } from "node:path";
+import { assertAllowedPath, isPathInsideRoot } from "../roots.js";
+const execFileAsync = promisify(execFile);
+const MAX_MANAGED_WORKTREES = 16;
+export class GitWorktreeError extends Error {
+    code;
+    constructor(code, message) {
+        super(message);
+        this.code = code;
+        this.name = "GitWorktreeError";
+    }
+}
+export async function createManagedWorktree(input) {
+    const sourcePath = assertAllowedPath(input.sourcePath, input.config.allowedRoots);
+    try {
+        const sourceStats = await stat(sourcePath);
+        if (!sourceStats.isDirectory()) {
+            throw new GitWorktreeError("GIT_REPOSITORY_NOT_FOUND", `Cannot open workspace in worktree mode because the source path is not a directory: ${input.sourcePath}`);
+        }
+    }
+    catch (error) {
+        if (error instanceof GitWorktreeError)
+            throw error;
+        throw new GitWorktreeError("GIT_REPOSITORY_NOT_FOUND", `Cannot open workspace in worktree mode because the source path does not exist: ${input.sourcePath}`);
+    }
+    const sourceRoot = await resolveGitRoot(sourcePath, input.config.allowedRoots);
+    const baseRef = input.baseRef ?? "HEAD";
+    const baseSha = await resolveBaseCommit(sourceRoot, baseRef);
+    const dirtySource = (await git(["status", "--porcelain=v1"], sourceRoot)).trim().length > 0;
+    const worktreePath = managedWorktreePath({
+        worktreeRoot: input.config.worktreeRoot,
+        repoRoot: sourceRoot,
+    });
+    await mkdir(input.config.worktreeRoot, { recursive: true });
+    assertAllowedPath(worktreePath, [input.config.worktreeRoot]);
+    const existing = await readdir(input.config.worktreeRoot).catch(() => []);
+    const managedCount = existing.filter((e) => /^[a-zA-Z0-9._-]+-[a-f0-9]{8}$/.test(e)).length;
+    if (managedCount >= MAX_MANAGED_WORKTREES) {
+        throw new GitWorktreeError("GIT_WORKTREE_CREATE_FAILED", `Cannot create managed worktree: limit of ${MAX_MANAGED_WORKTREES} concurrent managed worktrees reached. Remove unused worktrees and retry.`);
+    }
+    try {
+        await git(["worktree", "add", "--detach", worktreePath, baseSha], sourceRoot);
+    }
+    catch (error) {
+        await rm(worktreePath, { recursive: true, force: true });
+        const message = error instanceof Error ? error.message : String(error);
+        throw new GitWorktreeError("GIT_WORKTREE_CREATE_FAILED", `Git failed to create the managed worktree. ${message}`);
+    }
+    return {
+        sourceRoot,
+        path: worktreePath,
+        baseRef,
+        baseSha,
+        dirtySource,
+        detached: true,
+        managed: true,
+    };
+}
+async function resolveGitRoot(path, allowedRoots) {
+    try {
+        const output = await git(["rev-parse", "--show-toplevel"], path);
+        return await assertGitRootAllowed(output.trim(), allowedRoots);
+    }
+    catch (error) {
+        if (isGitUnavailable(error)) {
+            throw new GitWorktreeError("GIT_NOT_AVAILABLE", "Cannot open workspace in worktree mode because Git is not available on this machine.");
+        }
+        throw new GitWorktreeError("GIT_REPOSITORY_NOT_FOUND", `Cannot open workspace in worktree mode because this path is not inside a Git repository: ${path}. Use mode=\"checkout\" to work directly in this directory, or initialize Git and create an initial commit first.`);
+    }
+}
+async function assertGitRootAllowed(gitRoot, allowedRoots) {
+    try {
+        return assertAllowedPath(gitRoot, allowedRoots);
+    }
+    catch {
+        const canonicalGitRoot = await realpath(gitRoot);
+        for (const allowedRoot of allowedRoots) {
+            const canonicalAllowedRoot = await realpath(allowedRoot).catch(() => undefined);
+            if (!canonicalAllowedRoot || !isPathInsideRoot(canonicalGitRoot, canonicalAllowedRoot)) {
+                continue;
+            }
+            const logicalGitRoot = resolve(allowedRoot, relative(canonicalAllowedRoot, canonicalGitRoot));
+            return assertAllowedPath(logicalGitRoot, allowedRoots);
+        }
+        return assertAllowedPath(canonicalGitRoot, allowedRoots);
+    }
+}
+async function resolveBaseCommit(sourceRoot, baseRef) {
+    try {
+        return (await git(["rev-parse", "--verify", `${baseRef}^{commit}`], sourceRoot)).trim();
+    }
+    catch (error) {
+        if (baseRef === "HEAD") {
+            throw new GitWorktreeError("GIT_REPOSITORY_HAS_NO_COMMITS", "Cannot open workspace in worktree mode because the repository has no commits yet. Create an initial commit first, or use mode=\"checkout\".");
+        }
+        throw new GitWorktreeError("GIT_INVALID_BASE_REF", `Cannot open workspace in worktree mode because baseRef ${JSON.stringify(baseRef)} does not resolve to a commit.`);
+    }
+}
+function managedWorktreePath(input) {
+    const repoName = sanitizePathSegment(basename(input.repoRoot)) || "repo";
+    const worktreeId = randomBytes(4).toString("hex");
+    return join(input.worktreeRoot, `${repoName}-${worktreeId}`);
+}
+function sanitizePathSegment(value) {
+    return value
+        .replace(/[^a-zA-Z0-9._-]+/g, "-")
+        .replace(/^-+|-+$/g, "")
+        .slice(0, 80);
+}
+async function git(args, cwd) {
+    try {
+        const { stdout } = await execFileAsync("git", args, {
+            cwd,
+            maxBuffer: 10 * 1024 * 1024,
+            windowsHide: true,
+        });
+        return stdout;
+    }
+    catch (error) {
+        if (isGitUnavailable(error))
+            throw error;
+        const stderr = typeof error === "object" && error && "stderr" in error
+            ? String(error.stderr ?? "").trim()
+            : "";
+        const stdout = typeof error === "object" && error && "stdout" in error
+            ? String(error.stdout ?? "").trim()
+            : "";
+        const details = stderr || stdout || (error instanceof Error ? error.message : String(error));
+        throw new Error(details);
+    }
+}
+function isGitUnavailable(error) {
+    return Boolean(typeof error === "object" &&
+        error &&
+        "code" in error &&
+        error.code === "ENOENT");
+}

package/dist/workspace/git.js

@@ -0,0 +1,42 @@
+import { createHash } from "node:crypto";
+import { execFile } from "node:child_process";
+import { promisify } from "node:util";
+const execFileAsync = promisify(execFile);
+export async function git(cwd, args, options = {}) {
+    const { stdout, stderr } = await execFileAsync("git", args, {
+        cwd,
+        env: options.env ? { ...process.env, ...options.env } : process.env,
+        maxBuffer: options.maxBuffer ?? 10 * 1024 * 1024,
+        windowsHide: true,
+    });
+    return { stdout, stderr };
+}
+export async function getGitEligibility(cwd) {
+    try {
+        await git(cwd, ["rev-parse", "--is-inside-work-tree"]);
+    }
+    catch {
+        return {
+            ok: false,
+            reason: "not_git",
+            message: "workspace is not inside a git repository",
+        };
+    }
+    const gitRoot = (await git(cwd, ["rev-parse", "--show-toplevel"])).stdout.trim();
+    try {
+        await git(gitRoot, ["rev-parse", "--verify", "--quiet", "HEAD^{commit}"]);
+    }
+    catch {
+        return {
+            ok: false,
+            gitRoot,
+            reason: "no_head",
+            message: "repository has no HEAD commit",
+        };
+    }
+    return { ok: true, gitRoot };
+}
+export function safeWorkspaceRefSegment(workspaceId) {
+    const safe = workspaceId.replace(/[^A-Za-z0-9._-]/g, "-");
+    return safe.length > 0 ? safe : createHash("sha256").update(workspaceId).digest("hex").slice(0, 16);
+}

package/dist/workspace/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/workspace/roots.js

@@ -0,0 +1,56 @@
+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 the canonical path that was actually authorized rather than the
+        // original symlink/junction spelling. This narrows the time-of-check /
+        // time-of-use window for callers that subsequently open or mutate it.
+        return resolvedPath;
+    }
+    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/workspace/search-discovery.js

@@ -0,0 +1,264 @@
+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;
+    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);
+            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);
+    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");
+    }
+    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;
+    }
+    if (entrySet.has("project.godot")) {
+        projectTypes.push("godot");
+        configFiles.push("project.godot");
+        recommendedCommands.run = recommendedCommands.run ?? "godot --path .";
+        details.godotProject = true;
+    }
+    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";
+    }
+    if (entrySet.has(".git")) {
+        configFiles.push(".git");
+        details.gitRepository = true;
+    }
+    return {
+        workspaceId: input.workspaceId,
+        root: targetDir,
+        projectTypes,
+        packageManagers,
+        frameworks,
+        configFiles,
+        recommendedCommands,
+        details,
+    };
+}

package/dist/workspace/skills.js

@@ -0,0 +1,45 @@
+import { homedir } from "node:os";
+import { resolve, sep } from "node:path";
+import { loadSkills, } from "@earendil-works/pi-coding-agent";
+import { expandHomePath, isPathInsideRoot } from "../roots.js";
+export function loadWorkspaceSkills(config, cwd) {
+    if (!config.skillsEnabled)
+        return { skills: [], diagnostics: [] };
+    return loadSkills({
+        cwd,
+        agentDir: config.agentDir,
+        skillPaths: config.skillPaths,
+        includeDefaults: true,
+    });
+}
+export function resolveSkillReadPath(skills, activatedSkillDirs, inputPath) {
+    const absolutePath = resolve(expandHomePath(inputPath));
+    for (const skill of skills) {
+        const skillFilePath = resolve(skill.filePath);
+        if (absolutePath === skillFilePath) {
+            return { absolutePath, skill, isSkillFile: true };
+        }
+    }
+    for (const skill of skills) {
+        const baseDir = resolve(skill.baseDir);
+        if (!activatedSkillDirs.has(baseDir))
+            continue;
+        if (!isPathInsideRoot(absolutePath, baseDir))
+            continue;
+        return { absolutePath, skill, isSkillFile: false };
+    }
+    return undefined;
+}
+export function markSkillActivated(activatedSkillDirs, skill) {
+    activatedSkillDirs.add(resolve(skill.baseDir));
+}
+export function formatPathForPrompt(path) {
+    const home = resolve(homedir());
+    const resolvedPath = resolve(path);
+    if (resolvedPath === home)
+        return "~";
+    if (resolvedPath.startsWith(`${home}${sep}`)) {
+        return `~/${resolvedPath.slice(home.length + 1).split(sep).join("/")}`;
+    }
+    return resolvedPath.split(sep).join("/");
+}