@lousy-agents/cli 5.9.5 → 5.10.0

package/dist/index.js

@@ -10229,11 +10229,14 @@ var promises_ = __webpack_require__(1455);
 
 // EXTERNAL MODULE: external "node:path"
 var external_node_path_ = __webpack_require__(6760);
+// EXTERNAL MODULE: external "node:fs"
+var external_node_fs_ = __webpack_require__(3024);
 ;// CONCATENATED MODULE: ../core/src/gateways/file-system-utils.ts
 /**
  * Shared file system utilities for gateways.
  */ 
 
+
 /**
  * Checks if a file or directory exists.
  */ async function file_system_utils_fileExists(path) {
@@ -10303,6 +10306,44 @@ function isPathWithinRoot(rootPath, candidatePath) {
         throw new Error(`${context} exceeds size limit (${fileStats.size} bytes > ${maxBytes} bytes)`);
     }
 }
+/**
+ * Reads a file atomically with symlink and size protection.
+ *
+ * Uses `O_NOFOLLOW` (where available) to atomically reject symlinks at
+ * the kernel level, eliminating the TOCTOU window between `lstat()` and
+ * `readFile()`. Falls back to `lstat()` on platforms without `O_NOFOLLOW`.
+ * Validates file size via `fstat()` on the opened file descriptor so the
+ * size check and the read operate on the same inode.
+ */ async function readFileNoFollow(filePath, maxBytes) {
+    const hasNoFollow = typeof external_node_fs_.constants.O_NOFOLLOW === "number" && external_node_fs_.constants.O_NOFOLLOW !== 0;
+    const safePath = JSON.stringify(filePath);
+    let fh;
+    if (hasNoFollow) {
+        try {
+            fh = await (0,promises_.open)(filePath, external_node_fs_.constants.O_RDONLY | external_node_fs_.constants.O_NOFOLLOW);
+        } catch (error) {
+            if (error instanceof Error && "code" in error && error.code === "ELOOP") {
+                throw new Error(`Symlinks are not allowed: ${safePath}`);
+            }
+            throw error;
+        }
+    } else {
+        const stats = await (0,promises_.lstat)(filePath);
+        if (stats.isSymbolicLink()) {
+            throw new Error(`Symlinks are not allowed: ${safePath}`);
+        }
+        fh = await (0,promises_.open)(filePath, external_node_fs_.constants.O_RDONLY);
+    }
+    try {
+        const fdStats = await fh.stat();
+        if (fdStats.size > maxBytes) {
+            throw new Error(`File ${safePath} exceeds size limit (${fdStats.size} bytes > ${maxBytes} bytes)`);
+        }
+        return await fh.readFile("utf-8");
+    } finally{
+        await fh.close();
+    }
+}
 
 ;// CONCATENATED MODULE: ../core/src/gateways/agent-file-gateway.ts
 /**
@@ -10414,8 +10455,6 @@ function isPathWithinRoot(rootPath, candidatePath) {
     "pip"
 ];
 
-// EXTERNAL MODULE: external "node:fs"
-var external_node_fs_ = __webpack_require__(3024);
 ;// CONCATENATED MODULE: ../../node_modules/pathe/dist/shared/pathe.M-eThtNZ.mjs
 let _lazyMatch = () => { var __lib__=(()=>{var m=Object.defineProperty,V=Object.getOwnPropertyDescriptor,G=Object.getOwnPropertyNames,T=Object.prototype.hasOwnProperty,q=(r,e)=>{for(var n in e)m(r,n,{get:e[n],enumerable:true});},H=(r,e,n,a)=>{if(e&&typeof e=="object"||typeof e=="function")for(let t of G(e))!T.call(r,t)&&t!==n&&m(r,t,{get:()=>e[t],enumerable:!(a=V(e,t))||a.enumerable});return r},J=r=>H(m({},"__esModule",{value:true}),r),w={};q(w,{default:()=>re});var A=r=>Array.isArray(r),d=r=>typeof r=="function",Q=r=>r.length===0,W=r=>typeof r=="number",K=r=>typeof r=="object"&&r!==null,X=r=>r instanceof RegExp,b=r=>typeof r=="string",h=r=>r===void 0,Y=r=>{const e=new Map;return n=>{const a=e.get(n);if(a)return a;const t=r(n);return e.set(n,t),t}},rr=(r,e,n={})=>{const a={cache:{},input:r,index:0,indexMax:0,options:n,output:[]};if(v(e)(a)&&a.index===r.length)return a.output;throw new Error(`Failed to parse at index ${a.indexMax}`)},i=(r,e)=>A(r)?er(r,e):b(r)?ar(r,e):nr(r,e),er=(r,e)=>{const n={};for(const a of r){if(a.length!==1)throw new Error(`Invalid character: "${a}"`);const t=a.charCodeAt(0);n[t]=true;}return a=>{const t=a.index,o=a.input;for(;a.index<o.length&&o.charCodeAt(a.index)in n;)a.index+=1;const u=a.index;if(u>t){if(!h(e)&&!a.options.silent){const s=a.input.slice(t,u),c=d(e)?e(s,o,String(t)):e;h(c)||a.output.push(c);}a.indexMax=Math.max(a.indexMax,a.index);}return  true}},nr=(r,e)=>{const n=r.source,a=r.flags.replace(/y|$/,"y"),t=new RegExp(n,a);return g(o=>{t.lastIndex=o.index;const u=t.exec(o.input);if(u){if(!h(e)&&!o.options.silent){const s=d(e)?e(...u,o.input,String(o.index)):e;h(s)||o.output.push(s);}return o.index+=u[0].length,o.indexMax=Math.max(o.indexMax,o.index),true}else return  false})},ar=(r,e)=>n=>{if(n.input.startsWith(r,n.index)){if(!h(e)&&!n.options.silent){const t=d(e)?e(r,n.input,String(n.index)):e;h(t)||n.output.push(t);}return n.index+=r.length,n.indexMax=Math.max(n.indexMax,n.index),true}else return  false},C=(r,e,n,a)=>{const t=v(r);return g(_(M(o=>{let u=0;for(;u<n;){const s=o.index;if(!t(o)||(u+=1,o.index===s))break}return u>=e})))},tr=(r,e)=>C(r,0,1),f=(r,e)=>C(r,0,1/0),x=(r,e)=>{const n=r.map(v);return g(_(M(a=>{for(let t=0,o=n.length;t<o;t++)if(!n[t](a))return  false;return  true})))},l=(r,e)=>{const n=r.map(v);return g(_(a=>{for(let t=0,o=n.length;t<o;t++)if(n[t](a))return  true;return  false}))},M=(r,e=false)=>{const n=v(r);return a=>{const t=a.index,o=a.output.length,u=n(a);return (!u||e)&&(a.index=t,a.output.length!==o&&(a.output.length=o)),u}},_=(r,e)=>{const n=v(r);return n},g=(()=>{let r=0;return e=>{const n=v(e),a=r+=1;return t=>{var o;if(t.options.memoization===false)return n(t);const u=t.index,s=(o=t.cache)[a]||(o[a]=new Map),c=s.get(u);if(c===false)return  false;if(W(c))return t.index=c,true;if(c)return t.index=c.index,c.output?.length&&t.output.push(...c.output),true;{const Z=t.output.length;if(n(t)){const D=t.index,U=t.output.length;if(U>Z){const ee=t.output.slice(Z,U);s.set(u,{index:D,output:ee});}else s.set(u,D);return  true}else return s.set(u,false),false}}}})(),E=r=>{let e;return n=>(e||(e=v(r())),e(n))},v=Y(r=>{if(d(r))return Q(r)?E(r):r;if(b(r)||X(r))return i(r);if(A(r))return x(r);if(K(r))return l(Object.values(r));throw new Error("Invalid rule")}),P="abcdefghijklmnopqrstuvwxyz",ir=r=>{let e="";for(;r>0;){const n=(r-1)%26;e=P[n]+e,r=Math.floor((r-1)/26);}return e},O=r=>{let e=0;for(let n=0,a=r.length;n<a;n++)e=e*26+P.indexOf(r[n])+1;return e},S=(r,e)=>{if(e<r)return S(e,r);const n=[];for(;r<=e;)n.push(r++);return n},or=(r,e,n)=>S(r,e).map(a=>String(a).padStart(n,"0")),R=(r,e)=>S(O(r),O(e)).map(ir),p=r=>r,z=r=>ur(e=>rr(e,r,{memoization:false}).join("")),ur=r=>{const e={};return n=>e[n]??(e[n]=r(n))},sr=i(/^\*\*\/\*$/,".*"),cr=i(/^\*\*\/(\*)?([ a-zA-Z0-9._-]+)$/,(r,e,n)=>`.*${e?"":"(?:^|/)"}${n.replaceAll(".","\\.")}`),lr=i(/^\*\*\/(\*)?([ a-zA-Z0-9._-]*)\{([ a-zA-Z0-9._-]+(?:,[ a-zA-Z0-9._-]+)*)\}$/,(r,e,n,a)=>`.*${e?"":"(?:^|/)"}${n.replaceAll(".","\\.")}(?:${a.replaceAll(",","|").replaceAll(".","\\.")})`),y=i(/\\./,p),pr=i(/[$.*+?^(){}[\]\|]/,r=>`\\${r}`),vr=i(/./,p),hr=i(/^(?:!!)*!(.*)$/,(r,e)=>`(?!^${L(e)}$).*?`),dr=i(/^(!!)+/,""),fr=l([hr,dr]),xr=i(/\/(\*\*\/)+/,"(?:/.+/|/)"),gr=i(/^(\*\*\/)+/,"(?:^|.*/)"),mr=i(/\/(\*\*)$/,"(?:/.*|$)"),_r=i(/\*\*/,".*"),j=l([xr,gr,mr,_r]),Sr=i(/\*\/(?!\*\*\/)/,"[^/]*/"),yr=i(/\*/,"[^/]*"),N=l([Sr,yr]),k=i("?","[^/]"),$r=i("[",p),wr=i("]",p),Ar=i(/[!^]/,"^/"),br=i(/[a-z]-[a-z]|[0-9]-[0-9]/i,p),Cr=i(/[$.*+?^(){}[\|]/,r=>`\\${r}`),Mr=i(/[^\]]/,p),Er=l([y,Cr,br,Mr]),B=x([$r,tr(Ar),f(Er),wr]),Pr=i("{","(?:"),Or=i("}",")"),Rr=i(/(\d+)\.\.(\d+)/,(r,e,n)=>or(+e,+n,Math.min(e.length,n.length)).join("|")),zr=i(/([a-z]+)\.\.([a-z]+)/,(r,e,n)=>R(e,n).join("|")),jr=i(/([A-Z]+)\.\.([A-Z]+)/,(r,e,n)=>R(e.toLowerCase(),n.toLowerCase()).join("|").toUpperCase()),Nr=l([Rr,zr,jr]),I=x([Pr,Nr,Or]),kr=i("{","(?:"),Br=i("}",")"),Ir=i(",","|"),Fr=i(/[$.*+?^(){[\]\|]/,r=>`\\${r}`),Lr=i(/[^}]/,p),Zr=E(()=>F),Dr=l([j,N,k,B,I,Zr,y,Fr,Ir,Lr]),F=x([kr,f(Dr),Br]),Ur=f(l([sr,cr,lr,fr,j,N,k,B,I,F,y,pr,vr])),Vr=Ur,Gr=z(Vr),L=Gr,Tr=i(/\\./,p),qr=i(/./,p),Hr=i(/\*\*\*+/,"*"),Jr=i(/([^/{[(!])\*\*/,(r,e)=>`${e}*`),Qr=i(/(^|.)\*\*(?=[^*/)\]}])/,(r,e)=>`${e}*`),Wr=f(l([Tr,Hr,Jr,Qr,qr])),Kr=Wr,Xr=z(Kr),Yr=Xr,$=(r,e)=>{const n=Array.isArray(r)?r:[r];if(!n.length)return  false;const a=n.map($.compile),t=n.every(s=>/(\/(?:\*\*)?|\[\/\])$/.test(s)),o=e.replace(/[\\\/]+/g,"/").replace(/\/$/,t?"/":"");return a.some(s=>s.test(o))};$.compile=r=>new RegExp(`^${L(Yr(r))}$`,"s");var re=$;return J(w)})();
  return __lib__.default || __lib__; };
