@automaton-labs/aib 0.0.7 → 0.0.9

package/dist/commands/inspect-tree.js

@@ -1,5 +1,827 @@
-"use strict";var H=exports&&exports.__createBinding||(Object.create?(function(n,e,t,i){i===void 0&&(i=t);var o=Object.getOwnPropertyDescriptor(e,t);(!o||("get"in o?!e.__esModule:o.writable||o.configurable))&&(o={enumerable:!0,get:function(){return e[t]}}),Object.defineProperty(n,i,o)}):(function(n,e,t,i){i===void 0&&(i=t),n[i]=e[t]})),Q=exports&&exports.__setModuleDefault||(Object.create?(function(n,e){Object.defineProperty(n,"default",{enumerable:!0,value:e})}):function(n,e){n.default=e}),I=exports&&exports.__importStar||(function(){var n=function(e){return n=Object.getOwnPropertyNames||function(t){var i=[];for(var o in t)Object.prototype.hasOwnProperty.call(t,o)&&(i[i.length]=o);return i},n(e)};return function(e){if(e&&e.__esModule)return e;var t={};if(e!=null)for(var i=n(e),o=0;o<i.length;o++)i[o]!=="default"&&H(t,e,i[o]);return Q(t,e),t}})();Object.defineProperty(exports,"__esModule",{value:!0}),exports.isInspectTreeRequest=J,exports.runInspectTree=Y,exports.buildInspectTreeResult=Z,exports.formatTreeResponse=F;const R=I(require("node:fs")),d=I(require("node:path")),X=require("../shared/agent-text"),y=require("../shared/errors"),E=require("../config/path-display"),A=require("../config/local-config"),O=require("./session-workspace"),K=2,G=80,$=["node_modules/**","**/node_modules/**",".git/**","**/.git/**","dist/**","**/dist/**","build/**","**/build/**","out/**","**/out/**",".tmp/**","**/.tmp/**"];function J(n,e){if(n[0]==="tree")return!0;if(!n.includes("--stdin")||!x(e))return!1;const t=L(e);return t.length>0&&t.some(i=>m(i.op)==="tree")}function Y(n,e,t){const i=(0,E.buildDisplayPathAliases)(n,(0,O.readEffectiveSessionPathAliases)(n)),o=(0,A.resolveLocalCliConfig)(n),r=k(n,e,t,i).map(u=>M(n,u,i,o.config.inspect.tree)),s=r.length===1?r[0]:{results:r};return(0,X.attachAgentText)(s,F(s))}function Z(n,e){const t=(0,E.buildDisplayPathAliases)(n,e.aliases??(0,O.readEffectiveSessionPathAliases)(n)),i={scope:e.scope,only:e.only??[],exclude:e.exclude??[],onlyDirs:e.onlyDirs??!1,noDefaultExclude:!1,noConfigExclude:!1};e.displayScope!==void 0&&(i.displayScope=e.displayScope),e.depth!==void 0&&(i.depth=e.depth),e.minDepth!==void 0&&(i.minDepth=e.minDepth),e.limit!==void 0&&(i.limit=e.limit);const o=b(n,i);return M(n,o,t,(0,A.resolveLocalCliConfig)(n).config.inspect.tree)}function k(n,e,t,i){if(e[0]==="tree")return[w(n,e.slice(1),i)];if(!e.includes("--stdin")||!x(t))throw new y.CliError("INSPECT_TREE_SCOPE_REQUIRED","inspect tree expects a file or directory scope.");const o=L(t);if(o.some(l=>m(l.op)!=="tree"))throw new y.CliError("INSPECT_TREE_MIXED_BATCH_UNSUPPORTED","inspect tree --stdin expects only tree requests.");return o.map((l,r)=>q(n,l,r,i))}function w(n,e,t){const o=e.filter(l=>!l.startsWith("--")&&!ue(e,l))[0];if(!o)throw new y.CliError("INSPECT_TREE_SCOPE_REQUIRED","inspect tree expects a file or directory scope.");return b(n,{scope:o,depth:W(e,"--depth"),minDepth:z(e,"--min-depth")??z(e,"--minDepth"),limit:W(e,"--limit"),only:C(e,"--only"),exclude:[...C(e,"--exclude"),...C(e,"--excludes")],onlyDirs:e.includes("--only-dirs")||e.includes("--onlyDirs"),noDefaultExclude:e.includes("--no-default-exclude")||e.includes("--noDefaultExclude")||e.includes("--ned"),noConfigExclude:e.includes("--no-config-exclude")||e.includes("--noConfigExclude")||e.includes("--nec")},t)}function q(n,e,t,i){const o=m(e.scope)??m(e.file)??m(e.dir)??m(e.directory);if(!o)throw new y.CliError("INSPECT_TREE_SCOPE_REQUIRED",`Inspect tree request at index ${t} requires scope.`);return b(n,{scope:o,depth:P(e.depth),minDepth:N(e.minDepth)??N(e.min_depth),limit:P(e.limit),only:S(e.only)??[],exclude:S(e.exclude)??S(e.excludes)??[],onlyDirs:a(e.onlyDirs)??a(e.only_dirs)??!1,noDefaultExclude:a(e.noDefaultExclude)??a(e.no_default_exclude)??a(e.ned)??!1,noConfigExclude:a(e.noConfigExclude)??a(e.no_config_exclude)??a(e.nec)??!1},i)}function b(n,e,t=[]){const i=e.depth??K,o=e.minDepth??0,l=ce(n,e.scope);if(o>i)throw new y.CliError("INSPECT_TREE_DEPTH_INVALID","inspect tree minDepth must be <= depth.");return{scope:l,displayScope:e.displayScope??(0,E.compactDisplayPath)(n,l,t),depth:i,minDepth:o,limit:e.limit??G,only:e.only,exclude:e.exclude,onlyDirs:e.onlyDirs,noDefaultExclude:e.noDefaultExclude,noConfigExclude:e.noConfigExclude}}function M(n,e,t=[],i={onlyDirs:{exclude:[]},files:{exclude:[]}}){const o=se(e.scope);if(!o)throw new y.CliError("INSPECT_TREE_SCOPE_NOT_FOUND","inspect tree scope was not found.",{scope:B(n,e.scope)});const l=o.isDirectory()?e.scope:d.dirname(e.scope),r=e.displayScope??(0,E.compactDisplayPath)(n,e.scope,t),s=e.onlyDirs?i.onlyDirs:i.files,u=ee(e,s),c=u.only.map(D),f=[...e.noDefaultExclude?[]:$,...u.exclude].map(D),p=j(n,l,e.depth,f).filter(h=>e.onlyDirs?h.kind==="dir":h.kind==="file").filter(h=>c.length===0||T(c,h.relative)).filter(h=>h.depth>=e.minDepth),g=p.slice(0,e.limit),V=ne(n,e,l,r,g,u);return{ok:!0,op:"tree",scope:r,depth:e.depth,minDepth:e.minDepth,onlyDirs:e.onlyDirs,[e.onlyDirs?"dirs":"files"]:p.length,shown:g.length,...e.only.length>0?{only:e.only}:{},...e.exclude.length>0?{exclude:e.exclude}:{},...e.noDefaultExclude?{noDefaultExclude:!0}:{},...e.noConfigExclude?{noConfigExclude:!0}:{},...p.length>g.length?{hidden:p.length-g.length}:{},lines:V}}function ee(n,e){return{only:n.only,exclude:re([...n.noConfigExclude?[]:e.exclude,...n.exclude])}}function j(n,e,t,i){const o=[],l=(r,s)=>{if(s>t)return;const u=R.readdirSync(r,{withFileTypes:!0}).sort((c,f)=>Number(f.isDirectory())-Number(c.isDirectory())||c.name.localeCompare(f.name));for(const c of u){const f=d.join(r,c.name),_=B(n,f),p=c.isDirectory()?"dir":"file";T(i,_)||(o.push({absolute:f,relative:_,depth:s,kind:p}),c.isDirectory()&&l(f,s+1))}};return l(e,1),o}function ne(n,e,t,i,o,l){const r=[`tree ${i.replace(/\\/g,"/")}`];if(e.minDepth>0&&r.push(`depth: ${e.minDepth}..${e.depth}`),e.only.length>0&&r.push(`only: ${e.only.join(", ")}`),e.exclude.length>0&&r.push(`exclude: ${e.exclude.join(", ")}`),e.noDefaultExclude&&r.push("noDefaultExclude: true"),e.noConfigExclude&&r.push("noConfigExclude: true"),e.onlyDirs&&r.push("onlyDirs: true"),r.push(""),o.length===0)return r.push("no matching paths"),r;if(te(r,i,t,o),typeof e.limit=="number"&&e.limit>0&&o.length===e.limit){const s=oe(n,e,t,l);s>o.length&&r.push(`+ ${s-o.length} more paths`)}return r}function te(n,e,t,i){const o=ie(t,i);n.push(`${e.replace(/\\/g,"/").replace(/\/?$/,"/")}`),v(n,o,"  ")}function ie(n,e){const t=new Map;for(const i of e){const o=d.relative(n,i.absolute).replace(/\\/g,"/").split("/").filter(Boolean);let l=t;for(let r=0;r<o.length;r+=1){const s=o[r];if(r===o.length-1)l.get(s)instanceof Map||l.set(s,i.kind);else{let c=l.get(s);c instanceof Map||(c=new Map,l.set(s,c)),l=c}}}return t}function v(n,e,t){for(const[i,o]of Array.from(e.entries()).sort(([l,r],[s,u])=>+(u instanceof Map)-+(r instanceof Map)||l.localeCompare(s)))o instanceof Map?(n.push(`${t}${i}/`),v(n,o,`${t}  `)):o==="dir"?n.push(`${t}${i}/`):n.push(`${t}${i}`)}function oe(n,e,t,i){const o=i.only.map(D),l=[...e.noDefaultExclude?[]:$,...i.exclude].map(D);return j(n,t,e.depth,l).filter(r=>e.onlyDirs?r.kind==="dir":r.kind==="file").filter(r=>o.length===0||T(o,r.relative)).filter(r=>r.depth>=e.minDepth).length}function F(n){if(Array.isArray(n.results)){const e=n.results.filter(x).map(t=>Array.isArray(t.lines)?t.lines.filter(i=>typeof i=="string").join(`
-`):"").filter(Boolean);return e.length>0?e.join(`
-
-`):null}return Array.isArray(n.lines)?n.lines.filter(e=>typeof e=="string").join(`
-`):null}function L(n){return Array.isArray(n.requests)?n.requests.filter(x):[n]}function D(n){const e=n.replace(/\\/g,"/").replace(/^\.?\//,"");let t="";for(let i=0;i<e.length;i+=1){const o=e[i];if(o==="*"){e[i+1]==="*"?(t+=".*",i+=1):t+="[^/]*";continue}t+=le(o)}return new RegExp(`^${t}$`)}function T(n,e){return n.some(t=>t.test(e)||t.test(`${e}/`))}function re(n){return Array.from(new Set(n))}function le(n){return n.replace(/[|\\{}()[\]^$+?.]/g,"\\$&")}function se(n){try{return R.statSync(n)}catch{return null}}function ce(n,e){return d.normalize(d.isAbsolute(e)?e:d.resolve(n,e))}function B(n,e){const t=d.relative(n,e);return(t&&!t.startsWith("..")&&!d.isAbsolute(t)?t:e).replace(/\\/g,"/")}function U(n,e){const t=n.indexOf(e);if(t<0)return null;const i=n[t+1];return i&&!i.startsWith("--")?i:null}function C(n,e){const t=[];for(let i=0;i<n.length;i+=1){if(n[i]!==e)continue;const o=n[i+1];o&&!o.startsWith("--")&&(t.push(...o.split(",").map(l=>l.trim()).filter(Boolean)),i+=1)}return t}function ue(n,e){const t=n.indexOf(e);return t>0&&n[t-1]?.startsWith("--")===!0}function W(n,e){return P(U(n,e))}function z(n,e){return N(U(n,e))}function P(n){const e=typeof n=="number"?n:typeof n=="string"?Number(n):NaN;return Number.isInteger(e)&&e>0?e:null}function N(n){const e=typeof n=="number"?n:typeof n=="string"?Number(n):NaN;return Number.isInteger(e)&&e>=0?e:null}function m(n){return typeof n=="string"&&n.length>0?n:null}function S(n){return typeof n=="string"&&n.length>0?n.split(",").map(e=>e.trim()).filter(Boolean):Array.isArray(n)?n.filter(e=>typeof e=="string"&&e.length>0):null}function a(n){if(typeof n=="boolean")return n;if(typeof n!="string")return null;const e=n.trim().toLowerCase();return e==="true"?!0:e==="false"?!1:null}function x(n){return!!n&&typeof n=="object"&&!Array.isArray(n)}
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isInspectTreeRequest = isInspectTreeRequest;
+exports.runInspectTree = runInspectTree;
+exports.buildInspectTreeResult = buildInspectTreeResult;
+exports.formatTreeResponse = formatTreeResponse;
+const fs = __importStar(require("node:fs"));
+const path = __importStar(require("node:path"));
+const agent_text_1 = require("../shared/agent-text");
+const errors_1 = require("../shared/errors");
+const path_display_1 = require("../config/path-display");
+const local_config_1 = require("../config/local-config");
+const session_workspace_1 = require("./session-workspace");
+const DEFAULT_DEPTH = 2;
+const DEFAULT_LIMIT = 80;
+const BUILTIN_EXCLUDES = [
+    "node_modules/**",
+    "**/node_modules/**",
+    ".git/**",
+    "**/.git/**",
+    "dist/**",
+    "**/dist/**",
+    "build/**",
+    "**/build/**",
+    "out/**",
+    "**/out/**",
+    ".tmp/**",
+    "**/.tmp/**"
+];
+function isInspectTreeRequest(restArgs, stdinPayload) {
+    if (restArgs[0] === "tree") {
+        return true;
+    }
+    if (!restArgs.includes("--stdin") || !isObject(stdinPayload)) {
+        return false;
+    }
+    const requests = expandTreePayloadRequests(stdinPayload);
+    return requests.length > 0 && requests.some((request) => readString(request.op) === "tree");
+}
+function runInspectTree(cwd, restArgs, stdinPayload) {
+    const aliases = (0, path_display_1.buildDisplayPathAliases)(cwd, (0, session_workspace_1.readEffectiveSessionPathAliases)(cwd));
+    const localConfig = (0, local_config_1.resolveLocalCliConfig)(cwd);
+    const requests = buildTreeRequests(cwd, restArgs, stdinPayload, aliases);
+    const results = requests.map((request) => runTreeRequest(cwd, request, aliases, localConfig.config.inspect.tree));
+    const response = buildTreeResponse(results);
+    return (0, agent_text_1.attachAgentText)(response, formatTreeResponse(response));
+}
+function buildInspectTreeResult(cwd, input) {
+    const aliases = (0, path_display_1.buildDisplayPathAliases)(cwd, input.aliases ?? (0, session_workspace_1.readEffectiveSessionPathAliases)(cwd));
+    const partial = {
+        scope: input.scope,
+        only: input.only ?? [],
+        exclude: input.exclude ?? [],
+        onlyDirs: input.onlyDirs ?? false,
+        noDefaultExclude: false,
+        noConfigExclude: false
+    };
+    if (input.displayScope !== undefined) {
+        partial.displayScope = input.displayScope;
+    }
+    if (input.depth !== undefined) {
+        partial.depth = input.depth;
+    }
+    if (input.minDepth !== undefined) {
+        partial.minDepth = input.minDepth;
+    }
+    if (input.limit !== undefined) {
+        partial.limit = input.limit;
+    }
+    const request = finalizeTreeRequest(cwd, partial);
+    return runTreeRequest(cwd, request, aliases, (0, local_config_1.resolveLocalCliConfig)(cwd).config.inspect.tree);
+}
+function buildTreeRequests(cwd, restArgs, stdinPayload, aliases) {
+    if (restArgs[0] === "tree") {
+        return treeRequestsFromArgs(cwd, restArgs.slice(1), aliases);
+    }
+    if (!restArgs.includes("--stdin") || !isObject(stdinPayload)) {
+        throw treeScopeRequiredError();
+    }
+    const rawRequests = expandTreePayloadRequests(stdinPayload);
+    if (rawRequests.some((request) => readString(request.op) !== "tree")) {
+        throw new errors_1.CliError("INSPECT_TREE_MIXED_BATCH_UNSUPPORTED", "inspect tree --stdin expects only tree requests.");
+    }
+    return rawRequests.map((request, index) => treeRequestFromObject(cwd, request, index, aliases));
+}
+function treeRequestsFromArgs(cwd, args, aliases) {
+    const inlineOptions = readInlineTreeOptions(args);
+    const positionals = args.filter((arg) => !arg.startsWith("--") && !isFlagValue(args, arg) && !isInlineTreeOptionToken(arg));
+    if (positionals.length === 0) {
+        throw treeScopeRequiredError();
+    }
+    const options = {
+        depth: readPositiveIntegerFlag(args, "--depth") ?? inlineOptions.depth,
+        minDepth: readNonNegativeIntegerFlag(args, "--min-depth") ?? readNonNegativeIntegerFlag(args, "--minDepth") ?? inlineOptions.minDepth,
+        limit: readPositiveIntegerFlag(args, "--limit") ?? inlineOptions.limit,
+        only: [
+            ...readFlagValues(args, "--only"),
+            ...inlineOptions.only
+        ],
+        exclude: [
+            ...readFlagValues(args, "--exclude"),
+            ...readFlagValues(args, "--excludes"),
+            ...inlineOptions.exclude
+        ],
+        onlyDirs: args.includes("--only-dirs") || args.includes("--onlyDirs") || inlineOptions.onlyDirs,
+        noDefaultExclude: args.includes("--no-default-exclude") ||
+            args.includes("--noDefaultExclude") ||
+            args.includes("--ned") ||
+            inlineOptions.noDefaultExclude,
+        noConfigExclude: args.includes("--no-config-exclude") ||
+            args.includes("--noConfigExclude") ||
+            args.includes("--nec") ||
+            inlineOptions.noConfigExclude
+    };
+    return positionals.map((scope) => finalizeTreeRequest(cwd, {
+        scope,
+        ...options
+    }, aliases));
+}
+function treeRequestFromObject(cwd, raw, index, aliases) {
+    const scope = readString(raw.scope) ?? readString(raw.file) ?? readString(raw.dir) ?? readString(raw.directory);
+    if (!scope) {
+        throw new errors_1.CliError("INSPECT_TREE_SCOPE_REQUIRED", `Inspect tree request at index ${index} expects a directory scope.`);
+    }
+    return finalizeTreeRequest(cwd, {
+        scope,
+        depth: readPositiveInteger(raw.depth),
+        minDepth: readNonNegativeInteger(raw.minDepth) ?? readNonNegativeInteger(raw.min_depth),
+        limit: readPositiveInteger(raw.limit),
+        only: readStringArray(raw.only) ?? [],
+        exclude: readStringArray(raw.exclude) ?? readStringArray(raw.excludes) ?? [],
+        onlyDirs: readBoolean(raw.onlyDirs) ?? readBoolean(raw.only_dirs) ?? false,
+        noDefaultExclude: readBoolean(raw.noDefaultExclude) ??
+            readBoolean(raw.no_default_exclude) ??
+            readBoolean(raw.ned) ??
+            false,
+        noConfigExclude: readBoolean(raw.noConfigExclude) ??
+            readBoolean(raw.no_config_exclude) ??
+            readBoolean(raw.nec) ??
+            false
+    }, aliases);
+}
+function finalizeTreeRequest(cwd, partial, aliases = []) {
+    const depth = partial.depth ?? DEFAULT_DEPTH;
+    const minDepth = partial.minDepth ?? 0;
+    const scope = resolveCliPath(cwd, partial.scope);
+    if (minDepth > depth) {
+        throw new errors_1.CliError("INSPECT_TREE_DEPTH_INVALID", "inspect tree minDepth must be <= depth.");
+    }
+    return {
+        scope,
+        displayScope: partial.displayScope ?? (0, path_display_1.compactDisplayPath)(cwd, scope, aliases),
+        depth,
+        minDepth,
+        limit: partial.limit ?? DEFAULT_LIMIT,
+        only: partial.only,
+        exclude: partial.exclude,
+        onlyDirs: partial.onlyDirs,
+        noDefaultExclude: partial.noDefaultExclude,
+        noConfigExclude: partial.noConfigExclude
+    };
+}
+function runTreeRequest(cwd, request, aliases = [], treeConfig = { onlyDirs: { exclude: [] }, files: { exclude: [] } }) {
+    const scopeStat = safeStat(request.scope);
+    if (!scopeStat) {
+        return treeErrorResult(request, "pathNotFound", "path was not found");
+    }
+    if (!scopeStat.isDirectory()) {
+        return treeErrorResult(request, "notDirectory", "scope is not a directory");
+    }
+    const root = request.scope;
+    const rootLabel = request.displayScope ?? (0, path_display_1.compactDisplayPath)(cwd, request.scope, aliases);
+    const modeConfig = request.onlyDirs ? treeConfig.onlyDirs : treeConfig.files;
+    const effectiveFilters = buildEffectiveTreeFilters(request, modeConfig);
+    const onlyMatchers = effectiveFilters.only.map(globToRegExp);
+    const excludeMatchers = [
+        ...(request.noDefaultExclude ? [] : BUILTIN_EXCLUDES),
+        ...effectiveFilters.exclude
+    ].map(globToRegExp);
+    const allPaths = collectTreePaths(cwd, root, request.depth, excludeMatchers);
+    const matchedPaths = allPaths
+        .filter((item) => request.onlyDirs ? item.kind === "dir" : item.kind === "file")
+        .filter((item) => onlyMatchers.length === 0 || matchesAnyPath(onlyMatchers, item.relative))
+        .filter((item) => item.depth >= request.minDepth);
+    const visiblePaths = matchedPaths.slice(0, request.limit);
+    const rendered = renderTree(cwd, request, root, rootLabel, visiblePaths, effectiveFilters);
+    return {
+        ok: true,
+        op: "tree",
+        scope: rootLabel,
+        depth: request.depth,
+        minDepth: request.minDepth,
+        onlyDirs: request.onlyDirs,
+        [request.onlyDirs ? "dirs" : "files"]: matchedPaths.length,
+        shown: visiblePaths.length,
+        ...(request.only.length > 0 ? { only: request.only } : {}),
+        ...(request.exclude.length > 0 ? { exclude: request.exclude } : {}),
+        ...(request.noDefaultExclude ? { noDefaultExclude: true } : {}),
+        ...(request.noConfigExclude ? { noConfigExclude: true } : {}),
+        ...(matchedPaths.length > visiblePaths.length ? { hidden: matchedPaths.length - visiblePaths.length } : {}),
+        lines: rendered
+    };
+}
+function buildTreeResponse(results) {
+    const failures = results.filter(isTreeErrorResult);
+    const successes = results.filter((result) => !isTreeErrorResult(result));
+    const errors = buildTreeErrors(failures);
+    if (results.length === 1 && failures.length === 0) {
+        return successes[0];
+    }
+    if (results.length === 1 && failures.length === 1) {
+        return {
+            ok: false,
+            op: "tree",
+            results,
+            treeErrors: errors
+        };
+    }
+    return {
+        ...(successes.length === 0 ? { ok: false } : {}),
+        results,
+        ...(failures.length > 0 ? { treeErrors: errors } : {})
+    };
+}
+function buildTreeErrors(failures) {
+    const pathNotFound = failures
+        .filter((failure) => failure.errorKind === "pathNotFound")
+        .map((failure) => failure.scope);
+    const notDirectory = failures
+        .filter((failure) => failure.errorKind === "notDirectory")
+        .map((failure) => failure.scope);
+    return {
+        ...(pathNotFound.length > 0 ? { pathsNotFound: pathNotFound } : {}),
+        ...(notDirectory.length > 0 ? { notDirectory } : {})
+    };
+}
+function treeErrorResult(request, errorKind, error) {
+    return {
+        ok: false,
+        op: "tree",
+        scope: request.displayScope ?? request.scope,
+        errorKind,
+        error
+    };
+}
+function isTreeErrorResult(value) {
+    return isObject(value) && value.ok === false && value.op === "tree" && typeof value.errorKind === "string";
+}
+function buildEffectiveTreeFilters(request, config) {
+    return {
+        only: request.only,
+        exclude: uniqueStrings([
+            ...(request.noConfigExclude ? [] : config.exclude),
+            ...request.exclude
+        ])
+    };
+}
+function collectTreePaths(cwd, root, maxDepth, excludeMatchers) {
+    const result = [];
+    const visit = (directory, depth) => {
+        if (depth > maxDepth) {
+            return;
+        }
+        const entries = fs.readdirSync(directory, { withFileTypes: true })
+            .sort((left, right) => Number(right.isDirectory()) - Number(left.isDirectory()) || left.name.localeCompare(right.name));
+        for (const entry of entries) {
+            const absolute = path.join(directory, entry.name);
+            const relative = toDisplayPath(cwd, absolute);
+            const kind = entry.isDirectory() ? "dir" : "file";
+            if (matchesAnyPath(excludeMatchers, relative)) {
+                continue;
+            }
+            result.push({ absolute, relative, depth, kind });
+            if (entry.isDirectory()) {
+                visit(absolute, depth + 1);
+            }
+        }
+    };
+    visit(root, 1);
+    return result;
+}
+function renderTree(cwd, request, root, rootLabel, paths, effectiveFilters) {
+    const lines = [`tree ${rootLabel.replace(/\\/g, "/")}`];
+    if (request.minDepth > 0) {
+        lines.push(`depth: ${request.minDepth}..${request.depth}`);
+    }
+    if (request.only.length > 0) {
+        lines.push(`only: ${request.only.join(", ")}`);
+    }
+    if (request.exclude.length > 0) {
+        lines.push(`exclude: ${request.exclude.join(", ")}`);
+    }
+    if (request.noDefaultExclude) {
+        lines.push("noDefaultExclude: true");
+    }
+    if (request.noConfigExclude) {
+        lines.push("noConfigExclude: true");
+    }
+    if (request.onlyDirs) {
+        lines.push("onlyDirs: true");
+    }
+    lines.push("");
+    if (paths.length === 0) {
+        lines.push("no matching paths");
+        return lines;
+    }
+    appendTreeLines(lines, rootLabel, root, paths);
+    if (typeof request.limit === "number" && request.limit > 0 && paths.length === request.limit) {
+        const allCount = runTreeCount(cwd, request, root, effectiveFilters);
+        if (allCount > paths.length) {
+            lines.push(`+ ${allCount - paths.length} more paths`);
+        }
+    }
+    return lines;
+}
+function appendTreeLines(lines, rootLabel, root, paths) {
+    const tree = buildNestedTree(root, paths);
+    lines.push(`${rootLabel.replace(/\\/g, "/").replace(/\/?$/, "/")}`);
+    appendNestedTree(lines, tree, "  ");
+}
+function buildNestedTree(root, paths) {
+    const tree = new Map();
+    for (const item of paths) {
+        const parts = path.relative(root, item.absolute).replace(/\\/g, "/").split("/").filter(Boolean);
+        let current = tree;
+        for (let index = 0; index < parts.length; index += 1) {
+            const part = parts[index];
+            const isLeaf = index === parts.length - 1;
+            if (isLeaf) {
+                const existing = current.get(part);
+                if (!(existing instanceof Map)) {
+                    current.set(part, item.kind);
+                }
+            }
+            else {
+                let next = current.get(part);
+                if (!(next instanceof Map)) {
+                    next = new Map();
+                    current.set(part, next);
+                }
+                current = next;
+            }
+        }
+    }
+    return tree;
+}
+function appendNestedTree(lines, tree, indent) {
+    for (const [name, child] of Array.from(tree.entries()).sort(([leftName, left], [rightName, right]) => Number(right instanceof Map) - Number(left instanceof Map) || leftName.localeCompare(rightName))) {
+        if (child instanceof Map) {
+            lines.push(`${indent}${name}/`);
+            appendNestedTree(lines, child, `${indent}  `);
+        }
+        else if (child === "dir") {
+            lines.push(`${indent}${name}/`);
+        }
+        else {
+            lines.push(`${indent}${name}`);
+        }
+    }
+}
+function runTreeCount(cwd, request, root, effectiveFilters) {
+    const onlyMatchers = effectiveFilters.only.map(globToRegExp);
+    const excludeMatchers = [
+        ...(request.noDefaultExclude ? [] : BUILTIN_EXCLUDES),
+        ...effectiveFilters.exclude
+    ].map(globToRegExp);
+    return collectTreePaths(cwd, root, request.depth, excludeMatchers)
+        .filter((item) => request.onlyDirs ? item.kind === "dir" : item.kind === "file")
+        .filter((item) => onlyMatchers.length === 0 || matchesAnyPath(onlyMatchers, item.relative))
+        .filter((item) => item.depth >= request.minDepth)
+        .length;
+}
+function formatTreeResponse(response) {
+    if (Array.isArray(response.results)) {
+        const chunks = response.results
+            .filter(isObject)
+            .filter((item) => !isTreeErrorResult(item))
+            .map((item) => Array.isArray(item.lines) ? item.lines.filter((line) => typeof line === "string").join("\n") : "")
+            .filter(Boolean);
+        const errors = formatTreeErrors(readTreeErrors(response.treeErrors));
+        return [...chunks, ...(errors ? [errors] : [])].filter(Boolean).join("\n\n") || null;
+    }
+    const errors = formatTreeErrors(readTreeErrors(response.treeErrors));
+    if (errors) {
+        return errors;
+    }
+    return Array.isArray(response.lines)
+        ? response.lines.filter((line) => typeof line === "string").join("\n")
+        : null;
+}
+function readTreeErrors(value) {
+    if (!isObject(value)) {
+        return { pathsNotFound: [], notDirectory: [] };
+    }
+    return {
+        pathsNotFound: readStringArray(value.pathsNotFound) ?? [],
+        notDirectory: readStringArray(value.notDirectory) ?? []
+    };
+}
+function formatTreeErrors(errors) {
+    const lines = [];
+    if (errors.pathsNotFound.length > 0) {
+        lines.push("paths not found:", ...errors.pathsNotFound);
+    }
+    if (errors.notDirectory.length > 0) {
+        if (lines.length > 0) {
+            lines.push("");
+        }
+        lines.push("not a directory:", ...errors.notDirectory);
+    }
+    return lines.length > 0 ? ["tree errors:", ...lines].join("\n") : null;
+}
+function expandTreePayloadRequests(payload) {
+    if (Array.isArray(payload.requests)) {
+        return payload.requests.filter(isObject);
+    }
+    return [payload];
+}
+function treeScopeRequiredError() {
+    return new errors_1.CliError("INSPECT_TREE_SCOPE_REQUIRED", [
+        "inspect tree expects a directory scope",
+        ...(process.platform === "win32" ? [
+            "",
+            "hint:",
+            "In PowerShell, bare aliases like @alias may be parsed as splatting",
+            "Quote bare aliases:",
+            "aib inspect tree '@alias'"
+        ] : [])
+    ].join("\n"));
+}
+function globToRegExp(pattern) {
+    const normalized = pattern.replace(/\\/g, "/").replace(/^\.?\//, "");
+    let source = "";
+    for (let index = 0; index < normalized.length; index += 1) {
+        const char = normalized[index];
+        if (char === "[") {
+            const parsed = readGlobCharacterClass(normalized, index);
+            if (parsed) {
+                source += parsed.source;
+                index = parsed.endIndex;
+                continue;
+            }
+        }
+        if (char === "{") {
+            const parsed = readGlobBraceAlternation(normalized, index);
+            if (parsed) {
+                source += parsed.source;
+                index = parsed.endIndex;
+                continue;
+            }
+        }
+        if (char === "*") {
+            if (normalized[index + 1] === "*") {
+                source += ".*";
+                index += 1;
+            }
+            else {
+                source += "[^/]*";
+            }
+            continue;
+        }
+        source += escapeRegExp(char);
+    }
+    return new RegExp(`^${source}$`);
+}
+function readGlobCharacterClass(pattern, startIndex) {
+    let index = startIndex + 1;
+    let body = "";
+    if (pattern[index] === "!" || pattern[index] === "^") {
+        body += "^";
+        index += 1;
+    }
+    for (; index < pattern.length; index += 1) {
+        const char = pattern[index];
+        if (char === "]") {
+            return body.length > 0 ? { source: `[${body}]`, endIndex: index } : null;
+        }
+        if (char === "\\" || char === "[") {
+            body += `\\${char}`;
+            continue;
+        }
+        body += char;
+    }
+    return null;
+}
+function readGlobBraceAlternation(pattern, startIndex) {
+    const endIndex = pattern.indexOf("}", startIndex + 1);
+    if (endIndex < 0) {
+        return null;
+    }
+    const body = pattern.slice(startIndex + 1, endIndex);
+    const parts = body.split(",").map((part) => part.trim()).filter(Boolean);
+    if (parts.length <= 1) {
+        return null;
+    }
+    return {
+        source: `(?:${parts.map(escapeRegExp).join("|")})`,
+        endIndex
+    };
+}
+function matchesAnyPath(matchers, relative) {
+    return matchers.some((matcher) => matcher.test(relative) || matcher.test(`${relative}/`));
+}
+function uniqueStrings(items) {
+    return Array.from(new Set(items));
+}
+function escapeRegExp(value) {
+    return value.replace(/[|\\{}()[\]^$+?.]/g, "\\$&");
+}
+function safeStat(filePath) {
+    try {
+        return fs.statSync(filePath);
+    }
+    catch {
+        return null;
+    }
+}
+function resolveCliPath(cwd, filePath) {
+    return path.normalize(path.isAbsolute(filePath) ? filePath : path.resolve(cwd, filePath));
+}
+function toDisplayPath(cwd, filePath) {
+    const relative = path.relative(cwd, filePath);
+    return (relative && !relative.startsWith("..") && !path.isAbsolute(relative) ? relative : filePath).replace(/\\/g, "/");
+}
+function readFlagValue(args, flag) {
+    const index = args.indexOf(flag);
+    if (index < 0) {
+        return null;
+    }
+    const value = args[index + 1];
+    return value && !value.startsWith("--") ? value : null;
+}
+function readFlagValues(args, flag) {
+    const values = [];
+    for (let index = 0; index < args.length; index += 1) {
+        if (args[index] !== flag) {
+            continue;
+        }
+        const value = args[index + 1];
+        if (value && !value.startsWith("--")) {
+            values.push(...parseInlineTreeStringList(value));
+            index += 1;
+        }
+    }
+    return values;
+}
+function readInlineTreeOptions(args) {
+    const options = {
+        depth: null,
+        minDepth: null,
+        limit: null,
+        only: [],
+        exclude: [],
+        onlyDirs: false,
+        noDefaultExclude: false,
+        noConfigExclude: false
+    };
+    for (const arg of args) {
+        if (arg === "+onlyDirs" || arg === "+only-dirs") {
+            options.onlyDirs = true;
+            continue;
+        }
+        if (arg === "+ned" || arg === "+noDefaultExclude" || arg === "+no-default-exclude") {
+            options.noDefaultExclude = true;
+            continue;
+        }
+        if (arg === "+nec" || arg === "+noConfigExclude" || arg === "+no-config-exclude") {
+            options.noConfigExclude = true;
+            continue;
+        }
+        const assignment = parseInlineTreeAssignment(arg);
+        if (!assignment) {
+            continue;
+        }
+        if (assignment.key === "depth") {
+            options.depth = readPositiveInteger(assignment.value);
+            continue;
+        }
+        if (assignment.key === "minDepth") {
+            options.minDepth = readNonNegativeInteger(assignment.value);
+            continue;
+        }
+        if (assignment.key === "limit") {
+            options.limit = readPositiveInteger(assignment.value);
+            continue;
+        }
+        if (assignment.key === "only") {
+            options.only.push(...parseInlineTreeStringList(assignment.value));
+            continue;
+        }
+        if (assignment.key === "exclude") {
+            options.exclude.push(...parseInlineTreeStringList(assignment.value));
+            continue;
+        }
+        if (assignment.key === "onlyDirs") {
+            options.onlyDirs = readBoolean(assignment.value) ?? false;
+            continue;
+        }
+        if (assignment.key === "noDefaultExclude") {
+            options.noDefaultExclude = readBoolean(assignment.value) ?? false;
+            continue;
+        }
+        if (assignment.key === "noConfigExclude") {
+            options.noConfigExclude = readBoolean(assignment.value) ?? false;
+        }
+    }
+    return options;
+}
+function parseInlineTreeAssignment(arg) {
+    const equalIndex = arg.indexOf("=");
+    if (equalIndex <= 0) {
+        return null;
+    }
+    const rawKey = arg.slice(0, equalIndex);
+    const key = normalizeInlineTreeKey(rawKey);
+    if (!key) {
+        return null;
+    }
+    return { key, value: stripMatchingQuotes(arg.slice(equalIndex + 1)) };
+}
+function normalizeInlineTreeKey(key) {
+    if (key === "depth") {
+        return "depth";
+    }
+    if (key === "minDepth" || key === "min_depth" || key === "min-depth") {
+        return "minDepth";
+    }
+    if (key === "limit") {
+        return "limit";
+    }
+    if (key === "only") {
+        return "only";
+    }
+    if (key === "exclude" || key === "excludes") {
+        return "exclude";
+    }
+    if (key === "onlyDirs" || key === "only_dirs" || key === "only-dirs") {
+        return "onlyDirs";
+    }
+    if (key === "ned" || key === "noDefaultExclude" || key === "no_default_exclude" || key === "no-default-exclude") {
+        return "noDefaultExclude";
+    }
+    if (key === "nec" || key === "noConfigExclude" || key === "no_config_exclude" || key === "no-config-exclude") {
+        return "noConfigExclude";
+    }
+    return null;
+}
+function isInlineTreeOptionToken(arg) {
+    return arg === "+onlyDirs" ||
+        arg === "+only-dirs" ||
+        arg === "+ned" ||
+        arg === "+noDefaultExclude" ||
+        arg === "+no-default-exclude" ||
+        arg === "+nec" ||
+        arg === "+noConfigExclude" ||
+        arg === "+no-config-exclude" ||
+        parseInlineTreeAssignment(arg) !== null;
+}
+function parseInlineTreeStringList(value) {
+    const normalized = stripMatchingQuotes(value.trim());
+    const bracketItems = parseInlineTreeBracketList(normalized);
+    if (bracketItems !== null) {
+        return bracketItems;
+    }
+    return splitInlineTreeCommaList(normalized);
+}
+function parseInlineTreeBracketList(value) {
+    const trimmed = value.trim();
+    if (!trimmed.startsWith("[") || !trimmed.endsWith("]")) {
+        return null;
+    }
+    const inner = trimmed.slice(1, -1).trim();
+    if (!inner) {
+        return [];
+    }
+    const items = [];
+    let current = "";
+    let quote = null;
+    for (let index = 0; index < inner.length; index += 1) {
+        const char = inner[index];
+        if ((char === "\"" || char === "'") && inner[index - 1] !== "\\") {
+            quote = quote === char ? null : quote ?? char;
+            current += char;
+            continue;
+        }
+        if (char === "," && quote === null) {
+            const item = stripMatchingQuotes(current.trim());
+            if (item) {
+                items.push(item);
+            }
+            current = "";
+            continue;
+        }
+        current += char;
+    }
+    const tail = stripMatchingQuotes(current.trim());
+    if (tail) {
+        items.push(tail);
+    }
+    return items;
+}
+function splitInlineTreeCommaList(value) {
+    const items = [];
+    let current = "";
+    let braceDepth = 0;
+    let quote = null;
+    for (let index = 0; index < value.length; index += 1) {
+        const char = value[index];
+        if ((char === "\"" || char === "'") && value[index - 1] !== "\\") {
+            quote = quote === char ? null : quote ?? char;
+            current += char;
+            continue;
+        }
+        if (quote === null && char === "{") {
+            braceDepth += 1;
+            current += char;
+            continue;
+        }
+        if (quote === null && char === "}" && braceDepth > 0) {
+            braceDepth -= 1;
+            current += char;
+            continue;
+        }
+        if (quote === null && braceDepth === 0 && char === ",") {
+            const item = stripMatchingQuotes(current.trim());
+            if (item) {
+                items.push(item);
+            }
+            current = "";
+            continue;
+        }
+        current += char;
+    }
+    const tail = stripMatchingQuotes(current.trim());
+    if (tail) {
+        items.push(tail);
+    }
+    return items;
+}
+function stripMatchingQuotes(value) {
+    if (value.length >= 2 && ((value.startsWith("\"") && value.endsWith("\"")) || (value.startsWith("'") && value.endsWith("'")))) {
+        return value.slice(1, -1);
+    }
+    return value;
+}
+function isFlagValue(args, value) {
+    const index = args.indexOf(value);
+    return index > 0 && args[index - 1]?.startsWith("--") === true;
+}
+function readPositiveIntegerFlag(args, flag) {
+    return readPositiveInteger(readFlagValue(args, flag));
+}
+function readNonNegativeIntegerFlag(args, flag) {
+    return readNonNegativeInteger(readFlagValue(args, flag));
+}
+function readPositiveInteger(value) {
+    const parsed = typeof value === "number" ? value : typeof value === "string" ? Number(value) : NaN;
+    return Number.isInteger(parsed) && parsed > 0 ? parsed : null;
+}
+function readNonNegativeInteger(value) {
+    const parsed = typeof value === "number" ? value : typeof value === "string" ? Number(value) : NaN;
+    return Number.isInteger(parsed) && parsed >= 0 ? parsed : null;
+}
+function readString(value) {
+    return typeof value === "string" && value.length > 0 ? value : null;
+}
+function readStringArray(value) {
+    if (typeof value === "string" && value.length > 0) {
+        return value.split(",").map((item) => item.trim()).filter(Boolean);
+    }
+    if (!Array.isArray(value)) {
+        return null;
+    }
+    return value.filter((item) => typeof item === "string" && item.length > 0);
+}
+function readBoolean(value) {
+    if (typeof value === "boolean") {
+        return value;
+    }
+    if (typeof value !== "string") {
+        return null;
+    }
+    const normalized = value.trim().toLowerCase();
+    if (normalized === "true") {
+        return true;
+    }
+    if (normalized === "false") {
+        return false;
+    }
+    return null;
+}
+function isObject(value) {
+    return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+}