@lousy-agents/cli 4.0.1 → 5.0.0

package/api/copilot-with-fastify/src/app.integration.ts

@@ -0,0 +1,45 @@
+import type { AddressInfo } from "node:net";
+import type { FastifyInstance } from "fastify";
+import { afterAll, beforeAll, describe, expect, it } from "vitest";
+import { buildApp } from "./app.js";
+
+describe("API integration", () => {
+    let app: FastifyInstance;
+    let baseUrl: string;
+
+    beforeAll(async () => {
+        app = buildApp();
+        await app.listen({ port: 0, host: "127.0.0.1" });
+        const address = app.server.address() as AddressInfo;
+        baseUrl = `http://127.0.0.1:${address.port}`;
+    });
+
+    afterAll(async () => {
+        await app.close();
+    });
+
+    describe("GET /health", () => {
+        it("should respond with 200 and health status", async () => {
+            const response = await fetch(`${baseUrl}/health`);
+
+            expect(response.status).toBe(200);
+            expect(await response.json()).toEqual({ status: "ok" });
+        });
+
+        it("should return application/json content type", async () => {
+            const response = await fetch(`${baseUrl}/health`);
+
+            expect(response.headers.get("content-type")).toContain(
+                "application/json",
+            );
+        });
+    });
+
+    describe("undefined routes", () => {
+        it("should return 404 for non-existent routes", async () => {
+            const response = await fetch(`${baseUrl}/nonexistent`);
+
+            expect(response.status).toBe(404);
+        });
+    });
+});

package/api/copilot-with-fastify/src/app.test.ts

@@ -0,0 +1,28 @@
+import type { FastifyInstance } from "fastify";
+import { afterAll, beforeAll, describe, expect, it } from "vitest";
+import { buildApp } from "./app.js";
+
+describe("Health endpoint", () => {
+    let app: FastifyInstance;
+
+    beforeAll(async () => {
+        app = buildApp();
+        await app.ready();
+    });
+
+    afterAll(async () => {
+        await app.close();
+    });
+
+    describe("GET /health", () => {
+        it("should return 200 with status ok", async () => {
+            const response = await app.inject({
+                method: "GET",
+                url: "/health",
+            });
+
+            expect(response.statusCode).toBe(200);
+            expect(response.json()).toEqual({ status: "ok" });
+        });
+    });
+});

package/api/copilot-with-fastify/src/app.ts

@@ -0,0 +1,11 @@
+import Fastify from "fastify";
+
+export function buildApp() {
+    const app = Fastify({ logger: true });
+
+    app.get("/health", async () => {
+        return { status: "ok" };
+    });
+
+    return app;
+}

package/api/copilot-with-fastify/src/index.ts

@@ -0,0 +1,12 @@
+import { buildApp } from "./app.js";
+import { parsePort } from "./parse-port.js";
+
+const app = buildApp();
+const port = parsePort(process.env.PORT);
+
+try {
+    await app.listen({ port, host: "0.0.0.0" });
+} catch (err) {
+    app.log.error(err);
+    process.exit(1);
+}

package/api/copilot-with-fastify/src/parse-port.test.ts

@@ -0,0 +1,100 @@
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+import { parsePort } from "./parse-port.js";
+
+describe("parsePort", () => {
+    describe("when value is undefined", () => {
+        it("should return default port 3000", () => {
+            const result = parsePort(undefined);
+
+            expect(result).toBe(3000);
+        });
+    });
+
+    describe("when value is empty string", () => {
+        it("should return default port 3000", () => {
+            const result = parsePort("");
+
+            expect(result).toBe(3000);
+        });
+    });
+
+    describe("when value is a valid unprivileged port", () => {
+        it("should return the parsed port", () => {
+            const result = parsePort("8080");
+
+            expect(result).toBe(8080);
+        });
+    });
+
+    describe("when value is invalid", () => {
+        let warnSpy: ReturnType<typeof vi.spyOn>;
+
+        beforeEach(() => {
+            warnSpy = vi.spyOn(console, "warn").mockImplementation(() => {});
+        });
+
+        afterEach(() => {
+            warnSpy.mockRestore();
+        });
+
+        it("should warn and return default for non-numeric value", () => {
+            const result = parsePort("abc");
+
+            expect(result).toBe(3000);
+            expect(warnSpy).toHaveBeenCalledWith(
+                'Invalid PORT "abc", using default 3000',
+            );
+        });
+
+        it("should warn and return default for privileged port", () => {
+            const result = parsePort("80");
+
+            expect(result).toBe(3000);
+            expect(warnSpy).toHaveBeenCalledWith(
+                'Invalid PORT "80", using default 3000',
+            );
+        });
+
+        it("should warn and return default for port above max", () => {
+            const result = parsePort("70000");
+
+            expect(result).toBe(3000);
+            expect(warnSpy).toHaveBeenCalledWith(
+                'Invalid PORT "70000", using default 3000',
+            );
+        });
+
+        it("should warn and return default for non-integer port", () => {
+            const result = parsePort("3000.5");
+
+            expect(result).toBe(3000);
+            expect(warnSpy).toHaveBeenCalledWith(
+                'Invalid PORT "3000.5", using default 3000',
+            );
+        });
+    });
+
+    describe("when value is not provided or empty", () => {
+        let warnSpy: ReturnType<typeof vi.spyOn>;
+
+        beforeEach(() => {
+            warnSpy = vi.spyOn(console, "warn").mockImplementation(() => {});
+        });
+
+        afterEach(() => {
+            warnSpy.mockRestore();
+        });
+
+        it("should not warn when value is undefined", () => {
+            parsePort(undefined);
+
+            expect(warnSpy).not.toHaveBeenCalled();
+        });
+
+        it("should not warn when value is empty string", () => {
+            parsePort("");
+
+            expect(warnSpy).not.toHaveBeenCalled();
+        });
+    });
+});

