@agentlighthouse/core 0.1.0-alpha.0

package/dist/detection/project.js

@@ -0,0 +1,225 @@
+const artifactRoles = {
+    "AGENTS.md": "Primary coding-agent instructions",
+    "CLAUDE.md": "Claude Code project memory",
+    "llms.txt": "LLM-readable project map",
+    "README.md": "Human and agent entry point",
+    ".cursor/rules": "Cursor rules",
+    ".github/copilot-instructions.md": "GitHub Copilot instructions",
+    ".agentlighthouseignore": "AgentLighthouse ignore rules"
+};
+export function detectProject(signals) {
+    const evidence = [];
+    const packageJson = signals.packageJson;
+    const has = (file) => signals.scannedFiles.includes(file);
+    const hasAny = (predicate) => signals.scannedFiles.some(predicate);
+    const dependencies = new Set([
+        ...(packageJson?.dependencies ?? []),
+        ...(packageJson?.devDependencies ?? [])
+    ]);
+    let type = "unknown";
+    let confidence = 0.3;
+    const rootOpenApiFiles = signals.openApiFiles.filter((file) => !file.startsWith("examples/"));
+    if (signals.mcpFiles.length > 0 ||
+        [...dependencies].some((dependency) => dependency.includes("mcp"))) {
+        type = "mcp_project";
+        confidence = 0.9;
+        evidence.push("MCP file or package signal detected.");
+    }
+    else if (rootOpenApiFiles.length > 0) {
+        type = "openapi_project";
+        confidence = 0.85;
+        evidence.push(`OpenAPI files detected: ${rootOpenApiFiles.join(", ")}.`);
+    }
+    else if (packageJson &&
+        (has("tsconfig.json") || has("tsconfig.base.json") || hasAny((file) => file.endsWith(".ts")))) {
+        type = "node_typescript";
+        confidence = 0.9;
+        evidence.push("package.json plus TypeScript config or source files detected.");
+    }
+    else if (packageJson) {
+        type = "node_javascript";
+        confidence = 0.8;
+        evidence.push("package.json detected.");
+    }
+    else if (has("pyproject.toml") ||
+        has("requirements.txt") ||
+        hasAny((file) => file.endsWith(".py"))) {
+        type = "python";
+        confidence = 0.85;
+        evidence.push("Python project files detected.");
+    }
+    else if (has("Cargo.toml")) {
+        type = "rust";
+        confidence = 0.85;
+        evidence.push("Cargo.toml detected.");
+    }
+    else if (has("go.mod")) {
+        type = "go";
+        confidence = 0.85;
+        evidence.push("go.mod detected.");
+    }
+    else if (signals.docsMarkdownFiles.length > 0 &&
+        signals.scannedFiles.filter((file) => /\.(ts|tsx|js|jsx|py|rs|go)$/i.test(file)).length === 0) {
+        type = "docs_only";
+        confidence = 0.75;
+        evidence.push("Markdown docs detected without common source-code files.");
+    }
+    return {
+        type,
+        name: packageJson?.name ?? signals.projectName,
+        confidence,
+        evidence: evidence.length > 0 ? evidence : ["No strong project-type signal detected."],
+        packageManager: detectPackageManager(signals),
+        frameworks: detectFrameworks(signals)
+    };
+}
+export function detectedArtifacts(signals) {
+    return Object.entries(signals.artifacts).map(([artifactPath, artifact]) => {
+        const content = signals.textByPath[artifactPath];
+        return {
+            path: artifactPath,
+            exists: artifact.exists,
+            kind: artifact.kind,
+            role: artifactRoles[artifactPath] ?? "Agent-readiness artifact",
+            quality: artifact.exists ? artifactQuality(artifactPath, content, signals) : "missing",
+            notes: artifactNotes(artifactPath, content, signals)
+        };
+    });
+}
+function detectPackageManager(signals) {
+    const declaredManager = signals.packageJson?.packageManager?.split("@")[0];
+    if (declaredManager === "pnpm" ||
+        declaredManager === "npm" ||
+        declaredManager === "yarn" ||
+        declaredManager === "bun") {
+        return declaredManager;
+    }
+    if (signals.scannedFiles.includes("pnpm-lock.yaml"))
+        return "pnpm";
+    if (signals.scannedFiles.includes("yarn.lock"))
+        return "yarn";
+    if (signals.scannedFiles.includes("bun.lockb") || signals.scannedFiles.includes("bun.lock"))
+        return "bun";
+    if (signals.scannedFiles.includes("package-lock.json"))
+        return "npm";
+    if (signals.scannedFiles.includes("pyproject.toml"))
+        return "poetry";
+    if (signals.scannedFiles.includes("requirements.txt"))
+        return "pip";
+    if (signals.scannedFiles.includes("Cargo.toml"))
+        return "cargo";
+    if (signals.scannedFiles.includes("go.mod"))
+        return "go";
+    if (signals.packageJson)
+        return "npm";
+    return "unknown";
+}
+function detectFrameworks(signals) {
+    const dependencies = new Set([
+        ...(signals.packageJson?.dependencies ?? []),
+        ...(signals.packageJson?.devDependencies ?? [])
+    ]);
+    const frameworks = [];
+    for (const [dependency, framework] of [
+        ["next", "Next.js"],
+        ["react", "React"],
+        ["vite", "Vite"],
+        ["express", "Express"],
+        ["fastify", "Fastify"],
+        ["astro", "Astro"],
+        ["typescript", "TypeScript"],
+        ["vitest", "Vitest"]
+    ]) {
+        if (dependencies.has(dependency)) {
+            frameworks.push(framework);
+        }
+    }
+    if (signals.scannedFiles.includes("pyproject.toml"))
+        frameworks.push("Python");
+    if (signals.scannedFiles.includes("Cargo.toml"))
+        frameworks.push("Rust");
+    if (signals.scannedFiles.includes("go.mod"))
+        frameworks.push("Go");
+    return [...new Set(frameworks)];
+}
+function artifactQuality(artifactPath, content, signals) {
+    if (!content && artifactPath === ".cursor/rules") {
+        return signals.scannedFiles.some((file) => file.startsWith(".cursor/rules/"))
+            ? "partial"
+            : "unknown";
+    }
+    if (!content)
+        return "unknown";
+    const score = qualitySignals(content, artifactPath).filter(Boolean).length;
+    if (score >= 8)
+        return "strong";
+    if (score >= 4)
+        return "partial";
+    return "thin";
+}
+function artifactNotes(artifactPath, content, signals) {
+    if (!content &&
+        artifactPath === ".cursor/rules" &&
+        signals.scannedFiles.some((file) => file.startsWith(".cursor/rules/"))) {
+        return ["Cursor rules directory detected."];
+    }
+    if (!content)
+        return ["Artifact exists but no text content was available for quality checks."];
+    const checks = qualityCheckLabels(content, artifactPath);
+    const present = checks
+        .filter((check) => check.present)
+        .map((check) => `Includes ${check.label}.`);
+    const missing = checks
+        .filter((check) => !check.present)
+        .map((check) => `Missing ${check.label}.`);
+    return [...present.slice(0, 4), ...missing.slice(0, 4)];
+}
+function qualitySignals(content, artifactPath) {
+    return qualityCheckLabels(content, artifactPath).map((check) => check.present);
+}
+function qualityCheckLabels(content, artifactPath) {
+    const lower = content.toLowerCase();
+    const hasAny = (terms) => terms.some((term) => lower.includes(term));
+    const hasCommand = /\b(pnpm|npm|yarn|bun|pip|poetry|cargo|go)\s+[a-z0-9:_-]+/i.test(content);
+    const hasLink = /\[[^\]]+\]\([^)]+\)/.test(content) || /^https?:\/\//m.test(content);
+    const checks = [
+        {
+            label: "project overview",
+            present: hasAny(["overview", "purpose", "what it does", "project"])
+        },
+        { label: "setup commands", present: hasAny(["install", "setup"]) && hasCommand },
+        { label: "test commands", present: hasAny(["test", "pytest", "vitest", "jest"]) && hasCommand },
+        {
+            label: "lint/typecheck commands",
+            present: hasAny(["lint", "typecheck", "type check", "mypy"])
+        },
+        { label: "architecture map", present: hasAny(["architecture", "packages/", "apps/", "src/"]) },
+        { label: "coding conventions", present: hasAny(["convention", "style", "format", "naming"]) },
+        {
+            label: "security/privacy guidance",
+            present: hasAny(["secret", "privacy", "credential", "sensitive", "security"])
+        },
+        { label: "common mistakes", present: hasAny(["avoid", "do not", "don't", "common mistake"]) },
+        {
+            label: "generated-file warnings",
+            present: hasAny(["generated", "dist", "build output", "do not edit"])
+        },
+        { label: "docs links", present: hasLink || hasAny(["docs/", "readme"]) },
+        { label: "examples", present: hasAny(["example", "usage", "sample"]) },
+        { label: "task workflows", present: hasAny(["workflow", "task", "steps", "success criteria"]) }
+    ];
+    if (artifactPath === "llms.txt") {
+        return checks.filter((check) => ["project overview", "docs links", "examples", "architecture map"].includes(check.label));
+    }
+    if (artifactPath === "README.md") {
+        return checks.filter((check) => [
+            "project overview",
+            "setup commands",
+            "test commands",
+            "docs links",
+            "examples",
+            "architecture map"
+        ].includes(check.label));
+    }
+    return checks;
+}

