taphound 0.2.0-dev.1 → 0.2.0-dev.12

package/dist/adapters/filesystem/knowledge-registry.js

@@ -0,0 +1,223 @@
+import { createHash, randomUUID } from "node:crypto";
+import { lstat, readdir, readFile, realpath, rename, unlink, writeFile } from "node:fs/promises";
+import { basename, dirname, join, relative, resolve } from "node:path";
+import { AnchorDefinitionSchema, KnowledgeBundleIndexSchema, ScreenDefinitionSchema, hashKnowledge } from "../../domain/knowledge.js";
+import { KNOWLEDGE_DIR, KNOWLEDGE_INDEX_PATH } from "../../domain/workspace.js";
+import { isErrnoException } from "../../shared/errors.js";
+import { isContained } from "../../shared/paths.js";
+const MAX_KNOWLEDGE_FILE_BYTES = 1024 * 1024;
+function sha256(bytes) {
+    return createHash("sha256").update(bytes).digest("hex");
+}
+function serializedDocument(value) {
+    return `${JSON.stringify(value, null, 2)}\n`;
+}
+async function readBoundedJson(path) {
+    const before = await lstat(path);
+    if (!before.isFile() || before.isSymbolicLink()) {
+        throw new Error(`Knowledge document is not a regular file: ${path}`);
+    }
+    if (before.size > MAX_KNOWLEDGE_FILE_BYTES) {
+        throw new Error(`Knowledge document exceeds the size limit: ${path}`);
+    }
+    const bytes = await readFile(path);
+    const after = await lstat(path);
+    if (before.dev !== after.dev
+        || before.ino !== after.ino
+        || before.size !== after.size
+        || after.isSymbolicLink()) {
+        throw new Error(`Knowledge document changed while loading: ${path}`);
+    }
+    let value;
+    try {
+        value = JSON.parse(bytes.toString("utf8"));
+    }
+    catch (error) {
+        throw new Error(`Knowledge document is not valid JSON: ${path}`, {
+            cause: error
+        });
+    }
+    return { bytes, value };
+}
+async function atomicWrite(path, value) {
+    const temporary = join(dirname(path), `.${basename(path)}.${randomUUID()}.tmp`);
+    await writeFile(temporary, serializedDocument(value), {
+        encoding: "utf8",
+        mode: 0o644,
+        flag: "wx"
+    });
+    try {
+        await rename(temporary, path);
+    }
+    finally {
+        await unlink(temporary).catch(() => undefined);
+    }
+}
+function expectedPath(kind, id) {
+    return `${KNOWLEDGE_DIR}/${kind}/${id}.json`;
+}
+function assertReferencePath(kind, id, path) {
+    if (path !== expectedPath(kind, id)) {
+        throw new Error(`Knowledge reference ${id} must use ${expectedPath(kind, id)}`);
+    }
+}
+function assertBundleReferences(input) {
+    const anchorsById = new Map(input.anchors.map((anchor) => [anchor.id, anchor]));
+    for (const screen of input.screens) {
+        const references = [
+            ...screen.requiredAnchors,
+            ...screen.optionalAnchors,
+            ...screen.forbiddenAnchors,
+            ...screen.predicates
+                .filter((predicate) => predicate.kind !== "activityIs")
+                .map((predicate) => predicate.anchorId)
+        ];
+        for (const anchorId of references) {
+            if (!anchorsById.has(anchorId)) {
+                throw new Error(`Screen ${screen.id} references unknown Anchor ${anchorId}`);
+            }
+        }
+        for (const predicate of screen.predicates) {
+            if (predicate.kind === "windowPresent"
+                && anchorsById.get(predicate.anchorId)?.identity.kind !== "window") {
+                throw new Error(`Screen ${screen.id} window predicate requires a window Anchor`);
+            }
+        }
+    }
+}
+function bundleHash(indexSha256, index) {
+    return hashKnowledge({
+        indexSha256,
+        anchors: index.anchors.map(({ id, sha256: hash }) => ({ id, sha256: hash })),
+        screens: index.screens.map(({ id, sha256: hash }) => ({ id, sha256: hash }))
+    });
+}
+function sameReferences(left, right) {
+    return JSON.stringify(left) === JSON.stringify(right);
+}
+/**
+ * Knowledge is a committed, hand- or agent-authored library of semantic
+ * Anchors and Screens. `index.json` binds every document by content hash;
+ * `rehash` is the only writer and rebuilds the index from the documents.
+ */
+export class FileSystemKnowledgeRegistry {
+    load = async (projectRoot) => {
+        const canonicalProject = await realpath(projectRoot);
+        const indexPath = resolve(canonicalProject, KNOWLEDGE_INDEX_PATH);
+        if (!isContained(canonicalProject, indexPath)) {
+            throw new Error("Knowledge index escapes the project root");
+        }
+        const loadedIndex = await readBoundedJson(indexPath);
+        const index = KnowledgeBundleIndexSchema.parse(loadedIndex.value);
+        const anchors = await this.readDocuments(canonicalProject, "anchors", index.anchors, AnchorDefinitionSchema);
+        const screens = await this.readDocuments(canonicalProject, "screens", index.screens, ScreenDefinitionSchema);
+        assertBundleReferences({ anchors, screens });
+        const indexSha256 = sha256(loadedIndex.bytes);
+        return {
+            index,
+            indexSha256,
+            knowledgeHash: bundleHash(indexSha256, index),
+            anchors,
+            screens
+        };
+    };
+    rehash = async (projectRoot, packageName) => {
+        const canonicalProject = await realpath(projectRoot);
+        const indexPath = resolve(canonicalProject, KNOWLEDGE_INDEX_PATH);
+        let existing;
+        try {
+            existing = KnowledgeBundleIndexSchema.parse((await readBoundedJson(indexPath)).value);
+        }
+        catch (error) {
+            if (!isErrnoException(error) || error.code !== "ENOENT")
+                throw error;
+        }
+        if (existing !== undefined && existing.packageName !== packageName) {
+            throw new Error(`Knowledge package ${existing.packageName} does not match configured package ${packageName}`);
+        }
+        const anchors = await this.scanDocuments(canonicalProject, "anchors", AnchorDefinitionSchema);
+        const screens = await this.scanDocuments(canonicalProject, "screens", ScreenDefinitionSchema);
+        assertBundleReferences({
+            anchors: anchors.map(({ document }) => document),
+            screens: screens.map(({ document }) => document)
+        });
+        const references = {
+            anchors: anchors.map(({ reference }) => reference),
+            screens: screens.map(({ reference }) => reference)
+        };
+        const changed = existing === undefined
+            || !sameReferences(existing.anchors, references.anchors)
+            || !sameReferences(existing.screens, references.screens);
+        const index = KnowledgeBundleIndexSchema.parse({
+            version: 1,
+            packageName,
+            revision: existing === undefined
+                ? 1
+                : existing.revision + (changed ? 1 : 0),
+            ...references
+        });
+        if (changed) {
+            await atomicWrite(indexPath, index);
+        }
+        const indexSha256 = sha256(await readFile(indexPath));
+        return {
+            indexPath: relative(canonicalProject, indexPath).replaceAll("\\", "/"),
+            knowledgeHash: bundleHash(indexSha256, index),
+            revision: index.revision,
+            changed,
+            anchors: index.anchors.length,
+            screens: index.screens.length
+        };
+    };
+    async scanDocuments(canonicalProject, kind, schema) {
+        const directory = resolve(canonicalProject, KNOWLEDGE_DIR, kind);
+        let names;
+        try {
+            names = await readdir(directory);
+        }
+        catch (error) {
+            if (isErrnoException(error) && error.code === "ENOENT")
+                return [];
+            throw error;
+        }
+        const scanned = [];
+        for (const name of names.filter((entry) => entry.endsWith(".json")).sort()) {
+            const loaded = await readBoundedJson(join(directory, name));
+            const document = schema.parse(loaded.value);
+            if (`${document.id}.json` !== name) {
+                throw new Error(`Knowledge document ${KNOWLEDGE_DIR}/${kind}/${name} must be named ${document.id}.json`);
+            }
+            scanned.push({
+                document,
+                reference: {
+                    id: document.id,
+                    path: expectedPath(kind, document.id),
+                    sha256: sha256(loaded.bytes),
+                    status: document.status
+                }
+            });
+        }
+        return scanned;
+    }
+    async readDocuments(canonicalProject, kind, references, schema) {
+        const documents = [];
+        for (const reference of references) {
+            assertReferencePath(kind, reference.id, reference.path);
+            const path = resolve(canonicalProject, reference.path);
+            if (!isContained(canonicalProject, path)) {
+                throw new Error(`Knowledge reference escapes the project: ${reference.id}`);
+            }
+            const loaded = await readBoundedJson(path);
+            if (sha256(loaded.bytes) !== reference.sha256) {
+                throw new Error(`Knowledge document is stale: ${reference.path} (run taphound knowledge rehash)`);
+            }
+            const document = schema.parse(loaded.value);
+            if (document.id !== reference.id
+                || document.status !== reference.status) {
+                throw new Error(`Knowledge reference identity mismatch: ${reference.path}`);
+            }
+            documents.push(document);
+        }
+        return documents;
+    }
+}

