@feiyoug/skill-lab 0.0.0

package/esm/analyzer/rules/markdown/astTypes.js

@@ -0,0 +1,31 @@
+/** ast-grep node types for the Markdown block grammar (@ast-grep/lang-markdown). */
+export const MARKDOWN_NODE = {
+    CODE_FENCE_BLOCK: "fenced_code_block",
+    CODE_FENCE_CONTENT: "code_fence_content",
+    CODE_FENCE_LANGUAGE: "language",
+    INFO_STRING: "info_string",
+    PARAGRAPH: "paragraph",
+    INLINE: "inline",
+};
+/** tree-sitter node types for the Markdown inline grammar ("markdown-inline"). */
+export const MARKDOWN_INLINE_NODE = {
+    INLINE_LINK: "inline_link",
+    LINK_DESTINATION: "link_destination",
+    CODE_SPAN: "code_span",
+    TEXT: "text",
+};
+/**
+ * Pre-built tree-sitter S-expression query strings for the Markdown inline grammar.
+ * Pass these to treesitterClient.createQuery("markdown-inline", …) — results are cached
+ * by TreesitterClient so compilation happens only once per client instance.
+ */
+export const MARKDOWN_INLINE_QUERY = {
+    INLINE_LINK_DEST: `(${MARKDOWN_INLINE_NODE.INLINE_LINK} (${MARKDOWN_INLINE_NODE.LINK_DESTINATION}) @dest)`,
+    CODE_SPAN: `(${MARKDOWN_INLINE_NODE.CODE_SPAN}) @code`,
+    TEXT: `(${MARKDOWN_INLINE_NODE.TEXT}) @text`,
+};
+/** tree-sitter query strings for the Markdown block grammar ("markdown"). */
+export const MARKDOWN_QUERY = {
+    FENCED_BLOCK: `(${MARKDOWN_NODE.CODE_FENCE_BLOCK}) @block`,
+    INLINE: `(${MARKDOWN_NODE.INLINE}) @inline`,
+};

package/esm/analyzer/rules/markdown/extractCodeBlocks.d.ts

@@ -0,0 +1,7 @@
+import type { AnalyzerContext, CodeBlock } from "../../types.js";
+/**
+ * For markdown we use treesitter query directly
+ * as AST-grep doesn't support inline markdown
+ */
+export declare function extractCodeBlocks(context: AnalyzerContext, content: string): Promise<CodeBlock[]>;
+//# sourceMappingURL=extractCodeBlocks.d.ts.map

package/esm/analyzer/rules/markdown/extractCodeBlocks.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"extractCodeBlocks.d.ts","sourceRoot":"","sources":["../../../../src/analyzer/rules/markdown/extractCodeBlocks.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,eAAe,EAAE,SAAS,EAAE,MAAM,gBAAgB,CAAC;AAgBjE;;;GAGG;AACH,wBAAsB,iBAAiB,CACnC,OAAO,EAAE,eAAe,EACxB,OAAO,EAAE,MAAM,GAChB,OAAO,CAAC,SAAS,EAAE,CAAC,CAqFtB"}

package/esm/analyzer/rules/markdown/extractCodeBlocks.js