package/dist/findings/helpers.d.ts

@@ -0,0 +1,36 @@
+import type { Finding, FindingCategory, Severity, SuggestedFixType } from "../schemas/types.js";
+export declare function finding(input: {
+    id: string;
+    ruleId?: string;
+    fingerprint?: string;
+    identityParts?: string[];
+    locationKey?: string;
+    subject?: string;
+    title: string;
+    severity: Severity;
+    category: FindingCategory;
+    description: string;
+    evidence: string[];
+    recommendation: string;
+    affectedFile?: string;
+    agentFailureMode?: string;
+    fixExample?: string;
+    docsLinks?: string[];
+    suggestedFixType: SuggestedFixType;
+}): Finding;
+export declare function textIncludesAny(text: string | undefined, needles: readonly string[]): boolean;
+export declare function hasUsefulMarkdownLinks(text: string | undefined): boolean;
+export declare function deriveFindingIdentity(input: {
+    ruleId: string;
+    affectedFile?: string;
+    evidence: string[];
+    subject?: string;
+    locationKey?: string;
+    identityParts?: string[];
+}): {
+    identityParts: string[];
+    locationKey: string;
+    subject: string;
+};
+export declare function stableFingerprint(identityParts: string[]): string;
+//# sourceMappingURL=helpers.d.ts.map

