@aiwg/cli 0.0.0-bootstrap.0 → 2026.7.17

package/dist/src/extensions/project-local-doctor.js

@@ -0,0 +1,281 @@
+/**
+ * Project-Local Doctor Section
+ *
+ * Builds the "Project-local artifacts" section for `aiwg doctor` output
+ * per the spec at @.aiwg/architecture/design-doctor-log-promote.md (#1049).
+ *
+ * Pure function over (projectDir, frameworkRoot) — returns a string. The
+ * doctor handler in src/cli/handlers/utilities.ts is responsible for
+ * printing it. Section is fully suppressed when no project-local dirs
+ * are present.
+ *
+ * @design @.aiwg/architecture/design-doctor-log-promote.md
+ * @implements #1037
+ */
+import { join, resolve } from 'path';
+import { homedir } from 'os';
+import { discoverProjectLocalBundles } from './project-local-discovery.js';
+import { buildUpstreamRegistry } from './upstream-registry.js';
+import { resolveShadows } from './shadow-resolver.js';
+import { checkBundleManifestIgnored } from './project-local-gitignore.js';
+import { sha256OfFileRawAndNormalized } from './managed-marker.js';
+import { projectAiwgPath } from '../config/project-artifacts.js';
+import { projectRelativePathIfInside } from './project-local-paths.js';
+import { auditProjectQuickref } from './project-quickref.js';
+/**
+ * Hash a deployed file in raw and managed-marker-normalized forms. Returns
+ * null on read errors (e.g., file missing — caller treats as
+ * deploy-not-present).
+ *
+ * Source files are recorded via the same normalization in
+ * `hashBundleArtifacts()`, so the equivalence relation is symmetric.
+ *
+ * @implements #1086
+ */
+async function hashDeployed(absPath) {
+    try {
+        return await sha256OfFileRawAndNormalized(absPath);
+    }
+    catch {
+        return null;
+    }
+}
+const TYPES = ['extension', 'addon', 'framework', 'plugin', 'provider'];
+const TYPE_DIR = {
+    extension: 'extensions',
+    addon: 'addons',
+    framework: 'frameworks',
+    plugin: 'plugins',
+    provider: 'providers',
+};
+// Per PUW-026 (#1127): home-deploying providers get absolute prefixes so
+// `resolve(projectDir, prefix)` correctly produces the home-rooted path
+// (resolve treats absolute paths as authoritative). Previously these were
+// `null`, which silently skipped lifecycle operations against home-deployed
+// project-local bundles.
+const PROVIDER_PREFIX = {
+    claude: '.claude',
+    cursor: '.cursor',
+    factory: '.factory',
+    opencode: '.opencode',
+    windsurf: '.windsurf',
+    warp: '.warp',
+    codex: '.codex',
+    copilot: '.github',
+    openclaw: resolve(homedir(), '.openclaw'),
+    hermes: resolve(homedir(), '.hermes'),
+};
+export async function buildProjectLocalDoctorSection(opts) {
+    const { projectDir, frameworkRoot, config, quiet = false } = opts;
+    const discovery = await discoverProjectLocalBundles(projectDir);
+    const quickrefAudit = await auditProjectQuickref(projectDir, config?.providers ?? []);
+    const quickrefErrors = [...quickrefAudit.errors];
+    if (quickrefAudit.exists) {
+        const quickrefRelPath = projectRelativePathIfInside(projectDir, projectAiwgPath(projectDir, 'quickref.json'));
+        const ignored = quickrefRelPath
+            ? await checkBundleManifestIgnored(projectDir, quickrefRelPath)
+            : null;
+        if (ignored === true && quickrefRelPath) {
+            quickrefErrors.push(`${quickrefRelPath} is ignored by git; canonical project quickref source must be committed`);
+        }
+    }
+    // No project-local content → no section at all
+    if (discovery.isEmpty && discovery.errors.length === 0 && !quickrefAudit.exists && quickrefErrors.length === 0) {
+        return { output: '', validationErrors: 0, denylistViolations: 0, driftCount: 0, hasFailures: false };
+    }
+    const lines = ['', '── Project-local artifacts ────────────────────────────────────'];
+    // Counts
+    if (!quiet) {
+        lines.push(`  Discovered: ${discovery.bundles.length} bundle${discovery.bundles.length === 1 ? '' : 's'}`);
+        for (const t of TYPES) {
+            const dirName = TYPE_DIR[t];
+            const ofType = discovery.bundles.filter(b => b.type === t);
+            if (ofType.length === 0 && discovery.bundles.length > 0)
+                continue;
+            const idList = ofType.length > 0 ? `  (${ofType.map(b => b.id).join(', ')})` : '';
+            lines.push(`    ${dirName.padEnd(11)} ${ofType.length}${idList}`);
+        }
+        lines.push('');
+        if (quickrefAudit.exists) {
+            lines.push(`  Project quickref: ${quickrefAudit.skillName ?? 'invalid source'}`);
+            lines.push('');
+        }
+    }
+    // Validation
+    const validationErrors = discovery.errors.length + quickrefErrors.length;
+    if (validationErrors === 0) {
+        if (!quiet)
+            lines.push(`  Validation: ✓ all manifests${quickrefAudit.exists ? ' and project quickref source' : ''} valid`);
+    }
+    else {
+        lines.push(`  Validation: ✗ ${validationErrors} error${validationErrors === 1 ? '' : 's'}`);
+        for (const e of discovery.errors.slice(0, 10)) {
+            lines.push(`    ✗ ${e.path}: ${e.field} — ${e.actual}`);
+        }
+        for (const error of quickrefErrors.slice(0, Math.max(0, 10 - discovery.errors.length))) {
+            lines.push(`    ✗ ${error}`);
+        }
+        if (validationErrors > 10) {
+            lines.push(`    + ${validationErrors - 10} more (run 'aiwg list --project-local' for full list)`);
+        }
+    }
+    lines.push('');
+    // Shadows + denylist
+    let denylistViolations = 0;
+    if (discovery.bundles.length > 0) {
+        try {
+            const upstream = await buildUpstreamRegistry({ frameworkRoot });
+            const shadowResult = await resolveShadows(discovery.bundles, upstream);
+            const refusals = shadowResult.resolutions.filter(r => r.verdict === 'refuse-unsafe' || r.verdict === 'refuse-phantom' || r.verdict === 'refuse-duplicate');
+            denylistViolations = refusals.length;
+            if (!quiet) {
+                const informational = shadowResult.shadows.filter(s => s.verdict === 'deploy-with-warning' || s.verdict === 'deploy-acknowledged');
+                if (informational.length > 0) {
+                    lines.push(`  Shadows (${informational.length}):`);
+                    for (const s of informational) {
+                        const marker = s.verdict === 'deploy-acknowledged' ? '!!' : '⚠';
+                        const note = s.verdict === 'deploy-acknowledged' ? '  overrides safety-critical (acknowledged)' : `  overrides ${s.upstream?.source ?? 'upstream'}`;
+                        lines.push(`    ${marker} ${s.bundleId} :: ${s.artifactType}/${s.artifactId}${note}`);
+                    }
+                    lines.push('');
+                }
+            }
+            if (refusals.length > 0) {
+                lines.push(`  Denylist violations (${refusals.length}):`);
+                for (const r of refusals) {
+                    lines.push(`    ✗ ${r.bundleId} :: ${r.artifactType}/${r.artifactId}  [${r.verdict}]`);
+                }
+                lines.push('');
+            }
+            else if (!quiet) {
+                lines.push('  Denylist violations: 0');
+                lines.push('');
+            }
+        }
+        catch {
+            // Shadow resolution failure is non-fatal for doctor
+        }
+    }
+    // Drift detection (requires config and artifactHashes)
+    let driftCount = quickrefAudit.drift.length;
+    const driftLines = quickrefAudit.drift.map(message => `    ✗ project quickref :: ${message}`);
+    let unhashedSeen = false;
+    if (config) {
+        for (const bundle of discovery.bundles) {
+            const entry = config.installed[bundle.id];
+            if (!entry || entry.source !== 'project-local')
+                continue;
+            const hashes = entry.artifactHashes;
+            if (!hashes) {
+                unhashedSeen = true;
+                continue;
+            }
+            for (const provider of Object.keys(entry.deployedTo)) {
+                const prefix = PROVIDER_PREFIX[provider];
+                if (!prefix)
+                    continue;
+                for (const [sourceRel, expectedHash] of Object.entries(hashes)) {
+                    const deployedAbs = resolve(projectDir, `${prefix}/${sourceRel}`);
+                    const actualHash = await hashDeployed(deployedAbs);
+                    if (actualHash === null) {
+                        // Missing — not drift, deploy is just absent
+                        continue;
+                    }
+                    if (actualHash.normalized !== expectedHash && actualHash.raw !== expectedHash) {
+                        driftCount++;
+                        driftLines.push(`    ✗ ${bundle.id} :: ${sourceRel} @ ${provider}  (deployed file differs from source)`);
+                    }
+                }
+            }
+        }
+    }
+    if (driftCount > 0) {
+        lines.push(`  Drift (${driftCount}):`);
+        lines.push(...driftLines);
+        lines.push('');
+    }
+    else if (!quiet) {
+        lines.push('  Drift: 0');
+        if (unhashedSeen) {
+            lines.push('    (some entries lack artifactHashes — re-run `aiwg use <bundle>` to record)');
+        }
+        lines.push('');
+    }
+    // Provider deployment matrix
+    if (!quiet && config) {
+        const projectLocalEntries = Object.entries(config.installed).filter(([, e]) => e.source === 'project-local');
+        if (projectLocalEntries.length > 0) {
+            const allProviders = new Set();
+            for (const [, entry] of projectLocalEntries) {
+                for (const p of Object.keys(entry.deployedTo))
+                    allProviders.add(p);
+            }
+            const provList = [...allProviders].sort();
+            if (provList.length > 0) {
+                lines.push('  Provider deployment matrix:');
+                lines.push(`    ${'bundle'.padEnd(20)}${provList.map(p => p.padEnd(8)).join('')}`);
+                for (const [name, entry] of projectLocalEntries) {
+                    const cells = provList.map(p => {
+                        const c = entry.deployedTo[p];
+                        if (!c)
+                            return '-'.padEnd(8);
+                        const total = c.agents + c.commands + c.skills + c.rules;
+                        return `✓ ${total}`.padEnd(8);
+                    }).join('');
+                    lines.push(`    ${name.padEnd(20)}${cells}`);
+                }
+                lines.push('');
+            }
+        }
+    }
+    // #1085 — flag bundles whose source is silently git-ignored. Best-effort
+    // (uses `git check-ignore`); skipped silently outside git repos.
+    let gitignoredCount = 0;
+    if (discovery.bundles.length > 0) {
+        const ignored = [];
+        for (const b of discovery.bundles) {
+            const manifestRelPath = projectRelativePathIfInside(projectDir, join(b.bundlePath, 'manifest.json'));
+            const isIgnored = manifestRelPath
+                ? await checkBundleManifestIgnored(projectDir, manifestRelPath)
+                : null;
+            if (isIgnored === true)
+                ignored.push(`${b.type}/${b.id} (${manifestRelPath})`);
+        }
+        gitignoredCount = ignored.length;
+        if (ignored.length > 0) {
+            lines.push(`  Git tracking: ✗ ${ignored.length} bundle${ignored.length === 1 ? '' : 's'} silently ignored`);
+            for (const i of ignored.slice(0, 5)) {
+                lines.push(`    ✗ ${i}`);
+            }
+            if (ignored.length > 5) {
+                lines.push(`    + ${ignored.length - 5} more`);
+            }
+            lines.push('    Project-local bundle source should be tracked. Add to .gitignore:');
+            lines.push('      !.aiwg/quickref.json');
+            lines.push('      !.aiwg/addons/');
+            lines.push('      !.aiwg/extensions/');
+            lines.push('      !.aiwg/frameworks/');
+            lines.push('      !.aiwg/plugins/');
+            lines.push('    Or run `aiwg new-bundle <name>` to have AIWG add this block automatically.');
+            lines.push('');
+        }
+        else if (!quiet) {
+            lines.push('  Git tracking: ✓ all bundle manifests visible to git');
+            lines.push('');
+        }
+    }
+    const hasFailures = validationErrors > 0 || denylistViolations > 0 || driftCount > 0 || gitignoredCount > 0;
+    return {
+        output: lines.join('\n'),
+        validationErrors,
+        denylistViolations,
+        driftCount,
+        hasFailures,
+    };
+}
+/** Convenience accessor: just the section text. */
+export async function projectLocalDoctorSection(projectDir, frameworkRoot, config, quiet = false) {
+    const r = await buildProjectLocalDoctorSection({ projectDir, frameworkRoot, config, quiet });
+    return r.output;
+}
+//# sourceMappingURL=project-local-doctor.js.map