@@ -0,0 +1,70 @@
+import { FILETYPE_BY_LANGUAGE } from "../../../shared/mod.js";
+import { MARKDOWN_INLINE_QUERY, MARKDOWN_NODE, MARKDOWN_QUERY } from "./astTypes.js";
+/**
+ * For markdown we use treesitter query directly
+ * as AST-grep doesn't support inline markdown
+ */
+export async function extractCodeBlocks(context, content) {
+    const blocks = [];
+    try {
+        const blockTree = await context.treesitterClient.parse("markdown", content);
+        const fencedBlockQuery = await context.treesitterClient.createQuery("markdown", MARKDOWN_QUERY.FENCED_BLOCK);
+        for (const match of fencedBlockQuery.matches(blockTree.rootNode)) {
+            for (const capture of match.captures) {
+                if (capture.name !== "block")
+                    continue;
+                const blockNode = capture.node;
+                const startLine = blockNode.startPosition.row + 1;
+                const endLine = blockNode.endPosition.row + 1;
+                const languageNode = blockNode.children.find((child) => child.type === MARKDOWN_NODE.CODE_FENCE_LANGUAGE ||
+                    child.type === MARKDOWN_NODE.INFO_STRING);
+                const fenceLanguage = FILETYPE_BY_LANGUAGE[(languageNode?.text ?? "").trim().toLowerCase()] ?? null;
+                const contentNode = blockNode.children.find((child) => child.type === MARKDOWN_NODE.CODE_FENCE_CONTENT);
+                const codeContent = (contentNode?.text ?? "")
+                    .replace(/\n?[`~]{3,}[^\n]*\s*$/, "")
+                    .trimEnd();
+                if (!codeContent.trim())
+                    continue;
+                blocks.push({
+                    language: fenceLanguage ?? "text",
+                    content: codeContent,
+                    startLine,
+                    endLine,
+                    type: "script",
+                });
+            }
+        }
+        const inlineNodeQuery = await context.treesitterClient.createQuery("markdown", MARKDOWN_QUERY.INLINE);
+        const inlineParser = await context.treesitterClient.getParser("markdown-inline");
+        const codeSpanQuery = await context.treesitterClient.createQuery("markdown-inline", MARKDOWN_INLINE_QUERY.CODE_SPAN);
+        for (const inlineMatch of inlineNodeQuery.matches(blockTree.rootNode)) {
+            for (const inlineCapture of inlineMatch.captures) {
+                if (inlineCapture.name !== "inline")
+                    continue;
+                const inlineNode = inlineCapture.node;
+                const inlineTree = inlineParser.parse(inlineNode.text);
+                for (const codeMatch of codeSpanQuery.matches(inlineTree.rootNode)) {
+                    for (const codeCapture of codeMatch.captures) {
+                        if (codeCapture.name !== "code")
+                            continue;
+                        const spanNode = codeCapture.node;
+                        const snippet = spanNode.text.replace(/^`+/, "").replace(/`+$/, "").trim();
+                        if (!snippet || snippet.length > 200 || !/^[a-z]/i.test(snippet))
+                            continue;
+                        blocks.push({
+                            language: "bash",
+                            content: snippet,
+                            startLine: inlineNode.startPosition.row + 1,
+                            endLine: inlineNode.startPosition.row + 1,
+                            type: "inline",
+                        });
+                    }
+                }
+            }
+        }
+    }
+    catch (error) {
+        throw new Error(`Failed to extract code blocks from markdown: ${error}`);
+    }
+    return blocks;
+}

package/esm/analyzer/rules/markdown/extractFileRefs.d.ts

@@ -0,0 +1,11 @@
+/**
+ * AST-based file reference extractor for Markdown content.
+ *
+ * Extracts file path references using:
+ * - tree-sitter block grammar + MARKDOWN_QUERY.INLINE to find inline nodes
+ * - tree-sitter inline grammar for inline_link, code_span, text nodes
+ * - regex fallback if AST parsing fails
+ */
+import type { AnalyzerContext, FileRefDiscovery } from "../../types.js";
+export declare function extractMarkdownFileRefs(context: AnalyzerContext, content: string): Promise<FileRefDiscovery[]>;
+//# sourceMappingURL=extractFileRefs.d.ts.map

package/esm/analyzer/rules/markdown/extractFileRefs.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"extractFileRefs.d.ts","sourceRoot":"","sources":["../../../../src/analyzer/rules/markdown/extractFileRefs.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAGH,OAAO,KAAK,EAAE,eAAe,EAAE,gBAAgB,EAAE,MAAM,gBAAgB,CAAC;AAaxE,wBAAsB,uBAAuB,CACzC,OAAO,EAAE,eAAe,EACxB,OAAO,EAAE,MAAM,GAChB,OAAO,CAAC,gBAAgB,EAAE,CAAC,CAgF7B"}

package/esm/analyzer/rules/markdown/extractFileRefs.js

@@ -0,0 +1,151 @@
+/**
+ * AST-based file reference extractor for Markdown content.
+ *
+ * Extracts file path references using:
+ * - tree-sitter block grammar + MARKDOWN_QUERY.INLINE to find inline nodes
+ * - tree-sitter inline grammar for inline_link, code_span, text nodes
+ * - regex fallback if AST parsing fails
+ */
+import { BARE_PATH_PATTERN, isUrl, looksLikePath } from "../shared/file-refs.js";
+import { MARKDOWN_INLINE_QUERY, MARKDOWN_QUERY } from "./astTypes.js";
+export async function extractMarkdownFileRefs(context, content) {
+    try {
+        const refs = [];
+        const blockTree = await context.treesitterClient.parse("markdown", content);
+        const inlineNodeQuery = await context.treesitterClient.createQuery("markdown", MARKDOWN_QUERY.INLINE);
+        const inlineParser = await context.treesitterClient.getParser("markdown-inline");
+        const linkDestQuery = await context.treesitterClient.createQuery("markdown-inline", MARKDOWN_INLINE_QUERY.INLINE_LINK_DEST);
+        const codeSpanQuery = await context.treesitterClient.createQuery("markdown-inline", MARKDOWN_INLINE_QUERY.CODE_SPAN);
+        const textQuery = await context.treesitterClient.createQuery("markdown-inline", MARKDOWN_INLINE_QUERY.TEXT);
+        for (const inlineMatch of inlineNodeQuery.matches(blockTree.rootNode)) {
+            for (const inlineCapture of inlineMatch.captures) {
+                if (inlineCapture.name !== "inline")
+                    continue;
+                const inlineNode = inlineCapture.node;
+                const blockLine = inlineNode.startPosition.row;
+                const inlineTree = inlineParser.parse(inlineNode.text);
+                const inlineRoot = inlineTree.rootNode;
+                for (const match of linkDestQuery.matches(inlineRoot)) {
+                    for (const capture of match.captures) {
+                        if (capture.name !== "dest")
+                            continue;
+                        const destNode = capture.node;
+                        const path = destNode.text.trim();
+                        if (!path || isUrl(path) || path.startsWith("#"))
+                            continue;
+                        refs.push({ path, line: blockLine + 1, via: "markdown-link" });
+                    }
+                }
+                for (const match of codeSpanQuery.matches(inlineRoot)) {
+                    for (const capture of match.captures) {
+                        if (capture.name !== "code")
+                            continue;
+                        const codeNode = capture.node;
+                        const snippet = codeNode.text.replace(/^`+/, "").replace(/`+$/, "").trim();
+                        if (!snippet)
+                            continue;
+                        const parts = snippet.split(/\s+/);
+                        for (let pi = 0; pi < parts.length; pi++) {
+                            const part = parts[pi];
+                            if (pi === 0 && !part.includes("/") && !part.includes("."))
+                                continue;
+                            if (looksLikePath(part) && !isUrl(part)) {
+                                refs.push({ path: part, line: blockLine + 1, via: "inline-code" });
+                            }
+                        }
+                    }
+                }
+                for (const match of textQuery.matches(inlineRoot)) {
+                    for (const capture of match.captures) {
+                        if (capture.name !== "text")
+                            continue;
+                        const textNode = capture.node;
+                        BARE_PATH_PATTERN.lastIndex = 0;
+                        for (const pathMatch of textNode.text.matchAll(BARE_PATH_PATTERN)) {
+                            const path = pathMatch[0].trim();
+                            if (!path || isUrl(path) || !looksLikePath(path))
+                                continue;
+                            refs.push({ path, line: blockLine + 1, via: "bare-path" });
+                        }
+                    }
+                }
+            }
+        }
+        return deduplicateRefs(refs);
+    }
+    catch {
+        // Fallback to regex-based extraction if AST parsing is unavailable
+        return extractMarkdownFileRefsRegex(content);
+    }
+}
+/**
+ * Deduplicate refs, preferring higher-specificity discovery methods.
+ * Priority: markdown-link > inline-code > bare-path
+ */
+function deduplicateRefs(refs) {
+    const priority = {
+        "markdown-link": 3,
+        "inline-code": 2,
+        "bare-path": 1,
+        "import": 2,
+        "url": 3,
+        "source": 2,
+    };
+    const best = new Map();
+    for (const ref of refs) {
+        const key = `${ref.path}:${ref.line}`;
+        const existing = best.get(key);
+        if (!existing || (priority[ref.via] ?? 0) > (priority[existing.via] ?? 0)) {
+            best.set(key, ref);
+        }
+    }
+    return Array.from(best.values());
+}
+/**
+ * Regex-based fallback for when AST parsing is unavailable.
+ */
+function extractMarkdownFileRefsRegex(content) {
+    const refs = [];
+    const lines = content.split("\n");
+    let inFencedBlock = false;
+    const markdownLink = /\[[^\]]+\]\(([^)]+)\)/g;
+    const inlineCode = /`([^`\n]+)`/g;
+    for (let i = 0; i < lines.length; i++) {
+        const line = lines[i];
+        const lineNo = i + 1;
+        if (/^[ \t]*(`{3,}|~{3,})/.test(line)) {
+            inFencedBlock = !inFencedBlock;
+            continue;
+        }
+        if (inFencedBlock)
+            continue;
+        markdownLink.lastIndex = 0;
+        for (const match of line.matchAll(markdownLink)) {
+            const path = match[1]?.trim();
+            if (path && !isUrl(path) && !path.startsWith("#")) {
+                refs.push({ path, line: lineNo, via: "markdown-link" });
+            }
+        }
+        inlineCode.lastIndex = 0;
+        for (const match of line.matchAll(inlineCode)) {
+            const parts = match[1].trim().split(/\s+/);
+            for (let pi = 0; pi < parts.length; pi++) {
+                const part = parts[pi];
+                if (pi === 0 && !part.includes("/") && !part.includes("."))
+                    continue;
+                if (looksLikePath(part) && !isUrl(part)) {
+                    refs.push({ path: part, line: lineNo, via: "inline-code" });
+                }
+            }
+        }
+        const maskedLine = line.replace(/\[[^\]]*\]\([^)]*\)/g, "");
+        BARE_PATH_PATTERN.lastIndex = 0;
+        for (const match of maskedLine.matchAll(BARE_PATH_PATTERN)) {
+            const path = match[0].trim();
+            if (path && looksLikePath(path) && !isUrl(path)) {
+                refs.push({ path, line: lineNo, via: "bare-path" });
+            }
+        }
+    }
+    return deduplicateRefs(refs);
+}

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

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"mod.d.ts","sourceRoot":"","sources":["../../../../src/analyzer/rules/markdown/mod.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,yBAAyB,CAAC;AAE3D,OAAO,EAAE,cAAc,EAAE,MAAM,gBAAgB,CAAC;AAGhD,eAAO,MAAM,cAAc,EAAE,WAAW,EAAO,CAAC;AAEhD,eAAO,MAAM,wBAAwB,EAAE,cAItC,CAAC"}

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

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

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

@@ -0,0 +1,13 @@
+import { PROMPT_REGEX_RULES } from "./shared/prompt-injection.js";
+import type { FileRefDiscovery, FileTypeConfig } from "../types.js";
+import type { FileType, RuleRiskInput, RuleRiskResult } from "../../shared/mod.js";
+import type { AstGrepRule } from "../astgrep/client.js";
+import type { PromptRegexRule } from "./shared/prompt-injection.js";
+export declare const RULES_BY_FILETYPE: Partial<Record<FileType, readonly AstGrepRule[]>>;
+export declare const FILETYPE_CONFIGS: Record<FileType, FileTypeConfig>;
+export { PROMPT_REGEX_RULES };
+export type { FileRefDiscovery };
+export type RiskRuleDefinition = AstGrepRule | PromptRegexRule;
+export declare const RULES_BY_ID: Map<string, RiskRuleDefinition>;
+export declare function evalRuleRiskMappings(rule: RiskRuleDefinition, input: RuleRiskInput): RuleRiskResult[];
+//# sourceMappingURL=mod.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"mod.d.ts","sourceRoot":"","sources":["../../../src/analyzer/rules/mod.ts"],"names":[],"mappings":"AAQA,OAAO,EAAE,kBAAkB,EAAE,MAAM,8BAA8B,CAAC;AAClE,OAAO,KAAK,EAAE,gBAAgB,EAAE,cAAc,EAAE,MAAM,aAAa,CAAC;AAGpE,OAAO,KAAK,EAAE,QAAQ,EAAE,aAAa,EAAE,cAAc,EAAE,MAAM,qBAAqB,CAAC;AACnF,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,sBAAsB,CAAC;AACxD,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,8BAA8B,CAAC;AAGpE,eAAO,MAAM,iBAAiB,EAAE,OAAO,CAAC,MAAM,CAAC,QAAQ,EAAE,SAAS,WAAW,EAAE,CAAC,CAOtE,CAAC;AAEX,eAAO,MAAM,gBAAgB,EAAE,MAAM,CAAC,QAAQ,EAAE,cAAc,CAgBpD,CAAC;AAEX,OAAO,EAAE,kBAAkB,EAAE,CAAC;AAC9B,YAAY,EAAE,gBAAgB,EAAE,CAAC;AAEjC,MAAM,MAAM,kBAAkB,GAAG,WAAW,GAAG,eAAe,CAAC;AAE/D,eAAO,MAAM,WAAW,EAAE,GAAG,CAAC,MAAM,EAAE,kBAAkB,CAKvD,CAAC;AAEF,wBAAgB,oBAAoB,CAChC,IAAI,EAAE,kBAAkB,EACxB,KAAK,EAAE,aAAa,GACrB,cAAc,EAAE,CAiBlB"}

package/esm/analyzer/rules/mod.js

@@ -0,0 +1,55 @@
+import { BASH_FILETYPE_CONFIS, BASH_RULES } from "./bash/mod.js";
+import { JAVASCRIPT_FILETYPE_CONFIGS, JAVASCRIPT_RULES, TYPESCRIPT_FILETYPE_CONFIGS, } from "./javascript/mod.js";
+import { MARKDOWN_FILETYPE_CONFIG, MARKDOWN_RULES } from "./markdown/mod.js";
+import { PYTHON_RULES, PYTHONG_FILETYPE_CONFIGS } from "./python/mod.js";
+import { PROMPT_REGEX_RULES } from "./shared/prompt-injection.js";
+import { TEXT_FILETYPE_CONFIG, TEXT_RULES } from "./text/mod.js";
+import { TYPESCRIPT_RULES } from "./typescript/mod.js";
+// Single registry used for both file-level scanning and code-block scanning.
+export const RULES_BY_FILETYPE = {
+    markdown: MARKDOWN_RULES,
+    text: TEXT_RULES,
+    bash: BASH_RULES,
+    javascript: JAVASCRIPT_RULES,
+    typescript: TYPESCRIPT_RULES,
+    python: PYTHON_RULES,
+};
+export const FILETYPE_CONFIGS = {
+    markdown: MARKDOWN_FILETYPE_CONFIG,
+    text: TEXT_FILETYPE_CONFIG,
+    bash: BASH_FILETYPE_CONFIS,
+    javascript: JAVASCRIPT_FILETYPE_CONFIGS,
+    typescript: TYPESCRIPT_FILETYPE_CONFIGS,
+    python: PYTHONG_FILETYPE_CONFIGS,
+    csv: { defaultLanguage: null },
+    json: { defaultLanguage: null },
+    yaml: { defaultLanguage: null },
+    toml: { defaultLanguage: null },
+    config: { defaultLanguage: null },
+    sql: { defaultLanguage: null },
+    xml: { defaultLanguage: null },
+    binary: { defaultLanguage: null },
+    unknown: { defaultLanguage: null },
+};
+export { PROMPT_REGEX_RULES };
+export const RULES_BY_ID = new Map([
+    ...Object.values(RULES_BY_FILETYPE).flatMap((rules) => rules ?? []),
+    ...PROMPT_REGEX_RULES,
+].map((rule) => [rule.id, rule]));
+export function evalRuleRiskMappings(rule, input) {
+    const entries = "permission" in rule
+        ? (rule.permission.mappedRisks ?? [])
+        : (rule.mappedRisks ?? []);
+    const results = [];
+    for (const entry of entries) {
+        if (typeof entry === "function") {
+            const value = entry(input);
+            if (!value)
+                continue;
+            results.push(...(Array.isArray(value) ? value : [value]));
+            continue;
+        }
+        results.push(entry);
+    }
+    return results;
+}

package/esm/analyzer/rules/python/astTypes.d.ts

@@ -0,0 +1,10 @@
+/** ast-grep node types for Python. */
+export declare const PYTHON_NODE: {
+    readonly IMPORT_STATEMENT: "import_statement";
+    readonly IMPORT_FROM_STATEMENT: "import_from_statement";
+    readonly CALL: "call";
+    readonly STRING: "string";
+    readonly STRING_CONTENT: "string_content";
+    readonly DOTTED_NAME: "dotted_name";
+};
+//# sourceMappingURL=astTypes.d.ts.map

package/esm/analyzer/rules/python/astTypes.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"astTypes.d.ts","sourceRoot":"","sources":["../../../../src/analyzer/rules/python/astTypes.ts"],"names":[],"mappings":"AAAA,sCAAsC;AACtC,eAAO,MAAM,WAAW;;;;;;;CAOd,CAAC"}

package/esm/analyzer/rules/python/astTypes.js

@@ -0,0 +1,9 @@
+/** ast-grep node types for Python. */
+export const PYTHON_NODE = {
+    IMPORT_STATEMENT: "import_statement",
+    IMPORT_FROM_STATEMENT: "import_from_statement",
+    CALL: "call",
+    STRING: "string",
+    STRING_CONTENT: "string_content",
+    DOTTED_NAME: "dotted_name",
+};

package/esm/analyzer/rules/python/extractFileRefs.d.ts

@@ -0,0 +1,14 @@
+/**
+ * File reference extractor for Python scripts.
+ *
+ * Detects:
+ * - import statements → via: "import"
+ * - from...import statements → via: "import"
+ * - open() calls with host FS paths → via: "bare-path"
+ * - URL string literals (requests.get, urllib, etc.) → via: "url"
+ *
+ * Uses ast-grep AST traversal.
+ */
+import type { AnalyzerContext, FileRefDiscovery } from "../../types.js";
+export declare function extractPythonFileRefs(context: AnalyzerContext, content: string): FileRefDiscovery[];
+//# sourceMappingURL=extractFileRefs.d.ts.map

package/esm/analyzer/rules/python/extractFileRefs.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"extractFileRefs.d.ts","sourceRoot":"","sources":["../../../../src/analyzer/rules/python/extractFileRefs.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAGH,OAAO,KAAK,EAAE,eAAe,EAAE,gBAAgB,EAAE,MAAM,gBAAgB,CAAC;AAGxE,wBAAgB,qBAAqB,CACjC,OAAO,EAAE,eAAe,EACxB,OAAO,EAAE,MAAM,GAChB,gBAAgB,EAAE,CAwEpB"}

package/esm/analyzer/rules/python/extractFileRefs.js

@@ -0,0 +1,82 @@
+/**
+ * File reference extractor for Python scripts.
+ *
+ * Detects:
+ * - import statements → via: "import"
+ * - from...import statements → via: "import"
+ * - open() calls with host FS paths → via: "bare-path"
+ * - URL string literals (requests.get, urllib, etc.) → via: "url"
+ *
+ * Uses ast-grep AST traversal.
+ */
+import { isHostFsPath, isUrl } from "../shared/file-refs.js";
+import { PYTHON_NODE } from "./astTypes.js";
+export function extractPythonFileRefs(context, content) {
+    const refs = [];
+    const ast = context.astgrepClient.parse("python", content);
+    const root = ast.root();
+    // ── import_statement (e.g. `import os`, `import os.path`) ───────────────
+    const importNodes = root.findAll({ rule: { kind: PYTHON_NODE.IMPORT_STATEMENT } });
+    for (const node of importNodes) {
+        const nameNode = node.find({ rule: { kind: PYTHON_NODE.DOTTED_NAME } });
+        const pkg = nameNode?.text() ?? "";
+        if (pkg) {
+            refs.push({ path: pkg, line: node.range().start.line + 1, via: "import" });
+        }
+    }
+    // ── import_from_statement (e.g. `from os.path import join`) ─────────────
+    const fromImportNodes = root.findAll({ rule: { kind: PYTHON_NODE.IMPORT_FROM_STATEMENT } });
+    for (const node of fromImportNodes) {
+        const moduleNode = node.field("module_name");
+        const pkg = moduleNode?.text() ?? "";
+        if (pkg) {
+            refs.push({ path: pkg, line: node.range().start.line + 1, via: "import" });
+        }
+    }
+    // ── open("path") ─────────────────────────────────────────────────────────
+    const openCallNodes = root.findAll({
+        rule: {
+            kind: PYTHON_NODE.CALL,
+            has: {
+                field: "function",
+                regex: "^open$",
+                stopBy: "neighbor",
+            },
+        },
+    });
+    for (const node of openCallNodes) {
+        const argsNode = node.field("arguments");
+        if (!argsNode)
+            continue;
+        // string → string_content (Python string has no string_fragment)
+        const strNode = argsNode.find({ rule: { kind: PYTHON_NODE.STRING } });
+        const contentNode = strNode?.find({ rule: { kind: PYTHON_NODE.STRING_CONTENT } });
+        const path = contentNode?.text() ?? "";
+        if (path && isHostFsPath(path)) {
+            refs.push({ path, line: node.range().start.line + 1, via: "bare-path" });
+        }
+    }
+    // ── requests.*/urllib.* URL calls ────────────────────────────────────────
+    const httpCallNodes = root.findAll({
+        rule: {
+            kind: PYTHON_NODE.CALL,
+            has: {
+                field: "function",
+                regex: "^(?:requests|urllib)",
+                stopBy: "neighbor",
+            },
+        },
+    });
+    for (const node of httpCallNodes) {
+        const argsNode = node.field("arguments");
+        if (!argsNode)
+            continue;
+        const strNode = argsNode.find({ rule: { kind: PYTHON_NODE.STRING } });
+        const contentNode = strNode?.find({ rule: { kind: PYTHON_NODE.STRING_CONTENT } });
+        const url = contentNode?.text() ?? "";
+        if (url && isUrl(url)) {
+            refs.push({ path: url, line: node.range().start.line + 1, via: "url" });
+        }
+    }
+    return refs;
+}

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

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"mod.d.ts","sourceRoot":"","sources":["../../../../src/analyzer/rules/python/mod.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,yBAAyB,CAAC;AAC3D,OAAO,EAAE,cAAc,EAAE,MAAM,gBAAgB,CAAC;AAKhD,eAAO,MAAM,YAAY,EAAE,WAAW,EAGrC,CAAC;AAEF,eAAO,MAAM,wBAAwB,EAAE,cAGtC,CAAC"}

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

@@ -0,0 +1,11 @@
+import { extractPythonFileRefs } from "./extractFileRefs.js";
+import { PYTHON_NETWORK_RULES } from "./network.js";
+import { PYTHON_SECRET_DETECTION_RULES } from "./secret-detection.js";
+export const PYTHON_RULES = [
+    ...PYTHON_NETWORK_RULES,
+    ...PYTHON_SECRET_DETECTION_RULES,
+];
+export const PYTHONG_FILETYPE_CONFIGS = {
+    defaultLanguage: "python",
+    extractFileRefs: extractPythonFileRefs,
+};

package/esm/analyzer/rules/python/network.d.ts

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

package/esm/analyzer/rules/python/network.d.ts.map

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

package/esm/analyzer/rules/python/network.js

@@ -0,0 +1,24 @@
+import { DETECT_NETWORK_FETCH_RISKS } from "../shared/network-evaluators.js";
+export const PYTHON_NETWORK_RULES = [
+    {
+        id: "net-requests",
+        description: "Detects Python requests usage",
+        grammar: "python",
+        patterns: [
+            "requests.get($URL)",
+            "requests.post($URL, data=$DATA)",
+            "requests.put($URL, data=$DATA)",
+            "requests.patch($URL, data=$DATA)",
+        ],
+        permission: {
+            tool: "requests",
+            scope: "net",
+            permission: "fetch",
+            metadata: {
+                url: "URL",
+                data: "DATA",
+            },
+            mappedRisks: [DETECT_NETWORK_FETCH_RISKS],
+        },
+    },
+];

package/esm/analyzer/rules/python/secret-detection.d.ts

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

package/esm/analyzer/rules/python/secret-detection.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"secret-detection.d.ts","sourceRoot":"","sources":["../../../../src/analyzer/rules/python/secret-detection.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,yBAAyB,CAAC;AAG3D,eAAO,MAAM,6BAA6B,EAAE,WAAW,EA0BtD,CAAC"}

package/esm/analyzer/rules/python/secret-detection.js

@@ -0,0 +1,28 @@
+import { DETECT_SECRET_NAME_RISK } from "../shared/secret-evaluators.js";
+export const PYTHON_SECRET_DETECTION_RULES = [
+    {
+        id: "secret-python-env-read",
+        description: "Detects Python env reads",
+        grammar: "python",
+        patterns: ["os.environ[$KEY]", "os.environ.get($KEY)", "os.getenv($KEY)"],
+        permission: {
+            tool: "env",
+            scope: "env",
+            permission: "read",
+            metadata: { key: "KEY" },
+            mappedRisks: [DETECT_SECRET_NAME_RISK],
+        },
+    },
+    {
+        id: "secret-python-env-write",
+        description: "Detects Python env writes",
+        grammar: "python",
+        patterns: ["os.environ[$KEY] = $VALUE"],
+        permission: {
+            tool: "env",
+            scope: "env",
+            permission: "write",
+            metadata: { key: "KEY" },
+        },
+    },
+];

package/esm/analyzer/rules/shared/file-refs.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Shared types and utilities for file reference discovery across all language extractors.
+ */
+/**
+ * Patterns that indicate the referenced path targets the host filesystem
+ * rather than the skill package itself.
+ */
+export declare const HOST_FS_PATTERNS: RegExp[];
+/** Returns true if the path targets the host filesystem. */
+export declare function isHostFsPath(path: string): boolean;
+/** Returns true if the string looks like a URL. */
+export declare function isUrl(value: string): boolean;
+/**
+ * Regex pattern for bare relative paths (e.g. references/guide.md, ./script.py).
+ * Used by markdown and text extractors for prose scanning.
+ */
+export declare const BARE_PATH_PATTERN: RegExp;
+/** Returns true if the value looks like a file path (not a command or word). */
+export declare function looksLikePath(value: string): boolean;
+//# sourceMappingURL=file-refs.d.ts.map

package/esm/analyzer/rules/shared/file-refs.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"file-refs.d.ts","sourceRoot":"","sources":["../../../../src/analyzer/rules/shared/file-refs.ts"],"names":[],"mappings":"AAAA;;GAEG;AAIH;;;GAGG;AACH,eAAO,MAAM,gBAAgB,EAAE,MAAM,EAIpC,CAAC;AAEF,4DAA4D;AAC5D,wBAAgB,YAAY,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAElD;AAED,mDAAmD;AACnD,wBAAgB,KAAK,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,CAE5C;AAED;;;GAGG;AACH,eAAO,MAAM,iBAAiB,QAAkC,CAAC;AAEjE,gFAAgF;AAChF,wBAAgB,aAAa,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,CAIpD"}