package/dist/findings/helpers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"helpers.d.ts","sourceRoot":"","sources":["../../src/findings/helpers.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,eAAe,EAAE,QAAQ,EAAE,gBAAgB,EAAE,MAAM,qBAAqB,CAAC;AAMhG,wBAAgB,OAAO,CAAC,KAAK,EAAE;IAC7B,EAAE,EAAE,MAAM,CAAC;IACX,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,aAAa,CAAC,EAAE,MAAM,EAAE,CAAC;IACzB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,KAAK,EAAE,MAAM,CAAC;IACd,QAAQ,EAAE,QAAQ,CAAC;IACnB,QAAQ,EAAE,eAAe,CAAC;IAC1B,WAAW,EAAE,MAAM,CAAC;IACpB,QAAQ,EAAE,MAAM,EAAE,CAAC;IACnB,cAAc,EAAE,MAAM,CAAC;IACvB,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,gBAAgB,CAAC,EAAE,MAAM,CAAC;IAC1B,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,SAAS,CAAC,EAAE,MAAM,EAAE,CAAC;IACrB,gBAAgB,EAAE,gBAAgB,CAAC;CACpC,GAAG,OAAO,CAkBV;AAED,wBAAgB,eAAe,CAAC,IAAI,EAAE,MAAM,GAAG,SAAS,EAAE,OAAO,EAAE,SAAS,MAAM,EAAE,GAAG,OAAO,CAM7F;AAED,wBAAgB,sBAAsB,CAAC,IAAI,EAAE,MAAM,GAAG,SAAS,GAAG,OAAO,CAKxE;AAED,wBAAgB,qBAAqB,CAAC,KAAK,EAAE;IAC3C,MAAM,EAAE,MAAM,CAAC;IACf,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,QAAQ,EAAE,MAAM,EAAE,CAAC;IACnB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,aAAa,CAAC,EAAE,MAAM,EAAE,CAAC;CAC1B,GAAG;IAAE,aAAa,EAAE,MAAM,EAAE,CAAC;IAAC,WAAW,EAAE,MAAM,CAAC;IAAC,OAAO,EAAE,MAAM,CAAA;CAAE,CAqDpE;AAED,wBAAgB,iBAAiB,CAAC,aAAa,EAAE,MAAM,EAAE,GAAG,MAAM,CAQjE"}