package/dist/adapters/filesystem/project-bound-file.js

@@ -1,12 +1,10 @@
 import { randomUUID } from "node:crypto";
 import { constants, lstat, mkdir, open, realpath, rename, unlink } from "node:fs/promises";
 import { basename, isAbsolute, relative, resolve, sep } from "node:path";
+import { isErrnoException } from "../../shared/errors.js";
 function sameIdentity(left, right) {
     return left.dev === right.dev && left.ino === right.ino;
 }
-function isNodeError(error) {
-    return error instanceof Error && "code" in error;
-}
 async function captureDirectory(path) {
     const stats = await lstat(path, { bigint: true });
     if (!stats.isDirectory() || stats.isSymbolicLink()) {
@@ -31,7 +29,7 @@ async function captureOptionalFile(path) {
         return await captureFile(path);
     }
     catch (error) {
-        if (isNodeError(error) && error.code === "ENOENT") {
+        if (isErrnoException(error) && error.code === "ENOENT") {
             return null;
         }
         throw error;
@@ -129,7 +127,7 @@ async function prepareBoundOutput(input, createParents) {
         }
         catch (error) {
             if (!createParents
-                || !isNodeError(error)
+                || !isErrnoException(error)
                 || error.code !== "ENOENT") {
                 throw error;
             }

package/dist/adapters/filesystem/project-file-inspector.d.ts

@@ -1,5 +1,7 @@
 import { type ProjectFileInspection, type ProjectFileInspector } from "../../ports/project-file-inspector.js";
 export declare class NodeProjectFileInspector implements ProjectFileInspector {
+    private rootCache;
+    private readonly resolveRoot;
     readonly inspectProjectFile: (input: {
         projectRoot: string;
         relativePath: string;

package/dist/adapters/filesystem/project-file-inspector.js

@@ -1,22 +1,9 @@
 import { createHash } from "node:crypto";
 import { constants } from "node:fs";
 import { open, realpath, stat } from "node:fs/promises";
-import { isAbsolute, relative, resolve, sep } from "node:path";
-function errorCode(error) {
-    return (typeof error === "object"
-        && error !== null
-        && "code" in error
-        && typeof error.code === "string")
-        ? error.code
-        : undefined;
-}
-function isContained(root, path) {
-    const fromRoot = relative(root, path);
-    return (fromRoot === ""
-        || (fromRoot !== ".."
-            && !fromRoot.startsWith(`..${sep}`)
-            && !isAbsolute(fromRoot)));
-}
+import { relative, resolve } from "node:path";
+import { errnoCode } from "../../shared/errors.js";
+import { isContained } from "../../shared/paths.js";
 function sameIdentity(left, right) {
     return (left.dev === right.dev
         && left.ino === right.ino
@@ -48,40 +35,78 @@ function normalizedRelativePath(root, path) {
     return relative(root, path).replaceAll("\\", "/");
 }
 function evidenceFailure(error) {
-    return errorCode(error) === "ENOENT" || errorCode(error) === "ENOTDIR"
+    return errnoCode(error) === "ENOENT" || errnoCode(error) === "ENOTDIR"
         ? { status: "notFound" }
         : { status: "unreadable" };
 }
 export class NodeProjectFileInspector {
-    inspectProjectFile = async (input) => {
-        let canonicalRoot;
+    rootCache;
+    resolveRoot = async (projectRoot) => {
+        const cached = this.rootCache?.get(projectRoot);
+        if (cached !== undefined) {
+            try {
+                const stats = await stat(cached.canonical, { bigint: true });
+                if (stats.isDirectory()) {
+                    const identity = {
+                        dev: stats.dev,
+                        ino: stats.ino,
+                        size: stats.size,
+                        mtimeNs: stats.mtimeNs,
+                        ctimeNs: stats.ctimeNs
+                    };
+                    if (sameIdentity(cached.identity, identity)) {
+                        return {
+                            status: "resolved",
+                            canonical: cached.canonical,
+                            identity: cached.identity
+                        };
+                    }
+                }
+            }
+            catch {
+                // cache stale, re-resolve below
+            }
+        }
+        let canonical;
         try {
-            canonicalRoot = await realpath(input.projectRoot);
+            canonical = await realpath(projectRoot);
         }
         catch (error) {
-            return errorCode(error) === "ENOENT" || errorCode(error) === "ENOTDIR"
+            return errnoCode(error) === "ENOENT" || errnoCode(error) === "ENOTDIR"
                 ? { status: "rootNotFound" }
                 : { status: "rootUnreadable" };
         }
-        let rootBefore;
         try {
-            const rootStats = await stat(canonicalRoot, { bigint: true });
+            const rootStats = await stat(canonical, { bigint: true });
             if (!rootStats.isDirectory()) {
                 return { status: "rootNotDirectory" };
             }
-            rootBefore = {
+            const identity = {
                 dev: rootStats.dev,
                 ino: rootStats.ino,
                 size: rootStats.size,
                 mtimeNs: rootStats.mtimeNs,
                 ctimeNs: rootStats.ctimeNs
             };
+            if (this.rootCache === undefined) {
+                this.rootCache = new Map();
+            }
+            this.rootCache.set(projectRoot, { canonical, identity });
+            return { status: "resolved", canonical, identity };
         }
         catch (error) {
-            return errorCode(error) === "ENOENT"
+            return errnoCode(error) === "ENOENT"
                 ? { status: "rootNotFound" }
                 : { status: "rootUnreadable" };
         }
+    };
+    inspectProjectFile = async (input) => {
+        const root = await this.resolveRoot(input.projectRoot);
+        if (root.status !== "resolved") {
+            return root;
+        }
+        const canonicalRoot = root.canonical;
+        const rootBefore = root.identity;
         const normalizedPath = input.relativePath.replaceAll("\\", "/");
         if (normalizedPath.startsWith("/")
             || /^[A-Za-z]:/.test(normalizedPath)
@@ -113,7 +138,7 @@ export class NodeProjectFileInspector {
             handle = await open(canonicalBefore, openFlags);
         }
         catch (error) {
-            return errorCode(error) === "ELOOP"
+            return errnoCode(error) === "ELOOP"
                 ? { status: "changedIdentity", resolvedRelativePath }
                 : evidenceFailure(error);
         }
@@ -142,6 +167,7 @@ export class NodeProjectFileInspector {
             }
             const hash = createHash("sha256");
             const buffer = Buffer.allocUnsafe(64 * 1024);
+            const chunks = [];
             let totalBytes = 0;
             let tooLarge = false;
             while (totalBytes <= input.maximumBytes) {
@@ -152,7 +178,9 @@ export class NodeProjectFileInspector {
                     break;
                 }
                 totalBytes += readResult.bytesRead;
-                hash.update(buffer.subarray(0, readResult.bytesRead));
+                const chunk = Buffer.from(buffer.subarray(0, readResult.bytesRead));
+                hash.update(chunk);
+                chunks.push(chunk);
                 if (totalBytes > input.maximumBytes) {
                     tooLarge = true;
                     break;
@@ -185,7 +213,8 @@ export class NodeProjectFileInspector {
                 : {
                     status: "inspected",
                     resolvedRelativePath,
-                    sha256: hash.digest("hex")
+                    sha256: hash.digest("hex"),
+                    bytes: Buffer.concat(chunks)
                 };
         }
         catch {

package/dist/adapters/filesystem/project-identity-inspector.d.ts

@@ -0,0 +1,7 @@
+import type { ProjectIdentityInspection, ProjectIdentityInspector } from "../../ports/project-identity-inspector.js";
+export declare class AndroidProjectIdentityInspector implements ProjectIdentityInspector {
+    readonly inspectIdentity: (input: {
+        readonly projectRoot: string;
+        readonly moduleDir: string;
+    }) => Promise<ProjectIdentityInspection>;
+}

package/dist/adapters/filesystem/project-identity-inspector.js

@@ -0,0 +1,215 @@
+import { readFile, realpath, stat } from "node:fs/promises";
+import { resolve } from "node:path";
+import { errnoCode } from "../../shared/errors.js";
+const PACKAGE_PATTERN = /package\s*=\s*"([^"]+)"/;
+const MAIN_ACTION = "android.intent.action.MAIN";
+const LAUNCHER_CATEGORY = "android.intent.category.LAUNCHER";
+async function readBuildFile(moduleDir) {
+    for (const name of ["build.gradle.kts", "build.gradle"]) {
+        const candidate = resolve(moduleDir, name);
+        try {
+            const stats = await stat(candidate);
+            if (stats.isFile()) {
+                return await readFile(candidate, "utf8");
+            }
+        }
+        catch {
+            // continue
+        }
+    }
+    return undefined;
+}
+function escapeRegExp(value) {
+    return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function parseApplicationIdLiteral(buildContent) {
+    const groovyMatch = buildContent.match(/applicationId\s+['"]([A-Za-z_$][\w$]*(?:\.[A-Za-z_$][\w$]*)+)['"]/);
+    if (groovyMatch !== null) {
+        return groovyMatch[1];
+    }
+    const kotlinMatch = buildContent.match(/applicationId\s*=\s*['"]([A-Za-z_$][\w$]*(?:\.[A-Za-z_$][\w$]*)+)['"]/);
+    if (kotlinMatch !== null) {
+        return kotlinMatch[1];
+    }
+    return undefined;
+}
+function parseApplicationIdVariable(buildContent) {
+    const varMatch = buildContent.match(/applicationId\s*=\s*([A-Za-z_$][\w$]*)[ \t]*(?:\/\/.*)?$/m);
+    if (varMatch === null) {
+        return undefined;
+    }
+    const variableName = varMatch[1];
+    if (variableName === undefined) {
+        return undefined;
+    }
+    const propPattern = new RegExp(`val\\s+${escapeRegExp(variableName)}\\s*=\\s*providers\\.gradleProperty\\s*\\(\\s*["']([^"']+)["']\\s*\\)\\.get\\(\\)`);
+    const propMatch = buildContent.match(propPattern);
+    return propMatch?.[1];
+}
+async function readGradleProperty(projectRoot, propertyName) {
+    const propertiesPath = resolve(projectRoot, "gradle.properties");
+    let content;
+    try {
+        content = await readFile(propertiesPath, "utf8");
+    }
+    catch {
+        return undefined;
+    }
+    for (const line of content.split(/\r?\n/)) {
+        const trimmed = line.trim();
+        if (trimmed.startsWith("#") || trimmed.startsWith("!")) {
+            continue;
+        }
+        const eqIndex = trimmed.indexOf("=");
+        if (eqIndex === -1) {
+            continue;
+        }
+        const key = trimmed.slice(0, eqIndex).trim();
+        if (key === propertyName) {
+            return trimmed.slice(eqIndex + 1).trim();
+        }
+    }
+    return undefined;
+}
+async function resolveApplicationId(buildContent, projectRoot) {
+    if (buildContent === undefined) {
+        return { applicationId: undefined, namespace: undefined };
+    }
+    const literal = parseApplicationIdLiteral(buildContent);
+    if (literal !== undefined) {
+        const namespace = parseNamespace(buildContent);
+        return { applicationId: literal, namespace };
+    }
+    const propertyName = parseApplicationIdVariable(buildContent);
+    if (propertyName !== undefined) {
+        const value = await readGradleProperty(projectRoot, propertyName);
+        if (value !== undefined) {
+            const namespace = parseNamespace(buildContent);
+            return { applicationId: value, namespace };
+        }
+    }
+    const namespace = parseNamespace(buildContent);
+    return { applicationId: namespace, namespace };
+}
+function parseNamespace(buildContent) {
+    const namespaceMatch = buildContent.match(/namespace\s*=?\s*['"]([A-Za-z_$][\w$]*(?:\.[A-Za-z_$][\w$]*)+)['"]/);
+    return namespaceMatch?.[1];
+}
+function parseManifest(manifestContent) {
+    const packageMatch = manifestContent.match(PACKAGE_PATTERN);
+    const packageName = packageMatch?.[1];
+    const activityBlocks = [];
+    const activityPattern = /<activity\b[^>]*>/g;
+    let activityMatch;
+    while ((activityMatch = activityPattern.exec(manifestContent)) !== null) {
+        const tag = activityMatch[0];
+        const nameMatch = tag.match(/android:name\s*=\s*"([^"]+)"/);
+        if (nameMatch === null) {
+            continue;
+        }
+        const name = nameMatch[1];
+        if (name === undefined) {
+            continue;
+        }
+        const filters = [];
+        if (!tag.endsWith("/>")) {
+            const filterStart = activityMatch.index + tag.length;
+            const closingIndex = manifestContent.indexOf("</activity>", filterStart);
+            const activityBody = closingIndex === -1
+                ? manifestContent.slice(filterStart)
+                : manifestContent.slice(filterStart, closingIndex);
+            const filterPattern = /<intent-filter\b[\s\S]*?<\/intent-filter>/g;
+            let filterMatch;
+            while ((filterMatch = filterPattern.exec(activityBody)) !== null) {
+                filters.push(filterMatch[0]);
+            }
+        }
+        activityBlocks.push({ name, filters });
+    }
+    let launchActivity;
+    for (const block of activityBlocks) {
+        for (const filter of block.filters) {
+            if (filter.includes(MAIN_ACTION) && filter.includes(LAUNCHER_CATEGORY)) {
+                launchActivity = block.name;
+                break;
+            }
+        }
+        if (launchActivity !== undefined) {
+            break;
+        }
+    }
+    return { packageName, launchActivity };
+}
+function resolveActivity(packageName, activity) {
+    if (activity.startsWith(".")) {
+        return `${packageName}${activity}`;
+    }
+    if (!activity.includes(".")) {
+        return `${packageName}.${activity}`;
+    }
+    return activity;
+}
+export class AndroidProjectIdentityInspector {
+    inspectIdentity = async (input) => {
+        let root;
+        try {
+            root = await realpath(input.projectRoot);
+            const rootStats = await stat(root);
+            if (!rootStats.isDirectory()) {
+                return { status: "rootNotDirectory" };
+            }
+        }
+        catch (error) {
+            return errnoCode(error) === "ENOENT"
+                ? { status: "rootNotFound" }
+                : { status: "identityNotFound", message: "Project root is not accessible" };
+        }
+        const modulePath = resolve(root, input.moduleDir);
+        let moduleCanonical;
+        try {
+            moduleCanonical = await realpath(modulePath);
+            const moduleStats = await stat(moduleCanonical);
+            if (!moduleStats.isDirectory()) {
+                return { status: "moduleNotFound" };
+            }
+        }
+        catch (error) {
+            return errnoCode(error) === "ENOENT"
+                ? { status: "moduleNotFound" }
+                : { status: "identityNotFound", message: "Module directory is not accessible" };
+        }
+        const buildContent = await readBuildFile(moduleCanonical);
+        const { applicationId, namespace } = await resolveApplicationId(buildContent, root);
+        const manifestPath = resolve(moduleCanonical, "src", "main", "AndroidManifest.xml");
+        let manifestContent;
+        try {
+            manifestContent = await readFile(manifestPath, "utf8");
+        }
+        catch (error) {
+            if (errnoCode(error) === "ENOENT") {
+                return { status: "manifestNotFound" };
+            }
+            return { status: "manifestUnreadable" };
+        }
+        const { packageName: manifestPackage, launchActivity } = parseManifest(manifestContent);
+        const packageName = applicationId ?? manifestPackage;
+        if (packageName === undefined) {
+            return {
+                status: "identityNotFound",
+                message: "Unable to resolve applicationId or package from build file or manifest"
+            };
+        }
+        if (launchActivity === undefined) {
+            return {
+                status: "identityNotFound",
+                message: "Unable to resolve launch activity from manifest"
+            };
+        }
+        const activityBase = namespace ?? manifestPackage ?? packageName;
+        return {
+            status: "inspected",
+            packageName,
+            launchActivity: resolveActivity(activityBase, launchActivity)
+        };
+    };
+}

package/dist/adapters/filesystem/project-inventory-inspector.d.ts

@@ -0,0 +1,8 @@
+import type { ProjectInventoryCategory, ProjectInventoryInspection, ProjectInventoryInspector } from "../../ports/project-inventory-inspector.js";
+export declare class NodeProjectInventoryInspector implements ProjectInventoryInspector {
+    readonly inspectProjectInventory: (input: {
+        projectRoot: string;
+        projectDir: string;
+        categories: ProjectInventoryCategory[];
+    }) => Promise<ProjectInventoryInspection>;
+}