@feiyoug/skill-lab 0.0.0

package/esm/analyzer/rules/shared/file-refs.js

@@ -0,0 +1,34 @@
+/**
+ * Shared types and utilities for file reference discovery across all language extractors.
+ */
+import { getFileType } from "../../../shared/mod.js";
+/**
+ * Patterns that indicate the referenced path targets the host filesystem
+ * rather than the skill package itself.
+ */
+export const HOST_FS_PATTERNS = [
+    /^~\//, // ~/... (HOME directory expansion)
+    /^\$[A-Z_][A-Z0-9_]*\//, // $HOME/..., $VAR/... (env var expansion)
+    /^\//, // /absolute/path (absolute path)
+];
+/** Returns true if the path targets the host filesystem. */
+export function isHostFsPath(path) {
+    return HOST_FS_PATTERNS.some((p) => p.test(path));
+}
+/** Returns true if the string looks like a URL. */
+export function isUrl(value) {
+    return /^https?:\/\//i.test(value);
+}
+/**
+ * Regex pattern for bare relative paths (e.g. references/guide.md, ./script.py).
+ * Used by markdown and text extractors for prose scanning.
+ */
+export const BARE_PATH_PATTERN = /(?:\.\.?\/)?[\w./-]+\.[\w-]+/g;
+/** Returns true if the value looks like a file path (not a command or word). */
+export function looksLikePath(value) {
+    if (/^\.?\.?\//.test(value))
+        return true;
+    if (value.includes("/"))
+        return true;
+    return getFileType(value) != "unknown";
+}

package/esm/analyzer/rules/shared/network-evaluators.d.ts

@@ -0,0 +1,4 @@
+import type { DynamicRuleRiskMapping, StaticRuleRiskMapping } from "../../../shared/mod.js";
+export declare const DETECT_NETWORK_FETCH_RISKS: DynamicRuleRiskMapping;
+export declare const DETECT_REMOTE_CODE_EXECUTION_RISK: StaticRuleRiskMapping;
+//# sourceMappingURL=network-evaluators.d.ts.map

package/esm/analyzer/rules/shared/network-evaluators.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"network-evaluators.d.ts","sourceRoot":"","sources":["../../../../src/analyzer/rules/shared/network-evaluators.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACR,sBAAsB,EAGtB,qBAAqB,EACxB,MAAM,wBAAwB,CAAC;AAKhC,eAAO,MAAM,0BAA0B,EAAE,sBA6DxC,CAAC;AAEF,eAAO,MAAM,iCAAiC,EAAE,qBAI/C,CAAC"}

package/esm/analyzer/rules/shared/network-evaluators.js

@@ -0,0 +1,93 @@
+import { classifyDestination, parseUrlFromUnknown } from "../../utils/url-parser.js";
+const WRITE_METHODS = new Set(["POST", "PUT", "PATCH"]);
+export const DETECT_NETWORK_FETCH_RISKS = ({ permission }) => {
+    if (!permission)
+        return null;
+    const rawUrl = resolveUrl(permission);
+    if (!rawUrl)
+        return null;
+    const parsed = parseUrlFromUnknown(rawUrl);
+    if (!parsed)
+        return null;
+    const method = resolveMethod(permission);
+    const destination = classifyDestination(parsed.host);
+    const hasSecretsInRequest = hasSecretInRequest(permission, rawUrl);
+    const results = [];
+    if (destination === "external") {
+        if (WRITE_METHODS.has(method)) {
+            results.push({
+                code: "NETWORK:data_exfiltration",
+                severity: "critical",
+                message: `Writes data to external host ${parsed.host} via ${method}`,
+                metadata: {
+                    host: parsed.host,
+                    method,
+                    destination,
+                    url: parsed.raw,
+                },
+            });
+        }
+        else {
+            results.push({
+                code: "NETWORK:external_network_access",
+                severity: "warning",
+                message: `Reads from external host ${parsed.host}`,
+                metadata: {
+                    host: parsed.host,
+                    method,
+                    destination,
+                    url: parsed.raw,
+                },
+            });
+        }
+    }
+    if (hasSecretsInRequest) {
+        results.push({
+            code: destination === "external"
+                ? "NETWORK:credential_leak"
+                : "NETWORK:localhost_secret_exposure",
+            severity: destination === "external" ? "critical" : "warning",
+            message: `Potential secret transmission detected for ${parsed.host}`,
+            metadata: {
+                host: parsed.host,
+                method,
+                destination,
+                url: parsed.raw,
+            },
+        });
+    }
+    if (results.length === 0)
+        return null;
+    return results;
+};
+export const DETECT_REMOTE_CODE_EXECUTION_RISK = {
+    code: "NETWORK:remote_code_execution",
+    severity: "critical",
+    message: "Remote output piped to shell",
+};
+function resolveUrl(permission) {
+    const metadata = permission.metadata ?? {};
+    if (typeof metadata.url === "string")
+        return metadata.url;
+    if (!Array.isArray(permission.args) || permission.args.length === 0)
+        return undefined;
+    return permission.args.find((arg) => /\.|localhost|\//.test(arg));
+}
+function resolveMethod(permission) {
+    const metadata = permission.metadata ?? {};
+    const raw = typeof metadata.method === "string"
+        ? metadata.method
+        : inferMethodFromArgs(permission.args);
+    return String(raw).toUpperCase();
+}
+function inferMethodFromArgs(args) {
+    if (!args || args.length === 0)
+        return "GET";
+    const explicit = args.find((arg) => /^(get|post|put|patch|delete)$/i.test(arg));
+    return explicit ? explicit.toUpperCase() : "GET";
+}
+function hasSecretInRequest(permission, rawUrl) {
+    const metadata = permission.metadata ?? {};
+    const header = String(metadata.header ?? metadata.headers ?? "");
+    return /token|authorization|bearer|api[_-]?key|secret/i.test(`${header} ${rawUrl} ${JSON.stringify(metadata)}`);
+}

package/esm/analyzer/rules/shared/prompt-injection.d.ts

@@ -0,0 +1,8 @@
+import type { RuleRiskMapping } from "../../../shared/mod.js";
+export type PromptRegexRule = {
+    id: string;
+    pattern: RegExp;
+    mappedRisks?: RuleRiskMapping[];
+};
+export declare const PROMPT_REGEX_RULES: PromptRegexRule[];
+//# sourceMappingURL=prompt-injection.d.ts.map

package/esm/analyzer/rules/shared/prompt-injection.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"prompt-injection.d.ts","sourceRoot":"","sources":["../../../../src/analyzer/rules/shared/prompt-injection.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,wBAAwB,CAAC;AAE9D,MAAM,MAAM,eAAe,GAAG;IAC1B,EAAE,EAAE,MAAM,CAAC;IACX,OAAO,EAAE,MAAM,CAAC;IAChB,WAAW,CAAC,EAAE,eAAe,EAAE,CAAC;CACnC,CAAC;AAEF,eAAO,MAAM,kBAAkB,EAAE,eAAe,EAuC/C,CAAC"}

package/esm/analyzer/rules/shared/prompt-injection.js

@@ -0,0 +1,38 @@
+export const PROMPT_REGEX_RULES = [
+    {
+        id: "prompt-ignore-previous",
+        pattern: /ignore previous instructions?/i,
+        mappedRisks: [{
+                code: "PROMPT:prompt_override",
+                severity: "critical",
+                message: "Prompt override attempt detected",
+            }],
+    },
+    {
+        id: "prompt-forget-rules",
+        pattern: /forget (all )?(previous|earlier) rules/i,
+        mappedRisks: [{
+                code: "PROMPT:prompt_override",
+                severity: "critical",
+                message: "Prompt override attempt detected",
+            }],
+    },
+    {
+        id: "prompt-reveal-system-prompt",
+        pattern: /(reveal|show|print|dump|leak|disclose|output)\b[\s\S]{0,80}\b(system prompt|hidden instructions?)/i,
+        mappedRisks: [{
+                code: "PROMPT:prompt_override",
+                severity: "warning",
+                message: "Prompt override attempt detected",
+            }],
+    },
+    {
+        id: "prompt-ignore-and-reveal",
+        pattern: /\b(ignore|forget)\b[\s\S]{0,80}\b(previous|earlier)\b[\s\S]{0,80}\b(instructions?|rules?|system prompt)/i,
+        mappedRisks: [{
+                code: "PROMPT:prompt_override",
+                severity: "critical",
+                message: "Prompt override attempt detected",
+            }],
+    },
+];

package/esm/analyzer/rules/shared/secret-evaluators.d.ts

@@ -0,0 +1,3 @@
+import type { DynamicRuleRiskMapping } from "../../../shared/mod.js";
+export declare const DETECT_SECRET_NAME_RISK: DynamicRuleRiskMapping;
+//# sourceMappingURL=secret-evaluators.d.ts.map

package/esm/analyzer/rules/shared/secret-evaluators.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"secret-evaluators.d.ts","sourceRoot":"","sources":["../../../../src/analyzer/rules/shared/secret-evaluators.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,wBAAwB,CAAC;AAGrE,eAAO,MAAM,uBAAuB,EAAE,sBASrC,CAAC"}

package/esm/analyzer/rules/shared/secret-evaluators.js

@@ -0,0 +1,11 @@
+import { isSecretLikeName, normalizeKeyCandidate } from "../../utils/secret-validator.js";
+export const DETECT_SECRET_NAME_RISK = ({ finding }) => {
+    const key = normalizeKeyCandidate(finding.extracted.key ?? finding.extracted.var);
+    if (!isSecretLikeName(key))
+        return null;
+    return {
+        code: "SECRETS:secret_access",
+        severity: "warning",
+        message: `Potential secret or credential access: ${key}`,
+    };
+};

package/esm/analyzer/rules/text/mod.d.ts

@@ -0,0 +1,5 @@
+import type { AstGrepRule } from "../../astgrep/client.js";
+import { FileTypeConfig } from "../../types.js";
+export declare const TEXT_RULES: AstGrepRule[];
+export declare const TEXT_FILETYPE_CONFIG: FileTypeConfig;
+//# sourceMappingURL=mod.d.ts.map

package/esm/analyzer/rules/text/mod.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mod.d.ts","sourceRoot":"","sources":["../../../../src/analyzer/rules/text/mod.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,yBAAyB,CAAC;AAC3D,OAAO,EAAE,cAAc,EAAE,MAAM,gBAAgB,CAAC;AAIhD,eAAO,MAAM,UAAU,EAAE,WAAW,EAAO,CAAC;AAE5C,eAAO,MAAM,oBAAoB,EAAE,cAIlC,CAAC"}

package/esm/analyzer/rules/text/mod.js

@@ -0,0 +1,8 @@
+import { extractCodeBlocks } from "../markdown/extractCodeBlocks.js";
+import { extractMarkdownFileRefs } from "../markdown/extractFileRefs.js";
+export const TEXT_RULES = [];
+export const TEXT_FILETYPE_CONFIG = {
+    extractCodeBlocks,
+    defaultLanguage: "markdown",
+    extractFileRefs: extractMarkdownFileRefs,
+};

package/esm/analyzer/rules/typescript/mod.d.ts

@@ -0,0 +1,3 @@
+import type { AstGrepRule } from "../../astgrep/client.js";
+export declare const TYPESCRIPT_RULES: AstGrepRule[];
+//# sourceMappingURL=mod.d.ts.map

package/esm/analyzer/rules/typescript/mod.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mod.d.ts","sourceRoot":"","sources":["../../../../src/analyzer/rules/typescript/mod.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,yBAAyB,CAAC;AAG3D,eAAO,MAAM,gBAAgB,EAAE,WAAW,EAGvC,CAAC"}

package/esm/analyzer/rules/typescript/mod.js

@@ -0,0 +1,5 @@
+import { JAVASCRIPT_RULES } from "../javascript/mod.js";
+export const TYPESCRIPT_RULES = [...JAVASCRIPT_RULES].map((rule) => ({
+    ...rule,
+    language: "typescript",
+}));

package/esm/analyzer/steps/001-discovery/discover-files.d.ts

@@ -0,0 +1,26 @@
+import type { SkillFile } from "../../../skillreader/mod.js";
+import type { AnalyzerContext } from "../../types.js";
+import type { FileRefDiscovery } from "../../types.js";
+import type { FileReference, Reference } from "../../../shared/mod.js";
+type StartQueueItem = {
+    path: string;
+    depth: number;
+    referencedBy?: Reference;
+};
+/**
+ * Discovers referenced files recursively and excludes starting queue paths.
+ *
+ * Step 001 is code-block aware:
+ * - Extracts code blocks from each file
+ * - Runs per-language extractFileRefs on each block
+ * - Enqueues discovered local markdown/text files for recursive discovery
+ * - Emits virtual code-block FileReferences for step 002 scanning
+ */
+export declare function discoverReferencedFiles(context: AnalyzerContext, input: {
+    startQueue: StartQueueItem[];
+    allFiles: SkillFile[];
+    readTextFile: (path: string) => Promise<string | null>;
+    maxScanDepth: number;
+}): Promise<FileReference[]>;
+export type { FileRefDiscovery };
+//# sourceMappingURL=discover-files.d.ts.map

package/esm/analyzer/steps/001-discovery/discover-files.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"discover-files.d.ts","sourceRoot":"","sources":["../../../../src/analyzer/steps/001-discovery/discover-files.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,6BAA6B,CAAC;AAG7D,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,gBAAgB,CAAC;AAGtD,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,gBAAgB,CAAC;AACvD,OAAO,KAAK,EAAE,aAAa,EAAE,SAAS,EAAE,MAAM,wBAAwB,CAAC;AAGvE,KAAK,cAAc,GAAG;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,MAAM,CAAC;IAAC,YAAY,CAAC,EAAE,SAAS,CAAA;CAAE,CAAC;AAEhF;;;;;;;;GAQG;AACH,wBAAsB,uBAAuB,CACzC,OAAO,EAAE,eAAe,EACxB,KAAK,EAAE;IACH,UAAU,EAAE,cAAc,EAAE,CAAC;IAC7B,QAAQ,EAAE,SAAS,EAAE,CAAC;IACtB,YAAY,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC,CAAC;IACvD,YAAY,EAAE,MAAM,CAAC;CACxB,GACF,OAAO,CAAC,aAAa,EAAE,CAAC,CA6J1B;AAMD,YAAY,EAAE,gBAAgB,EAAE,CAAC"}

package/esm/analyzer/steps/001-discovery/discover-files.js

@@ -0,0 +1,147 @@
+import { getFileRole, getFileType } from "../../../shared/mod.js";
+import { FILETYPE_CONFIGS } from "../../rules/mod.js";
+import { isHostFsPath, isUrl } from "../../rules/shared/file-refs.js";
+import { encodeCodeBlockPath } from "../../utils/code-block-path.js";
+/**
+ * Discovers referenced files recursively and excludes starting queue paths.
+ *
+ * Step 001 is code-block aware:
+ * - Extracts code blocks from each file
+ * - Runs per-language extractFileRefs on each block
+ * - Enqueues discovered local markdown/text files for recursive discovery
+ * - Emits virtual code-block FileReferences for step 002 scanning
+ */
+export async function discoverReferencedFiles(context, input) {
+    const discovered = new Map();
+    const queue = [...input.startQueue];
+    // A set of file paths which have been processed
+    const processed = new Set();
+    const startPaths = new Set(input.startQueue.map((item) => normalizePath(item.path)));
+    while (queue.length > 0) {
+        const current = queue.shift();
+        if (!current)
+            break;
+        if (processed.has(current.path) || current.depth > input.maxScanDepth)
+            continue;
+        processed.add(current.path);
+        const content = await input.readTextFile(current.path);
+        if (!content)
+            continue;
+        const currentFileType = getFileType(current.path);
+        const blocks = await FILETYPE_CONFIGS[currentFileType]?.extractCodeBlocks?.(context, content) ?? [];
+        blocks.push({
+            language: currentFileType,
+            content,
+            startLine: 0,
+            endLine: Math.max(0, content.split("\n").length),
+            type: "content",
+        });
+        for (const block of blocks) {
+            const blockRefs = await FILETYPE_CONFIGS[block.language]?.extractFileRefs?.(context, block.content) ??
+                [];
+            for (const blockRef of blockRefs) {
+                const absoluteRef = {
+                    ...blockRef,
+                    line: blockRef.line + block.startLine - 1,
+                };
+                const normalizedPath = normalizePath(absoluteRef.path);
+                if (!normalizedPath || startPaths.has(normalizedPath) ||
+                    discovered.has(normalizedPath)) {
+                    continue;
+                }
+                const referenceFromCurrent = {
+                    file: current.path,
+                    line: absoluteRef.line,
+                    type: block.type,
+                    referencedBy: current.referencedBy,
+                };
+                const existsInSkill = input.allFiles.filter((file) => file.path.includes(normalizedPath));
+                if (existsInSkill.length > 0) {
+                    for (const file of existsInSkill) {
+                        if (discovered.has(file.path))
+                            continue;
+                        const resolvedFileType = getFileType(file.path);
+                        const localEntry = {
+                            path: file.path,
+                            sourceType: "local",
+                            fileType: resolvedFileType,
+                            role: getFileRole(file.path),
+                            depth: current.depth + 1,
+                            discoveryMethod: absoluteRef.via,
+                            referencedBy: referenceFromCurrent,
+                        };
+                        discovered.set(file.path, localEntry);
+                        // Keep scaning for files that are referenced within the skill repo
+                        queue.push({
+                            path: file.path,
+                            depth: current.depth + 1,
+                            referencedBy: localEntry.referencedBy,
+                        });
+                    }
+                    continue;
+                }
+                if (isHostFsPath(normalizedPath)) {
+                    discovered.set(normalizedPath, {
+                        path: normalizedPath,
+                        sourceType: "external",
+                        fileType: "unknown",
+                        role: "host-fs",
+                        depth: current.depth + 1,
+                        discoveryMethod: absoluteRef.via,
+                        referencedBy: referenceFromCurrent,
+                    });
+                    continue;
+                }
+                if (isUrl(normalizedPath) || absoluteRef.via === "markdown-link") {
+                    discovered.set(normalizedPath, {
+                        path: normalizedPath,
+                        sourceType: "external",
+                        fileType: "unknown",
+                        role: "regular",
+                        depth: current.depth + 1,
+                        discoveryMethod: absoluteRef.via,
+                        referencedBy: referenceFromCurrent,
+                    });
+                    continue;
+                }
+                if (absoluteRef.via === "import" || absoluteRef.via === "source") {
+                    discovered.set(normalizedPath, {
+                        path: normalizedPath,
+                        sourceType: "external",
+                        fileType: "unknown",
+                        role: "library",
+                        depth: current.depth + 1,
+                        discoveryMethod: absoluteRef.via,
+                        referencedBy: referenceFromCurrent,
+                    });
+                    continue;
+                }
+            }
+            let codeBlockPath = current.path;
+            if (block.type != "content") {
+                codeBlockPath = encodeCodeBlockPath(current.path, block.startLine, block.endLine);
+            }
+            if (!discovered.has(codeBlockPath)) {
+                discovered.set(codeBlockPath, {
+                    path: codeBlockPath,
+                    sourceType: "local",
+                    fileType: block.language,
+                    role: "script",
+                    depth: current.depth + 1,
+                    discoveryMethod: "code-block",
+                    referencedBy: {
+                        file: current.path,
+                        line: block.startLine,
+                        lineEnd: block.endLine,
+                        type: block.type,
+                        referencedBy: current.referencedBy,
+                    },
+                });
+            }
+        }
+    }
+    return Array.from(discovered.values());
+}
+function normalizePath(value) {
+    return value.replace(/^\/+/, "").replace(/\\/g, "/").trim();
+}

package/esm/analyzer/steps/001-discovery/filter-files.d.ts

@@ -0,0 +1,15 @@
+import type { SkillFile } from "../../../skillreader/mod.js";
+import type { FileReference } from "../../../shared/mod.js";
+export declare function filterScanQueue(input: {
+    queue: FileReference[];
+    allFiles: SkillFile[];
+    maxFileSize: number;
+    maxFileCount: number;
+}): {
+    queue: FileReference[];
+    skipped: Array<{
+        path: string;
+        reason: string;
+    }>;
+};
+//# sourceMappingURL=filter-files.d.ts.map

package/esm/analyzer/steps/001-discovery/filter-files.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"filter-files.d.ts","sourceRoot":"","sources":["../../../../src/analyzer/steps/001-discovery/filter-files.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,6BAA6B,CAAC;AAC7D,OAAO,KAAK,EAAE,aAAa,EAAY,MAAM,wBAAwB,CAAC;AAEtE,wBAAgB,eAAe,CAAC,KAAK,EAAE;IACnC,KAAK,EAAE,aAAa,EAAE,CAAC;IACvB,QAAQ,EAAE,SAAS,EAAE,CAAC;IACtB,WAAW,EAAE,MAAM,CAAC;IACpB,YAAY,EAAE,MAAM,CAAC;CACxB,GAAG;IAAE,KAAK,EAAE,aAAa,EAAE,CAAC;IAAC,OAAO,EAAE,KAAK,CAAC;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,MAAM,CAAA;KAAE,CAAC,CAAA;CAAE,CA+D/E"}

package/esm/analyzer/steps/001-discovery/filter-files.js

@@ -0,0 +1,57 @@
+export function filterScanQueue(input) {
+    const result = [];
+    const skipped = [];
+    const ordered = [...input.queue].sort((a, b) => {
+        const roleRank = (value) => {
+            switch (value) {
+                case "entrypoint":
+                    return 0;
+                case "readme":
+                    return 1;
+                case "reference":
+                    return 2;
+                case "license":
+                    return 3;
+                case "script":
+                    return 4;
+                case "library":
+                    return 5;
+                case "config":
+                    return 6;
+                default:
+                    return 7;
+            }
+        };
+        const fileTypeRank = (value) => {
+            if (value === "markdown" || value === "text")
+                return 0;
+            if (value === "bash" || value === "javascript" || value === "typescript" ||
+                value === "python")
+                return 1;
+            if (value === "json" || value === "yaml")
+                return 2;
+            return 3;
+        };
+        const roleDiff = roleRank(a.role) - roleRank(b.role);
+        if (roleDiff !== 0)
+            return roleDiff;
+        return fileTypeRank(a.fileType) - fileTypeRank(b.fileType);
+    });
+    for (const fileRef of ordered) {
+        const file = input.allFiles.find((item) => item.path === fileRef.path);
+        if (file?.contentType === "binary") {
+            skipped.push({ path: fileRef.path, reason: "binary" });
+            continue;
+        }
+        if ((file?.size ?? 0) > input.maxFileSize) {
+            skipped.push({ path: fileRef.path, reason: "too_large" });
+            continue;
+        }
+        if (result.length >= input.maxFileCount) {
+            skipped.push({ path: fileRef.path, reason: "too_many" });
+            continue;
+        }
+        result.push(fileRef);
+    }
+    return { queue: result, skipped };
+}

package/esm/analyzer/steps/001-discovery/mod.d.ts

@@ -0,0 +1,3 @@
+import type { AnalyzerContext, AnalyzerState } from "../../types.js";
+export declare function run001Discovery(state: AnalyzerState, context: AnalyzerContext): Promise<AnalyzerState>;
+//# sourceMappingURL=mod.d.ts.map

package/esm/analyzer/steps/001-discovery/mod.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mod.d.ts","sourceRoot":"","sources":["../../../../src/analyzer/steps/001-discovery/mod.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,eAAe,EAAE,aAAa,EAAE,MAAM,gBAAgB,CAAC;AAIrE,wBAAsB,eAAe,CACjC,KAAK,EAAE,aAAa,EACpB,OAAO,EAAE,eAAe,GACzB,OAAO,CAAC,aAAa,CAAC,CA4DxB"}

package/esm/analyzer/steps/001-discovery/mod.js

@@ -0,0 +1,50 @@
+import { DEFAULT_SKILL_VERSION, FRONTMATTER_SUPPORTED_FIELDS } from "../../config.js";
+import { discoverReferencedFiles } from "./discover-files.js";
+import { filterScanQueue } from "./filter-files.js";
+export async function run001Discovery(state, context) {
+    const files = await context.skillReader.listFiles();
+    const skillMdPath = await context.skillReader.getSkillMdPath();
+    const frontmatter = await context.skillReader.getSkillMdFrontmatter();
+    const nextState = {
+        ...state,
+        files,
+        frontmatter,
+        skillId: String(frontmatter.name ?? state.skillId),
+        skillVersionId: String(frontmatter.metadata?.version ?? state.skillVersionId ?? DEFAULT_SKILL_VERSION),
+    };
+    for (const field of Object.keys(frontmatter)) {
+        if (!FRONTMATTER_SUPPORTED_FIELDS.includes(field) && ![
+            "startLineNumber",
+            "endLineNumber",
+        ].includes(field)) {
+            nextState.warnings.push(`Unknown frontmatter field '${field}' - analysis not supported yet`);
+        }
+    }
+    const discovered = await discoverReferencedFiles(context, {
+        startQueue: [{ path: skillMdPath, depth: 0 }],
+        allFiles: files,
+        readTextFile: (path) => context.skillReader.readTextFile(path),
+        maxScanDepth: state.metadata.config.maxScanDepth,
+    });
+    discovered.push({
+        path: skillMdPath,
+        sourceType: "local",
+        fileType: "markdown",
+        role: "entrypoint",
+        depth: 0,
+    });
+    const filtered = filterScanQueue({
+        queue: discovered,
+        allFiles: files,
+        maxFileCount: state.metadata.config.maxFileCount,
+        maxFileSize: state.metadata.config.maxFileSize,
+    });
+    return {
+        ...nextState,
+        scanQueue: filtered.queue,
+        metadata: {
+            ...nextState.metadata,
+            skippedFiles: [...nextState.metadata.skippedFiles, ...filtered.skipped],
+        },
+    };
+}

package/esm/analyzer/steps/002-permissions/mod.d.ts

@@ -0,0 +1,3 @@
+import type { AnalyzerContext, AnalyzerState } from "../../types.js";
+export declare function run002Permissions(state: AnalyzerState, context: AnalyzerContext): Promise<AnalyzerState>;
+//# sourceMappingURL=mod.d.ts.map

package/esm/analyzer/steps/002-permissions/mod.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mod.d.ts","sourceRoot":"","sources":["../../../../src/analyzer/steps/002-permissions/mod.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAE,aAAa,EAAE,MAAM,gBAAgB,CAAC;AAWrE,wBAAsB,iBAAiB,CACnC,KAAK,EAAE,aAAa,EACpB,OAAO,EAAE,eAAe,GACzB,OAAO,CAAC,aAAa,CAAC,CA+FxB"}