package/dist/findings/helpers.js

@@ -0,0 +1,115 @@
+const openApiEvidencePattern = /(?<file>[^:;\n]+):\s*(?<method>GET|POST|PUT|PATCH|DELETE)\s+(?<path>\/[^\s;(]+)/i;
+const mcpOrTaskEvidencePattern = /(?<file>[^:;\n]+):\s*(?<subject>[A-Za-z0-9_.:-]+)/;
+export function finding(input) {
+    const ruleId = input.ruleId ?? input.id;
+    const identity = deriveFindingIdentity({
+        ruleId,
+        affectedFile: input.affectedFile,
+        evidence: input.evidence,
+        subject: input.subject,
+        locationKey: input.locationKey,
+        identityParts: input.identityParts
+    });
+    return {
+        ...input,
+        ruleId,
+        fingerprint: input.fingerprint ?? stableFingerprint(identity.identityParts),
+        identityParts: input.identityParts ?? identity.identityParts,
+        locationKey: input.locationKey ?? identity.locationKey,
+        subject: input.subject ?? identity.subject
+    };
+}
+export function textIncludesAny(text, needles) {
+    if (!text) {
+        return false;
+    }
+    const lower = text.toLowerCase();
+    return needles.some((needle) => lower.includes(needle.toLowerCase()));
+}
+export function hasUsefulMarkdownLinks(text) {
+    if (!text) {
+        return false;
+    }
+    return /\[[^\]]+\]\([^)]+\)/.test(text) || /^https?:\/\//m.test(text) || /^\//m.test(text);
+}
+export function deriveFindingIdentity(input) {
+    if (input.identityParts && input.identityParts.length > 0) {
+        const normalizedParts = input.identityParts.map(normalizeIdentityPart);
+        return {
+            identityParts: normalizedParts,
+            locationKey: input.locationKey ?? normalizedParts[1] ?? input.ruleId,
+            subject: input.subject ?? normalizedParts.at(-1) ?? input.ruleId
+        };
+    }
+    const evidenceKey = firstEvidenceKey(input.evidence);
+    const openApiMatch = input.evidence.join("; ").match(openApiEvidencePattern);
+    if (openApiMatch?.groups) {
+        const file = normalizePath(openApiMatch.groups.file ?? input.affectedFile ?? "");
+        const method = (openApiMatch.groups.method ?? "").toUpperCase();
+        const apiPath = openApiMatch.groups.path ?? "";
+        const subject = input.subject ?? `${method} ${apiPath}`;
+        const locationKey = input.locationKey ?? `${file}#/paths/${jsonPointerPath(apiPath)}/${method.toLowerCase()}`;
+        return {
+            identityParts: [input.ruleId, locationKey, normalizeIdentityPart(subject)],
+            locationKey,
+            subject
+        };
+    }
+    if (/^MCP_/.test(input.ruleId) || /^TASK_/.test(input.ruleId)) {
+        const parsed = input.evidence.join("; ").match(mcpOrTaskEvidencePattern);
+        if (parsed?.groups) {
+            const file = normalizePath(parsed.groups.file ?? input.affectedFile ?? "");
+            const subject = input.subject ?? parsed.groups.subject ?? input.ruleId;
+            const prefix = input.ruleId.startsWith("TASK_") ? "task" : "tool";
+            const locationKey = input.locationKey ?? `${file}#${prefix}:${normalizeIdentityPart(subject)}`;
+            return {
+                identityParts: [input.ruleId, locationKey, normalizeIdentityPart(subject)],
+                locationKey,
+                subject
+            };
+        }
+    }
+    const locationKey = input.locationKey ?? normalizePath(input.affectedFile ?? evidenceKey);
+    const subject = input.subject ?? normalizeSubject(input.affectedFile ?? evidenceKey);
+    return {
+        identityParts: [
+            input.ruleId,
+            normalizeIdentityPart(locationKey || "project"),
+            normalizeIdentityPart(subject || input.ruleId)
+        ],
+        locationKey: locationKey || input.ruleId,
+        subject: subject || input.ruleId
+    };
+}
+export function stableFingerprint(identityParts) {
+    const input = identityParts.map(normalizeIdentityPart).join("|");
+    let hash = 2166136261;
+    for (const character of input) {
+        hash ^= character.charCodeAt(0);
+        hash = Math.imul(hash, 16777619);
+    }
+    return `alh_${(hash >>> 0).toString(16).padStart(8, "0")}`;
+}
+function firstEvidenceKey(evidence) {
+    return evidence[0] ?? "project";
+}
+function normalizePath(value) {
+    return value
+        .trim()
+        .replaceAll("\\", "/")
+        .replace(/^\.\/+/, "")
+        .replace(/^<repo>\//, "")
+        .toLowerCase();
+}
+function normalizeSubject(value) {
+    return value.trim().replace(/\s+/g, " ");
+}
+function normalizeIdentityPart(value) {
+    return normalizeSubject(value).replaceAll("\\", "/").toLowerCase();
+}
+function jsonPointerPath(apiPath) {
+    return apiPath
+        .split("/")
+        .map((part) => part.replaceAll("~", "~0").replaceAll("/", "~1"))
+        .join("~1");
+}

package/dist/findings/locations.d.ts

@@ -0,0 +1,4 @@
+import type { Finding, FindingLocation, ProjectSignals } from "../schemas/types.js";
+export declare function enrichFindingLocations(signals: ProjectSignals, findings: Finding[]): Finding[];
+export declare function inferLocation(signals: ProjectSignals, finding: Pick<Finding, "affectedFile" | "ruleId" | "title" | "evidence" | "locationKey" | "subject">): FindingLocation | undefined;
+//# sourceMappingURL=locations.d.ts.map

package/dist/findings/locations.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"locations.d.ts","sourceRoot":"","sources":["../../src/findings/locations.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,eAAe,EAAE,cAAc,EAAE,MAAM,qBAAqB,CAAC;AAWpF,wBAAgB,sBAAsB,CAAC,OAAO,EAAE,cAAc,EAAE,QAAQ,EAAE,OAAO,EAAE,GAAG,OAAO,EAAE,CAa9F;AAED,wBAAgB,aAAa,CAC3B,OAAO,EAAE,cAAc,EACvB,OAAO,EAAE,IAAI,CACX,OAAO,EACP,cAAc,GAAG,QAAQ,GAAG,OAAO,GAAG,UAAU,GAAG,aAAa,GAAG,SAAS,CAC7E,GACA,eAAe,GAAG,SAAS,CAmB7B"}

package/dist/findings/locations.js

@@ -0,0 +1,117 @@
+const headingByRule = [
+    { pattern: /quickstart/i, heading: /quick\s*start|quickstart|getting started/i },
+    { pattern: /install/i, heading: /install|installation|setup/i },
+    { pattern: /example|usage/i, heading: /example|usage|demo/i },
+    { pattern: /test/i, heading: /test|testing|verify|verification/i },
+    { pattern: /security|secret|privacy/i, heading: /security|secret|privacy/i },
+    { pattern: /architecture|repo map/i, heading: /architecture|structure|repo map/i }
+];
+export function enrichFindingLocations(signals, findings) {
+    return findings.map((finding) => {
+        if (finding.location)
+            return finding;
+        const location = inferLocation(signals, finding);
+        return location
+            ? {
+                ...finding,
+                location,
+                locationKey: finding.locationKey ?? location.locationKey,
+                subject: finding.subject ?? location.subject
+            }
+            : finding;
+    });
+}
+export function inferLocation(signals, finding) {
+    const file = normalizeFile(finding.affectedFile ?? fileFromEvidence(finding.evidence));
+    if (!file || file === "n/a")
+        return undefined;
+    const content = signals.textByPath[file];
+    const sourceKind = sourceKindFor(finding.ruleId, file);
+    const line = sourceKind === "openapi"
+        ? openApiLine(content, finding)
+        : sourceKind === "mcp" || sourceKind === "task"
+            ? subjectLine(content, finding.subject)
+            : markdownLine(content, finding);
+    return {
+        file,
+        ...(line ? { startLine: line } : {}),
+        locationKey: finding.locationKey,
+        subject: finding.subject,
+        symbol: finding.subject,
+        sourceKind
+    };
+}
+function markdownLine(content, finding) {
+    if (!content)
+        return undefined;
+    const lines = content.split(/\r?\n/);
+    const haystack = `${finding.ruleId} ${finding.title}`;
+    const heading = headingByRule.find((entry) => entry.pattern.test(haystack))?.heading;
+    if (heading) {
+        const index = lines.findIndex((line) => /^#{1,6}\s+/.test(line) && heading.test(line));
+        if (index >= 0)
+            return index + 1;
+    }
+    return 1;
+}
+function openApiLine(content, finding) {
+    if (!content)
+        return undefined;
+    const subject = finding.subject ?? subjectFromEvidence(finding.evidence);
+    const match = subject?.match(/^(GET|POST|PUT|PATCH|DELETE)\s+(.+)$/i);
+    if (!match)
+        return 1;
+    const method = match[1]?.toLowerCase();
+    const apiPath = match[2];
+    const lines = content.split(/\r?\n/);
+    const pathIndex = lines.findIndex((line) => line.includes(`${apiPath}:`));
+    if (pathIndex < 0)
+        return 1;
+    const methodIndex = lines.findIndex((line, index) => index >= pathIndex &&
+        index < pathIndex + 30 &&
+        Boolean(method) &&
+        line.match(new RegExp(`^\\s*${method}:`)));
+    return methodIndex >= 0 ? methodIndex + 1 : pathIndex + 1;
+}
+function subjectLine(content, subject) {
+    if (!content)
+        return undefined;
+    if (!subject)
+        return 1;
+    const lines = content.split(/\r?\n/);
+    const index = lines.findIndex((line) => line.includes(subject));
+    return index >= 0 ? index + 1 : 1;
+}
+function sourceKindFor(ruleId, file) {
+    if (ruleId.startsWith("OPENAPI_") || /openapi|swagger/i.test(file))
+        return "openapi";
+    if (ruleId.startsWith("MCP_"))
+        return "mcp";
+    if (ruleId.startsWith("TASK_") || /agentlighthouse\.tasks/i.test(file))
+        return "task";
+    if (/\.md$|llms\.txt|AGENTS\.md|CLAUDE\.md/i.test(file))
+        return "markdown";
+    if (/package\.json|config/i.test(file))
+        return "config";
+    return "unknown";
+}
+function fileFromEvidence(evidence) {
+    const candidate = evidence[0]?.split(":")[0]?.trim();
+    if (!candidate || /\s/.test(candidate))
+        return undefined;
+    if (/^(AGENTS\.md|CLAUDE\.md|README\.md|llms\.txt|package\.json|agentlighthouse\.tasks\.ya?ml)$/i.test(candidate) ||
+        /\.(md|txt|json|ya?ml|ts|tsx|js|jsx|py|toml|rs|go|html)$/i.test(candidate)) {
+        return candidate;
+    }
+    return undefined;
+}
+function subjectFromEvidence(evidence) {
+    const match = evidence.join("; ").match(/\b(GET|POST|PUT|PATCH|DELETE)\s+(\/[^\s;(]+)/i);
+    return match ? `${match[1]?.toUpperCase()} ${match[2]}` : undefined;
+}
+function normalizeFile(file) {
+    return file
+        ?.trim()
+        .replaceAll("\\", "/")
+        .replace(/^\.\/+/, "");
+}

package/dist/generators/artifacts.d.ts

@@ -0,0 +1,6 @@
+import type { ArtifactGenerator, GeneratedArtifact, ProjectSignals } from "../schemas/types.js";
+export declare class StarterArtifactGenerator implements ArtifactGenerator {
+    readonly id = "starter-artifacts";
+    generate(signals: ProjectSignals): GeneratedArtifact[];
+}
+//# sourceMappingURL=artifacts.d.ts.map

package/dist/generators/artifacts.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"artifacts.d.ts","sourceRoot":"","sources":["../../src/generators/artifacts.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,iBAAiB,EAAE,iBAAiB,EAAE,cAAc,EAAE,MAAM,qBAAqB,CAAC;AAEhG,qBAAa,wBAAyB,YAAW,iBAAiB;IAChE,QAAQ,CAAC,EAAE,uBAAuB;IAElC,QAAQ,CAAC,OAAO,EAAE,cAAc,GAAG,iBAAiB,EAAE;CA6BvD"}