package/dist/src/extensions/project-local-gitignore.js

@@ -0,0 +1,176 @@
+/**
+ * Project-local .gitignore management.
+ *
+ * AIWG-managed projects historically `.gitignore` the whole `.aiwg/` tree
+ * because most of it is generated state (working scratch, ralph state,
+ * research corpora, etc.). With #1033's project-local artifact lifecycle,
+ * `.aiwg/{addons,extensions,frameworks,plugins,providers}/` is now also operator-
+ * authored source — and a blanket ignore silently drops it from version
+ * control.
+ *
+ * This module provides:
+ *
+ *   - `detectAiwgBlanketIgnore()`   — read .gitignore, classify the rules
+ *   - `appendAiwgSourceTrackBlock()` — append the canonical un-ignore
+ *                                      block (sentinel-marked, idempotent)
+ *   - `checkBundleManifestIgnored()` — per-bundle: is its manifest.json
+ *                                      git-ignored right now?
+ *
+ * @implements #1085
+ */
+import { readFile, writeFile, access } from 'fs/promises';
+import { join } from 'path';
+import { execFile } from 'child_process';
+import { promisify } from 'util';
+const execFileP = promisify(execFile);
+/**
+ * Sentinel comment that marks the AIWG-managed un-ignore block.
+ *
+ * We detect existing blocks by this exact line so re-running new-bundle
+ * never produces duplicate blocks.
+ */
+export const AIWG_GITIGNORE_SENTINEL = '# AIWG project-local bundle source — track these (managed by AIWG)';
+/**
+ * The canonical block we append when a project blanket-ignores `.aiwg/`
+ * but doesn't yet un-ignore the source directories.
+ */
+export const AIWG_GITIGNORE_BLOCK = [
+    '',
+    AIWG_GITIGNORE_SENTINEL,
+    '!.aiwg/aiwg.config',
+    '!.aiwg/quickref.json',
+    '!.aiwg/addons/',
+    '!.aiwg/extensions/',
+    '!.aiwg/frameworks/',
+    '!.aiwg/plugins/',
+    '!.aiwg/providers/',
+    '',
+].join('\n');
+/**
+ * Inspect a project's `.gitignore` and classify it for our purposes.
+ *
+ * Detection rules — only the patterns we actually need:
+ *
+ *   blanket ignore: a non-negation, non-comment line that matches the
+ *   `.aiwg/` directory directly. Specifically: `.aiwg`, `.aiwg/`,
+ *   `.aiwg/*`, `.aiwg/**`, or path-anchored variants thereof.
+ *
+ *   existing negation: a line beginning with `!` that points into one of
+ *   our four source directories. e.g. `!.aiwg/addons/` or
+ *   `!.aiwg/extensions/foo/`.
+ */
+export async function detectAiwgBlanketIgnore(projectDir) {
+    const path = join(projectDir, '.gitignore');
+    let raw;
+    try {
+        raw = await readFile(path, 'utf8');
+    }
+    catch {
+        return {
+            blanketIgnore: false,
+            hasExistingNegation: false,
+            hasManagedBlock: false,
+            gitignoreExists: false,
+        };
+    }
+    const lines = raw.split(/\r?\n/);
+    const stripped = lines.map(l => l.trim()).filter(l => l.length > 0 && !l.startsWith('#'));
+    const isBlanket = (l) => {
+        if (l.startsWith('!'))
+            return false;
+        // Strip a leading slash so `/.aiwg/` and `.aiwg/` are equivalent.
+        const norm = l.replace(/^\//, '');
+        return norm === '.aiwg' || norm === '.aiwg/' || norm === '.aiwg/*' || norm === '.aiwg/**';
+    };
+    const isSourceNegation = (l) => {
+        if (!l.startsWith('!'))
+            return false;
+        // `.aiwg/addons/`, `.aiwg/extensions/foo`, `/.aiwg/providers/**`, etc.
+        const body = l.slice(1).replace(/^\//, '');
+        return /^\.aiwg\/(addons|extensions|frameworks|plugins|providers)(\/.*)?$/.test(body);
+    };
+    const blanketIgnore = stripped.some(isBlanket);
+    const hasExistingNegation = stripped.some(isSourceNegation);
+    const hasManagedBlock = lines.some(l => l.trim() === AIWG_GITIGNORE_SENTINEL);
+    return { blanketIgnore, hasExistingNegation, hasManagedBlock, gitignoreExists: true };
+}
+/**
+ * Append the canonical un-ignore block to `.gitignore` if and only if:
+ *
+ *   - `.gitignore` exists, AND
+ *   - it blanket-ignores `.aiwg/`, AND
+ *   - it does NOT already have any source-directory negation, AND
+ *   - it does NOT already have our sentinel-marked block.
+ *
+ * The function is idempotent in all four conditions. No-op when the
+ * project doesn't blanket-ignore (operator has presumably configured a
+ * selective ignore already).
+ */
+export async function appendAiwgSourceTrackBlock(projectDir) {
+    const report = await detectAiwgBlanketIgnore(projectDir);
+    if (!report.gitignoreExists) {
+        return { added: false, reason: 'no .gitignore — skipped' };
+    }
+    if (!report.blanketIgnore) {
+        return { added: false, reason: 'no blanket .aiwg ignore — already tracking sources' };
+    }
+    // Check managed-block presence BEFORE generic negation detection — once
+    // we've added our block, it itself contains source-directory negations,
+    // so the existing-negation check would otherwise mis-fire on subsequent
+    // runs.
+    if (report.hasManagedBlock) {
+        const path = join(projectDir, '.gitignore');
+        const existing = await readFile(path, 'utf8');
+        if (!existing.split(/\r?\n/).some(line => line.trim() === '!.aiwg/quickref.json')) {
+            const sep = existing.endsWith('\n') ? '' : '\n';
+            await writeFile(path, `${existing}${sep}!.aiwg/quickref.json\n`, 'utf8');
+            return { added: true, reason: 'updated managed block to track .aiwg/quickref.json' };
+        }
+        return { added: false, reason: 'block already present — no change' };
+    }
+    if (report.hasExistingNegation) {
+        return { added: false, reason: 'operator has explicit !.aiwg negation — no change' };
+    }
+    const path = join(projectDir, '.gitignore');
+    const existing = await readFile(path, 'utf8');
+    const sep = existing.endsWith('\n') ? '' : '\n';
+    await writeFile(path, existing + sep + AIWG_GITIGNORE_BLOCK, 'utf8');
+    return { added: true, reason: 'appended project-local source un-ignore block (bundles, config, and quickref)' };
+}
+/**
+ * Per-bundle: is its `manifest.json` currently ignored by git?
+ *
+ * Uses `git check-ignore` which is authoritative — it reflects every
+ * `.gitignore` precedence rule, including negations and core.excludesFile.
+ *
+ * Returns `null` when git isn't installed or the project isn't a git
+ * repo. Caller should treat null as "skip the check".
+ */
+export async function checkBundleManifestIgnored(projectDir, manifestRelPath) {
+    // Quick sanity: ensure path doesn't try to escape projectDir
+    if (manifestRelPath.startsWith('/') || manifestRelPath.includes('..')) {
+        return null;
+    }
+    try {
+        await access(join(projectDir, '.git'));
+    }
+    catch {
+        return null;
+    }
+    try {
+        // `git check-ignore -q <path>` returns exit 0 if path is ignored,
+        // 1 if not ignored, 128 on error. We want a tristate.
+        await execFileP('git', ['check-ignore', '-q', manifestRelPath], {
+            cwd: projectDir,
+        });
+        // exit 0 → ignored
+        return true;
+    }
+    catch (err) {
+        const code = err.code;
+        if (code === 1)
+            return false; // not ignored
+        return null; // 128 or other — skip the check
+    }
+}
+//# sourceMappingURL=project-local-gitignore.js.map

package/dist/src/extensions/project-local-paths.js

@@ -0,0 +1,121 @@
+/**
+ * Project-local bundle search root resolution.
+ *
+ * The canonical project-local source tree lives under the configured AIWG
+ * artifact root, not necessarily `<project>/.aiwg`. Operators may also add
+ * extra roots for team/private bundles without moving the project corpus.
+ */
+import { existsSync, readFileSync } from 'fs';
+import { delimiter, isAbsolute, join, relative, resolve, sep } from 'path';
+import { DEFAULT_PROJECT_AIWG_DIR, expandProjectArtifactPath, resolveProjectAiwgDir, } from '../config/project-artifacts.js';
+export const PROJECT_LOCAL_SEARCH_PATHS_ENV = 'AIWG_PROJECT_LOCAL_PATHS';
+export const PROJECT_LOCAL_TYPE_TO_DIR = {
+    extension: 'extensions',
+    addon: 'addons',
+    framework: 'frameworks',
+    plugin: 'plugins',
+    provider: 'providers',
+};
+export const PROJECT_LOCAL_DIR_TO_TYPE = Object.fromEntries(Object.entries(PROJECT_LOCAL_TYPE_TO_DIR).map(([type, dirName]) => [dirName, type]));
+export const PROJECT_LOCAL_SCAN_DIRS = Object.values(PROJECT_LOCAL_TYPE_TO_DIR);
+function toPortablePath(pathValue) {
+    return pathValue.split(sep).join('/');
+}
+export function isPathInside(parentPath, candidatePath) {
+    const parent = resolve(parentPath);
+    const candidate = resolve(candidatePath);
+    const rel = relative(parent, candidate);
+    return rel === '' || (rel.length > 0 && !rel.startsWith('..') && !isAbsolute(rel));
+}
+export function projectRelativePathIfInside(projectDir, absPath) {
+    if (!isPathInside(projectDir, absPath))
+        return null;
+    const rel = toPortablePath(relative(resolve(projectDir), resolve(absPath)));
+    return rel.length > 0 ? rel : '.';
+}
+function displayPrefixForAdditionalRoot(projectDir, rootPath) {
+    const rel = projectRelativePathIfInside(projectDir, rootPath);
+    return rel ?? resolve(rootPath);
+}
+function readConfiguredSearchPaths(projectDir, env) {
+    const configPath = join(resolveProjectAiwgDir(projectDir, env), 'aiwg.config');
+    if (!existsSync(configPath))
+        return [];
+    let parsed;
+    try {
+        parsed = JSON.parse(readFileSync(configPath, 'utf-8'));
+    }
+    catch {
+        return [];
+    }
+    if (!parsed || typeof parsed !== 'object')
+        return [];
+    const record = parsed;
+    const projectLocal = record.projectLocal ?? record.project_local;
+    if (!projectLocal || typeof projectLocal !== 'object')
+        return [];
+    const projectLocalRecord = projectLocal;
+    const rawPaths = projectLocalRecord.searchPaths ?? projectLocalRecord.search_paths;
+    if (!Array.isArray(rawPaths))
+        return [];
+    return rawPaths
+        .filter((value) => typeof value === 'string')
+        .map(value => value.trim())
+        .filter(value => value.length > 0);
+}
+export function parseProjectLocalSearchPaths(value) {
+    if (!value)
+        return [];
+    return value
+        .split(delimiter)
+        .map(part => part.trim())
+        .filter(part => part.length > 0);
+}
+/**
+ * Resolve project-local bundle roots in scan order.
+ *
+ * The configured project AIWG artifact root is always first and keeps the
+ * virtual `.aiwg/...` display prefix so registry bindings survive a move or
+ * rename. Additional roots are then loaded from `aiwg.config` and finally
+ * `AIWG_PROJECT_LOCAL_PATHS`.
+ */
+export function resolveProjectLocalSearchRoots(projectDir, env = process.env) {
+    const roots = [];
+    const seen = new Set();
+    const addRoot = (rootPath, source, displayPrefix) => {
+        const absoluteRoot = resolve(rootPath);
+        const key = process.platform === 'win32' ? absoluteRoot.toLowerCase() : absoluteRoot;
+        if (seen.has(key))
+            return;
+        seen.add(key);
+        roots.push({ rootPath: absoluteRoot, source, displayPrefix });
+    };
+    addRoot(resolveProjectAiwgDir(projectDir, env), 'artifact-root', DEFAULT_PROJECT_AIWG_DIR);
+    for (const rawPath of readConfiguredSearchPaths(projectDir, env)) {
+        const rootPath = expandProjectArtifactPath(rawPath, projectDir);
+        addRoot(rootPath, 'config', displayPrefixForAdditionalRoot(projectDir, rootPath));
+    }
+    for (const rawPath of parseProjectLocalSearchPaths(env[PROJECT_LOCAL_SEARCH_PATHS_ENV])) {
+        const rootPath = expandProjectArtifactPath(rawPath, projectDir);
+        addRoot(rootPath, 'env', displayPrefixForAdditionalRoot(projectDir, rootPath));
+    }
+    return roots;
+}
+export function projectLocalDisplayPath(projectDir, absPath, searchRoot) {
+    const absolutePath = resolve(absPath);
+    if (searchRoot && isPathInside(searchRoot.rootPath, absolutePath)) {
+        const rel = toPortablePath(relative(searchRoot.rootPath, absolutePath));
+        const prefix = searchRoot.displayPrefix.replace(/\/+$/, '');
+        if (rel.length === 0)
+            return prefix || '.';
+        return prefix.length > 0 && prefix !== '.'
+            ? `${prefix}/${rel}`
+            : rel;
+    }
+    const projectRel = projectRelativePathIfInside(projectDir, absolutePath);
+    return projectRel ?? absolutePath;
+}
+export function ensureTrailingSlash(pathValue) {
+    return pathValue.endsWith('/') ? pathValue : `${pathValue}/`;
+}
+//# sourceMappingURL=project-local-paths.js.map