@@ -33436,6 +33475,7 @@ var dist = __webpack_require__(3519);
 
 
 
+/** Maximum skill file size: 1 MB */ const MAX_SKILL_FILE_BYTES = 1_048_576;
 /**
  * Skill directory locations to search for SKILL.md files.
  */ const SKILL_DIRECTORIES = [
@@ -33455,12 +33495,29 @@ var dist = __webpack_require__(3519);
         return skills;
     }
     async discoverSkillsInDir(skillsDir) {
-        if (!await file_system_utils_fileExists(skillsDir)) {
+        let dirStats;
+        try {
+            dirStats = await (0,promises_.lstat)(skillsDir);
+        } catch (error) {
+            if (error instanceof Error && "code" in error && (error.code === "ENOENT" || error.code === "ENOTDIR")) {
+                return [];
+            }
+            throw error;
+        }
+        if (dirStats.isSymbolicLink() || !dirStats.isDirectory()) {
             return [];
         }
-        const entries = await (0,promises_.readdir)(skillsDir, {
-            withFileTypes: true
-        });
+        let entries;
+        try {
+            entries = await (0,promises_.readdir)(skillsDir, {
+                withFileTypes: true
+            });
+        } catch (error) {
+            if (error instanceof Error && "code" in error && (error.code === "ENOENT" || error.code === "ENOTDIR")) {
+                return [];
+            }
+            throw error;
+        }
         const skills = [];
         for (const entry of entries){
             if (!entry.isDirectory()) {
@@ -33470,7 +33527,17 @@ var dist = __webpack_require__(3519);
                 continue;
             }
             const skillFilePath = (0,external_node_path_.join)(skillsDir, entry.name, "SKILL.md");
-            if (await file_system_utils_fileExists(skillFilePath)) {
+            let skillStat;
+            try {
+                skillStat = await (0,promises_.lstat)(skillFilePath);
+            } catch (error) {
+                if (error instanceof Error && "code" in error && (error.code === "ENOENT" || error.code === "ENOTDIR")) {
+                    skillStat = null;
+                } else {
+                    throw error;
+                }
+            }
+            if (skillStat && !skillStat.isSymbolicLink() && skillStat.isFile()) {
                 skills.push({
                     filePath: skillFilePath,
                     skillName: entry.name
@@ -33480,7 +33547,7 @@ var dist = __webpack_require__(3519);
         return skills;
     }
     async readSkillFileContent(filePath) {
-        return (0,promises_.readFile)(filePath, "utf-8");
+        return readFileNoFollow(filePath, MAX_SKILL_FILE_BYTES);
     }
     parseFrontmatter(content) {
         const lines = content.split("\n");
@@ -36577,12 +36644,22 @@ const initCommand = defineCommand({
 
 
 
+/** Maximum agent file size: 1 MB */ const MAX_AGENT_FILE_BYTES = 1_048_576;
 /**
  * File system implementation of the agent lint gateway.
  */ class FileSystemAgentLintGateway {
     async discoverAgents(targetDir) {
         const agentsDir = (0,external_node_path_.join)(targetDir, ".github", "agents");
-        if (!await file_system_utils_fileExists(agentsDir)) {
+        let agentsDirStats;
+        try {
+            agentsDirStats = await (0,promises_.lstat)(agentsDir);
+        } catch (error) {
+            if (error instanceof Error && "code" in error && (error.code === "ENOENT" || error.code === "ENOTDIR")) {
+                return [];
+            }
+            throw error;
+        }
+        if (agentsDirStats.isSymbolicLink() || !agentsDirStats.isDirectory()) {
             return [];
         }
         const resolvedAgentsDir = (0,external_node_path_.resolve)(agentsDir);
@@ -36626,11 +36703,7 @@ const initCommand = defineCommand({
         return agents;
     }
     async readAgentFileContent(filePath) {
-        const stats = await (0,promises_.lstat)(filePath);
-        if (stats.isSymbolicLink()) {
-            throw new Error(`Symlinks are not allowed: ${filePath}`);
-        }
-        return (0,promises_.readFile)(filePath, "utf-8");
+        return readFileNoFollow(filePath, MAX_AGENT_FILE_BYTES);
     }
     parseFrontmatter(content) {
         const lines = content.split("\n");
@@ -36681,7 +36754,6 @@ const initCommand = defineCommand({
  * Discovers hook config files for GitHub Copilot and Claude Code.
  */ 
 
-
 /** Maximum hook config file size: 1 MB */ const MAX_CONFIG_FILE_BYTES = 1_048_576;
 /** Matches the Copilot hook key `"preToolUse":` to detect hook section presence */ const COPILOT_HOOK_PATTERN = /"preToolUse"\s*:/;
 /** Matches the Claude hook key `"PreToolUse":` to detect hook section presence */ const CLAUDE_HOOK_PATTERN = /"PreToolUse"\s*:/;
@@ -36710,22 +36782,30 @@ const initCommand = defineCommand({
             let safePath;
             try {
                 safePath = await file_system_utils_resolveSafePath(targetDir, config.relativePath);
-            } catch  {
-                continue;
-            }
-            if (!await file_system_utils_fileExists(safePath)) {
-                continue;
-            }
-            const stats = await (0,promises_.lstat)(safePath);
-            if (stats.isSymbolicLink()) {
-                continue;
+            } catch (error) {
+                if (error instanceof Error && "code" in error && (error.code === "ENOENT" || error.code === "ENOTDIR")) {
+                    continue;
+                }
+                if (error instanceof Error && (error.message.startsWith("Resolved path is outside target directory:") || error.message.startsWith("Path contains symbolic link:"))) {
+                    continue;
+                }
+                throw error;
             }
+            let content;
             try {
-                await assertFileSizeWithinLimit(safePath, MAX_CONFIG_FILE_BYTES, `Hook config ${config.relativePath}`);
-            } catch  {
-                continue;
+                content = await readFileNoFollow(safePath, MAX_CONFIG_FILE_BYTES);
+            } catch (error) {
+                if (error instanceof Error && "code" in error && (error.code === "ENOENT" || error.code === "ENOTDIR")) {
+                    continue;
+                }
+                if (error instanceof Error && error.message.startsWith("Symlinks are not allowed")) {
+                    continue;
+                }
+                if (error instanceof Error && error.message.includes("exceeds size limit")) {
+                    continue;
+                }
+                throw error;
             }
-            const content = await (0,promises_.readFile)(safePath, "utf-8");
             if (this.mayContainHookSection(content, config.platform)) {
                 discovered.push({
                     filePath: safePath,
@@ -36736,12 +36816,7 @@ const initCommand = defineCommand({
         return discovered;
     }
     async readFileContent(filePath) {
-        const stats = await (0,promises_.lstat)(filePath);
-        if (stats.isSymbolicLink()) {
-            throw new Error(`Symlinks are not allowed: ${filePath}`);
-        }
-        await assertFileSizeWithinLimit(filePath, MAX_CONFIG_FILE_BYTES, `Hook config ${filePath}`);
-        return (0,promises_.readFile)(filePath, "utf-8");
+        return readFileNoFollow(filePath, MAX_CONFIG_FILE_BYTES);
     }
     /**
      * Lightweight heuristic to check if a file may contain a pre-tool-use hooks section.
@@ -55689,11 +55764,12 @@ const remark = unified().use(remarkParse).use(remarkStringify).freeze()
  */ 
 
 
+/** Maximum instruction file size: 1 MB */ const MAX_INSTRUCTION_FILE_BYTES = 1_048_576;
 /**
  * Remark-based implementation of the Markdown AST gateway.
  */ class RemarkMarkdownAstGateway {
     async parseFile(filePath) {
-        const content = await (0,promises_.readFile)(filePath, "utf-8");
+        const content = await readFileNoFollow(filePath, MAX_INSTRUCTION_FILE_BYTES);
         return this.parseContent(content);
     }
     parseContent(content) {
@@ -56839,13 +56915,109 @@ function hasFrontmatterDelimiters(content) {
     return false;
 }
 
-;// CONCATENATED MODULE: ./src/commands/lint.ts
+;// CONCATENATED MODULE: ../lint/src/validate-directory.ts
 /**
- * CLI command for linting agent skills, custom agents, and instruction files.
- * Discovers targets, validates frontmatter/quality, and reports diagnostics.
+ * Directory path validation for the public lint API.
+ *
+ * Validates user-supplied directory paths by rejecting unsafe inputs
+ * (control characters, path traversal, null bytes) and canonicalizing
+ * the path via `realpath()` for cross-platform compatibility.
  */ 
 
+/**
+ * Thrown when user-supplied directory input fails validation.
+ *
+ * Consumers can catch this type to distinguish user-input errors
+ * (bad path, missing directory) from system-level errors (EACCES, EMFILE).
+ */ class LintValidationError extends Error {
+    constructor(message){
+        super(message);
+        this.name = "LintValidationError";
+    }
+}
+function isControlCharacter(code) {
+    if (code >= 0x00 && code <= 0x1f) return true;
+    if (code === 0x7f) return true;
+    if (code >= 0x80 && code <= 0x9f) return true;
+    if (code === 0x2028 || code === 0x2029) return true;
+    if (code >= 0x202a && code <= 0x202e) return true;
+    if (code >= 0x2066 && code <= 0x2069) return true;
+    return false;
+}
+function containsControlCharacters(value) {
+    for(let i = 0; i < value.length; i++){
+        if (isControlCharacter(value.charCodeAt(i))) {
+            return true;
+        }
+    }
+    return false;
+}
+function sanitizeForErrorMessage(value) {
+    return JSON.stringify(value);
+}
+function hasPathTraversalSegment(directory) {
+    return directory.split(/[\\/]/).includes("..");
+}
+/**
+ * Validates a user-supplied directory path for safety and existence.
+ *
+ * Rejects paths that contain control characters (ASCII C0/C1, Unicode
+ * bidirectional overrides, line/paragraph separators), path traversal
+ * segments, or that do not resolve to an existing directory. Returns
+ * the canonicalized absolute path (all symlinks resolved) so downstream
+ * code always operates on real paths.
+ *
+ * @throws {LintValidationError} If the path is empty, contains control
+ *   characters, traversal segments, does not exist, or is not a directory.
+ */ async function validateDirectory(directory) {
+    if (directory.length === 0) {
+        throw new LintValidationError("directory must not be empty");
+    }
+    const safeDir = sanitizeForErrorMessage(directory);
+    if (containsControlCharacters(directory)) {
+        throw new LintValidationError(`Invalid directory path (contains control characters): ${safeDir}`);
+    }
+    if (hasPathTraversalSegment(directory)) {
+        throw new LintValidationError(`Invalid directory path (path traversal detected): ${safeDir}`);
+    }
+    const resolved = (0,external_node_path_.resolve)(directory);
+    let canonical;
+    try {
+        canonical = await (0,promises_.realpath)(resolved);
+    } catch (error) {
+        if (error instanceof Error && "code" in error) {
+            if (error.code === "ENOENT") {
+                throw new LintValidationError(`Directory does not exist: ${safeDir}`);
+            }
+            if (error.code === "ENOTDIR") {
+                throw new LintValidationError(`Path is not a directory: ${safeDir}`);
+            }
+        }
+        throw error;
+    }
+    let stats;
+    try {
+        stats = await (0,promises_.lstat)(canonical);
+    } catch (error) {
+        if (error instanceof Error && "code" in error && error.code === "ENOENT") {
+            throw new LintValidationError(`Directory does not exist: ${safeDir}`);
+        }
+        throw error;
+    }
+    if (!stats.isDirectory()) {
+        throw new LintValidationError(`Path is not a directory: ${safeDir}`);
+    }
+    return canonical;
+}
 
+;// CONCATENATED MODULE: ../lint/src/lint.ts
+/**
+ * Lint composition root.
+ *
+ * Wires internal gateways, use cases, and severity filtering into a
+ * single `runLint` entry point. This is a Layer 4 (Infrastructure)
+ * module — the only place that instantiates concrete implementations.
+ */ 
 
 
 
@@ -56859,51 +57031,17 @@ function hasFrontmatterDelimiters(content) {
 
 
 
-
-/** Schema for validating target directory */ const TargetDirSchema = schemas_string().min(1, "Target directory is required");
-/**
- * Validates the target directory.
- * Checks for path traversal attempts before resolution.
- */ function validateTargetDir(targetDir) {
-    const parsed = TargetDirSchema.parse(targetDir);
-    // Check for path traversal attempts in raw input before resolution
-    if (parsed.includes("..")) {
-        throw new Error(`Invalid target directory (path traversal detected): ${targetDir}`);
-    }
-    return (0,external_node_path_.resolve)(parsed);
-}
-/**
- * Converts skill lint output to unified LintOutput.
- */ function skillOutputToLintOutput(output) {
-    const diagnostics = [];
-    for (const result of output.results){
-        for (const d of result.diagnostics){
-            diagnostics.push({
-                filePath: result.filePath,
-                line: d.line,
-                severity: d.severity,
-                message: d.message,
-                field: d.field,
-                ruleId: d.ruleId,
-                target: "skill"
-            });
-        }
-    }
-    return {
-        diagnostics,
-        target: "skill",
-        filesAnalyzed: output.results.map((r)=>r.filePath),
-        summary: {
-            totalFiles: output.totalSkills,
-            totalErrors: output.totalErrors,
-            totalWarnings: output.totalWarnings,
-            totalInfos: 0
-        }
-    };
-}
-/**
- * Converts agent lint output to unified LintOutput.
- */ function agentOutputToLintOutput(output) {
+const LintTargetsSchema = schemas_object({
+    skills: schemas_boolean().optional(),
+    agents: schemas_boolean().optional(),
+    hooks: schemas_boolean().optional(),
+    instructions: schemas_boolean().optional()
+}).strict().optional();
+const LintOptionsSchema = schemas_object({
+    directory: schemas_string().min(1, "directory must not be empty"),
+    targets: LintTargetsSchema
+}).strict();
+/** Converts a use-case lint output to the unified LintOutput shape. */ function toLintOutput(output, target, totalFiles) {
     const diagnostics = [];
     for (const result of output.results){
         for (const d of result.diagnostics){
@@ -56914,114 +57052,47 @@ function hasFrontmatterDelimiters(content) {
                 message: d.message,
                 field: d.field,
                 ruleId: d.ruleId,
-                target: "agent"
+                target
             });
         }
     }
     return {
         diagnostics,
-        target: "agent",
+        target,
         filesAnalyzed: output.results.map((r)=>r.filePath),
         summary: {
-            totalFiles: output.totalAgents,
+            totalFiles,
             totalErrors: output.totalErrors,
             totalWarnings: output.totalWarnings,
-            totalInfos: 0
+            totalInfos: diagnostics.filter((d)=>d.severity === "info").length
         }
     };
 }
-/**
- * Formats and displays a LintOutput using consola.
- */ function displayLintOutput(output, label) {
-    if (output.summary.totalFiles === 0) {
-        consola.info(`No ${label} found`);
-        return;
-    }
-    consola.info(`Discovered ${output.summary.totalFiles} ${label}`);
-    // Group diagnostics by file
-    const filesWithDiagnostics = new Set();
-    for (const d of output.diagnostics){
-        filesWithDiagnostics.add(d.filePath);
-    }
-    for (const file of output.filesAnalyzed){
-        if (!filesWithDiagnostics.has(file)) {
-            consola.success(`${file}: OK`);
-        }
-    }
-    for (const d of output.diagnostics){
-        const prefix = `${d.filePath}:${d.line}`;
-        const fieldInfo = d.field ? ` [${d.field}]` : "";
-        if (d.severity === "error") {
-            consola.error(`${prefix}${fieldInfo}: ${d.message}`);
-        } else if (d.severity === "warning") {
-            consola.warn(`${prefix}${fieldInfo}: ${d.message}`);
-        } else {
-            consola.info(`${prefix}${fieldInfo}: ${d.message}`);
-        }
-    }
-}
-/**
- * Runs skill linting.
- */ async function lintSkills(targetDir) {
+async function lintSkills(targetDir) {
     const gateway = createSkillLintGateway();
     const useCase = new LintSkillFrontmatterUseCase(gateway);
     const output = await useCase.execute({
         targetDir
     });
-    return skillOutputToLintOutput(output);
+    return toLintOutput(output, "skill", output.totalSkills);
 }
-/**
- * Runs agent linting.
- */ async function lintAgents(targetDir) {
+async function lintAgents(targetDir) {
     const gateway = createAgentLintGateway();
     const useCase = new LintAgentFrontmatterUseCase(gateway);
     const output = await useCase.execute({
         targetDir
     });
-    return agentOutputToLintOutput(output);
+    return toLintOutput(output, "agent", output.totalAgents);
 }
-/**
- * Converts hook lint output to unified LintOutput.
- */ function hookOutputToLintOutput(output) {
-    const diagnostics = [];
-    for (const result of output.results){
-        for (const d of result.diagnostics){
-            diagnostics.push({
-                filePath: result.filePath,
-                line: d.line,
-                severity: d.severity,
-                message: d.message,
-                field: d.field,
-                ruleId: d.ruleId,
-                target: "hook"
-            });
-        }
-    }
-    return {
-        diagnostics,
-        target: "hook",
-        filesAnalyzed: output.results.map((r)=>r.filePath),
-        summary: {
-            totalFiles: output.totalFiles,
-            totalErrors: output.totalErrors,
-            totalWarnings: output.totalWarnings,
-            totalInfos: 0
-        }
-    };
-}
-/**
- * Runs hook configuration linting.
- */ async function lintHooks(targetDir) {
+async function lintHooks(targetDir) {
     const gateway = createHookConfigGateway();
     const useCase = new LintHookConfigUseCase(gateway);
     const output = await useCase.execute({
         targetDir
     });
-    return hookOutputToLintOutput(output);
+    return toLintOutput(output, "hook", output.totalFiles);
 }
-/**
- * Runs instruction quality analysis.
- */ async function lintInstructions(targetDir) {
+async function lintInstructions(targetDir) {
     const discoveryGateway = createInstructionFileDiscoveryGateway();
     const astGateway = createMarkdownAstGateway();
     const commandsGateway = createFeedbackLoopCommandsGateway();
@@ -57043,6 +57114,141 @@ function hasFrontmatterDelimiters(content) {
         }
     };
 }
+const LINT_TARGETS = [
+    {
+        key: "skills",
+        execute: lintSkills
+    },
+    {
+        key: "agents",
+        execute: lintAgents
+    },
+    {
+        key: "hooks",
+        execute: lintHooks
+    },
+    {
+        key: "instructions",
+        execute: lintInstructions
+    }
+];
+function isTargetEnabled(key, targets) {
+    if (!targets) return true;
+    const hasAnyEnabled = Object.values(targets).some(Boolean);
+    return !hasAnyEnabled || targets[key] === true;
+}
+/**
+ * Run lint checks on a project directory.
+ *
+ * Orchestrates all lint targets (skills, agents, hooks, instructions),
+ * applies lint rule configuration, and returns structured results.
+ *
+ * When no targets are specified (or all are false), all targets are run.
+ *
+ * @example
+ * ```typescript
+ * import { runLint } from '@lousy-agents/lint';
+ *
+ * const result = await runLint({ directory: '/path/to/project' });
+ * console.log(result.hasErrors);
+ * console.log(result.outputs);
+ * ```
+ *
+ * @throws {LintValidationError} If directory validation, schema validation, or lint configuration validation fails.
+ */ async function runLint(options) {
+    let parsed;
+    try {
+        parsed = LintOptionsSchema.parse(options);
+    } catch (error) {
+        if (error instanceof ZodError) {
+            throw new LintValidationError(error.issues.map((e)=>e.message).join("; "));
+        }
+        throw error;
+    }
+    const targetDir = await validateDirectory(parsed.directory);
+    let rulesConfig;
+    try {
+        rulesConfig = await loadLintConfig(targetDir);
+    } catch (error) {
+        if (error instanceof ZodError) {
+            throw new LintValidationError(`Invalid lint configuration: ${error.issues.map((e)=>e.message).join("; ")}`);
+        }
+        throw error;
+    }
+    const enabledTargets = LINT_TARGETS.filter((t)=>isTargetEnabled(t.key, parsed.targets));
+    const outputs = [];
+    for (const target of enabledTargets){
+        const rawOutput = await target.execute(targetDir);
+        outputs.push(applySeverityFilter(rawOutput, rulesConfig));
+    }
+    const totalErrors = outputs.reduce((sum, output)=>sum + output.summary.totalErrors, 0);
+    return {
+        outputs,
+        hasErrors: totalErrors > 0
+    };
+}
+
+;// CONCATENATED MODULE: ../lint/src/index.ts
+/**
+ * @lousy-agents/lint — Public Lint API
+ *
+ * Provides a programmatic lint interface for validating agent skills,
+ * custom agents, hook configurations, and instruction files.
+ *
+ * @example
+ * ```typescript
+ * import { runLint, createFormatter } from '@lousy-agents/lint';
+ *
+ * const result = await runLint({ directory: '/path/to/project' });
+ * if (result.hasErrors) {
+ *   const formatter = createFormatter('json');
+ *   console.error(formatter.format(result.outputs));
+ * }
+ * ```
+ */ // ── Instruction quality result types (returned in LintOutput) ────────
+
+// ── Output formatters ────────────────────────────────────────────────
+
+
+
+
+;// CONCATENATED MODULE: ./src/commands/lint.ts
+/**
+ * CLI command for linting agent skills, custom agents, and instruction files.
+ * Delegates to the lint package facade and handles CLI display concerns.
+ */ 
+
+
+/**
+ * Formats and displays a LintOutput using consola.
+ */ function displayLintOutput(output, label) {
+    if (output.summary.totalFiles === 0) {
+        consola.info(`No ${label} found`);
+        return;
+    }
+    consola.info(`Discovered ${output.summary.totalFiles} ${label}`);
+    // Group diagnostics by file
+    const filesWithDiagnostics = new Set();
+    for (const d of output.diagnostics){
+        filesWithDiagnostics.add(d.filePath);
+    }
+    for (const file of output.filesAnalyzed){
+        if (!filesWithDiagnostics.has(file)) {
+            consola.success(`${file}: OK`);
+        }
+    }
+    for (const d of output.diagnostics){
+        const prefix = `${d.filePath}:${d.line}`;
+        const fieldInfo = d.field ? ` [${d.field}]` : "";
+        if (d.severity === "error") {
+            consola.error(`${prefix}${fieldInfo}: ${d.message}`);
+        } else if (d.severity === "warning") {
+            consola.warn(`${prefix}${fieldInfo}: ${d.message}`);
+        } else {
+            consola.info(`${prefix}${fieldInfo}: ${d.message}`);
+        }
+    }
+}
 /**
  * Displays instruction quality analysis results using consola.
  */ function displayInstructionQuality(output) {
@@ -57099,57 +57305,43 @@ function hasFrontmatterDelimiters(content) {
     },
     run: async (context)=>{
         const rawTargetDir = typeof context.data?.targetDir === "string" ? context.data.targetDir : process.cwd();
-        const targetDir = validateTargetDir(rawTargetDir);
-        let rulesConfig;
-        try {
-            rulesConfig = await loadLintConfig(targetDir);
-        } catch (error) {
-            const message = error instanceof Error ? error.message : String(error);
-            consola.error(`Failed to load lint configuration: ${message}`);
-            process.exitCode = 1;
-            return;
-        }
         const lintSkillsFlag = context.args?.skills === true || context.data?.skills === true;
         const lintAgentsFlag = context.args?.agents === true || context.data?.agents === true;
         const lintHooksFlag = context.args?.hooks === true || context.data?.hooks === true;
         const lintInstructionsFlag = context.args?.instructions === true || context.data?.instructions === true;
-        const noFlagProvided = !lintSkillsFlag && !lintAgentsFlag && !lintHooksFlag && !lintInstructionsFlag;
-        const formatValue = context.args?.format ?? context.data?.format ?? "human";
-        const format = [
+        const rawFormat = typeof context.args?.format === "string" ? context.args.format : typeof context.data?.format === "string" ? context.data.format : "human";
+        const validFormats = new Set([
             "human",
             "json",
             "rdjsonl"
-        ].includes(formatValue) ? formatValue : "human";
-        let totalErrors = 0;
+        ]);
+        function isLintFormatType(value) {
+            return validFormats.has(value);
+        }
+        const format = isLintFormatType(rawFormat) ? rawFormat : "human";
+        let result;
+        try {
+            result = await runLint({
+                directory: rawTargetDir,
+                targets: {
+                    skills: lintSkillsFlag,
+                    agents: lintAgentsFlag,
+                    hooks: lintHooksFlag,
+                    instructions: lintInstructionsFlag
+                }
+            });
+        } catch (error) {
+            if (error instanceof LintValidationError) {
+                consola.error(`Lint failed: ${error.message}`);
+                process.exitCode = 1;
+                return;
+            }
+            throw error;
+        }
+        const { outputs, hasErrors } = result;
         let totalWarnings = 0;
-        const allOutputs = [];
-        if (noFlagProvided || lintSkillsFlag) {
-            const rawOutput = await lintSkills(targetDir);
-            const skillOutput = applySeverityFilter(rawOutput, rulesConfig);
-            allOutputs.push(skillOutput);
-            totalErrors += skillOutput.summary.totalErrors;
-            totalWarnings += skillOutput.summary.totalWarnings;
-        }
-        if (noFlagProvided || lintAgentsFlag) {
-            const rawOutput = await lintAgents(targetDir);
-            const agentOutput = applySeverityFilter(rawOutput, rulesConfig);
-            allOutputs.push(agentOutput);
-            totalErrors += agentOutput.summary.totalErrors;
-            totalWarnings += agentOutput.summary.totalWarnings;
-        }
-        if (noFlagProvided || lintHooksFlag) {
-            const rawOutput = await lintHooks(targetDir);
-            const hookOutput = applySeverityFilter(rawOutput, rulesConfig);
-            allOutputs.push(hookOutput);
-            totalErrors += hookOutput.summary.totalErrors;
-            totalWarnings += hookOutput.summary.totalWarnings;
-        }
-        if (noFlagProvided || lintInstructionsFlag) {
-            const rawOutput = await lintInstructions(targetDir);
-            const instructionOutput = applySeverityFilter(rawOutput, rulesConfig);
-            allOutputs.push(instructionOutput);
-            totalErrors += instructionOutput.summary.totalErrors;
-            totalWarnings += instructionOutput.summary.totalWarnings;
+        for (const output of outputs){
+            totalWarnings += output.summary.totalWarnings;
         }
         const targetLabels = {
             skill: "skill(s)",
@@ -57159,12 +57351,12 @@ function hasFrontmatterDelimiters(content) {
         };
         if (format !== "human") {
             const formatter = createFormatter(format);
-            const formatted = formatter.format(allOutputs);
+            const formatted = formatter.format(outputs);
             if (formatted) {
                 process.stdout.write(`${formatted}\n`);
             }
         } else {
-            for (const output of allOutputs){
+            for (const output of outputs){
                 const label = targetLabels[output.target] ?? output.target;
                 if (output.target === "instruction") {
                     displayInstructionQuality(output);
@@ -57173,9 +57365,10 @@ function hasFrontmatterDelimiters(content) {
                 }
             }
         }
-        if (totalErrors > 0) {
+        if (hasErrors) {
             process.exitCode = 1;
             if (format === "human") {
+                const totalErrors = outputs.reduce((sum, o)=>sum + o.summary.totalErrors, 0);
                 consola.error(`lint failed: ${totalErrors} error(s), ${totalWarnings} warning(s)`);
             }
             return;
@@ -57184,7 +57377,7 @@ function hasFrontmatterDelimiters(content) {
             if (totalWarnings > 0) {
                 consola.warn(`Lint passed with ${totalWarnings} warning(s)`);
             } else {
-                const targets = allOutputs.map((o)=>targetLabels[o.target] ?? o.target).join(", ");
+                const targets = outputs.map((o)=>targetLabels[o.target] ?? o.target).join(", ");
                 consola.success(`All ${targets} passed lint checks`);
             }
         }