package/api/copilot-with-fastify/src/parse-port.ts

@@ -0,0 +1,20 @@
+const defaultPort = 3000;
+const minUnprivilegedPort = 1024;
+const maxPort = 65535;
+
+export function parsePort(value: string | undefined): number {
+    if (value === undefined || value === "") {
+        return defaultPort;
+    }
+    const parsed = Number(value);
+    if (
+        !Number.isInteger(parsed) ||
+        parsed < minUnprivilegedPort ||
+        parsed > maxPort
+    ) {
+        // biome-ignore lint/suspicious/noConsole: user-facing warning for invalid PORT
+        console.warn(`Invalid PORT "${value}", using default ${defaultPort}`);
+        return defaultPort;
+    }
+    return parsed;
+}

package/cli/copilot-with-citty/.vscode/mcp.json

@@ -13,7 +13,7 @@
         "lousy-agents": {
             "type": "stdio",
             "command": "npx",
-            "args": ["-y", "-p", "@lousy-agents/cli", "lousy-agents-mcp"]
+            "args": ["-y", "-p", "@lousy-agents/mcp", "lousy-agents-mcp"]
         }
     }
 }

package/dist/index.js

@@ -35198,7 +35198,38 @@ const CLI_TEMPLATE_DIR = (0,external_node_path_.join)(PROJECT_ROOT, "cli", "copi
                 path: "vitest.setup.ts",
                 content: readRestApiTemplateFile("vitest.setup.ts")
             },
-            ...buildCommonNodes(readRestApiTemplateFile)
+            ...buildCommonNodes(readRestApiTemplateFile),
+            // Source code
+            {
+                type: "file",
+                path: "src/app.ts",
+                content: readRestApiTemplateFile("src/app.ts")
+            },
+            {
+                type: "file",
+                path: "src/app.test.ts",
+                content: readRestApiTemplateFile("src/app.test.ts")
+            },
+            {
+                type: "file",
+                path: "src/app.integration.ts",
+                content: readRestApiTemplateFile("src/app.integration.ts")
+            },
+            {
+                type: "file",
+                path: "src/parse-port.ts",
+                content: readRestApiTemplateFile("src/parse-port.ts")
+            },
+            {
+                type: "file",
+                path: "src/parse-port.test.ts",
+                content: readRestApiTemplateFile("src/parse-port.test.ts")
+            },
+            {
+                type: "file",
+                path: "src/index.ts",
+                content: readRestApiTemplateFile("src/index.ts")
+            }
         ]
     };
     return cachedRestApiStructure;
@@ -55779,6 +55810,84 @@ const remark = unified().use(remarkParse).use(remarkStringify).freeze()
     }
 }
 
+;// CONCATENATED MODULE: ../core/src/use-cases/apply-severity-filter.ts
+/**
+ * Shared severity filtering for lint outputs.
+ * Applies rule severity configuration to diagnostics, filtering out "off" rules,
+ * remapping "warn" → "warning", and recalculating summary counts.
+ */ /** Maps a lint target to its config key */ const TARGET_TO_CONFIG_KEY = {
+    skill: "skills",
+    agent: "agents",
+    instruction: "instructions"
+};
+/**
+ * Maps config severity to diagnostic severity.
+ * "warn" → "warning", "error" → "error", "off" → null (drop).
+ */ function apply_severity_filter_mapSeverity(configSeverity) {
+    if (configSeverity === "off") {
+        return null;
+    }
+    if (configSeverity === "warn") {
+        return "warning";
+    }
+    return configSeverity;
+}
+/**
+ * Filters instruction suggestions based on rule severity configuration.
+ * Drops suggestions whose corresponding rule is "off".
+ * Suggestions without a ruleId pass through unchanged.
+ */ function filterInstructionSuggestions(suggestions, rules) {
+    return suggestions.filter((suggestion)=>{
+        if (!suggestion.ruleId) {
+            return true;
+        }
+        return rules[suggestion.ruleId] !== "off";
+    });
+}
+/**
+ * Applies severity filtering to a LintOutput based on rule configuration.
+ * Drops diagnostics for "off" rules, remaps severity for "warn"/"error" rules.
+ * Diagnostics without a ruleId pass through unchanged.
+ * For instruction targets, also filters qualityResult.suggestions.
+ */ function applySeverityFilter(output, rulesConfig) {
+    const configKey = TARGET_TO_CONFIG_KEY[output.target];
+    const targetRules = rulesConfig[configKey];
+    const filteredDiagnostics = [];
+    for (const diagnostic of output.diagnostics){
+        const configuredSeverity = diagnostic.ruleId ? targetRules[diagnostic.ruleId] : undefined;
+        if (!configuredSeverity) {
+            filteredDiagnostics.push(diagnostic);
+            continue;
+        }
+        const mappedSeverity = apply_severity_filter_mapSeverity(configuredSeverity);
+        if (mappedSeverity === null) {
+            continue;
+        }
+        filteredDiagnostics.push({
+            ...diagnostic,
+            severity: mappedSeverity
+        });
+    }
+    const totalErrors = filteredDiagnostics.filter((d)=>d.severity === "error").length;
+    const totalWarnings = filteredDiagnostics.filter((d)=>d.severity === "warning").length;
+    const totalInfos = filteredDiagnostics.filter((d)=>d.severity === "info").length;
+    const filteredQualityResult = output.qualityResult && configKey === "instructions" ? {
+        ...output.qualityResult,
+        suggestions: filterInstructionSuggestions(output.qualityResult.suggestions, targetRules)
+    } : output.qualityResult;
+    return {
+        ...output,
+        diagnostics: filteredDiagnostics,
+        qualityResult: filteredQualityResult,
+        summary: {
+            ...output.summary,
+            totalErrors,
+            totalWarnings,
+            totalInfos
+        }
+    };
+}
+
 ;// CONCATENATED MODULE: ../core/src/use-cases/lint-agent-frontmatter.ts
 /**
  * Use case for linting GitHub Copilot custom agent frontmatter.
@@ -56080,6 +56189,7 @@ function hasFrontmatterDelimiters(content) {
 
 
 
+
 /** Schema for validating target directory */ const TargetDirSchema = schemas_string().min(1, "Target directory is required");
 /**
  * Validates the target directory.
@@ -56244,78 +56354,6 @@ function hasFrontmatterDelimiters(content) {
         consola.warn(suggestion.message);
     }
 }
-/** Maps a lint target to its config key */ const TARGET_TO_CONFIG_KEY = {
-    skill: "skills",
-    agent: "agents",
-    instruction: "instructions"
-};
-/**
- * Maps config-facing severity to diagnostic-facing severity.
- * "warn" → "warning", "error" → "error", "off" → null (drop).
- */ function lint_mapSeverity(configSeverity) {
-    if (configSeverity === "off") {
-        return null;
-    }
-    if (configSeverity === "warn") {
-        return "warning";
-    }
-    return configSeverity;
-}
-/**
- * Filters instruction suggestions based on rule severity configuration.
- * Drops suggestions whose corresponding rule is "off".
- * Suggestions without a ruleId pass through unchanged.
- */ function filterInstructionSuggestions(suggestions, rules) {
-    return suggestions.filter((suggestion)=>{
-        if (!suggestion.ruleId) {
-            return true;
-        }
-        return rules[suggestion.ruleId] !== "off";
-    });
-}
-/**
- * Applies severity filtering to a LintOutput based on rule configuration.
- * Drops diagnostics for "off" rules, remaps severity for "warn"/"error" rules.
- * Diagnostics without a ruleId pass through unchanged.
- * For instruction targets, also filters qualityResult.suggestions.
- */ function applySeverityFilter(output, rulesConfig) {
-    const configKey = TARGET_TO_CONFIG_KEY[output.target];
-    const targetRules = rulesConfig[configKey];
-    const filteredDiagnostics = [];
-    for (const diagnostic of output.diagnostics){
-        const configuredSeverity = diagnostic.ruleId ? targetRules[diagnostic.ruleId] : undefined;
-        if (!configuredSeverity) {
-            filteredDiagnostics.push(diagnostic);
-            continue;
-        }
-        const mappedSeverity = lint_mapSeverity(configuredSeverity);
-        if (mappedSeverity === null) {
-            continue;
-        }
-        filteredDiagnostics.push({
-            ...diagnostic,
-            severity: mappedSeverity
-        });
-    }
-    const totalErrors = filteredDiagnostics.filter((d)=>d.severity === "error").length;
-    const totalWarnings = filteredDiagnostics.filter((d)=>d.severity === "warning").length;
-    const totalInfos = filteredDiagnostics.filter((d)=>d.severity === "info").length;
-    const filteredQualityResult = output.qualityResult && configKey === "instructions" ? {
-        ...output.qualityResult,
-        suggestions: filterInstructionSuggestions(output.qualityResult.suggestions, targetRules)
-    } : output.qualityResult;
-    return {
-        ...output,
-        diagnostics: filteredDiagnostics,
-        qualityResult: filteredQualityResult,
-        summary: {
-            ...output.summary,
-            totalErrors,
-            totalWarnings,
-            totalInfos
-        }
-    };
-}
 /**
  * The `lint` command for validating agent skills, custom agents, and instruction files.
  */ const lintCommand = defineCommand({