@feiyoug/skill-lab 0.0.0 → 0.0.2

package/src/analyzer/rules/bash/commands/node.ts

@@ -0,0 +1,64 @@
+import type { AstGrepRule } from "../../../astgrep/client.js";
+
+export const NODE_ECOSYSTEM_RULES: AstGrepRule[] = [
+    {
+        id: "shell-npm",
+        description: "Detects npm commands",
+        grammar: "bash",
+        patterns: ["npm $SUB $$$ARGS"],
+        permission: {
+            tool: "npm",
+            scope: "sys",
+            permission: "shell",
+            metadata: { subcommand: "SUB" },
+        },
+    },
+    {
+        id: "shell-pnpm",
+        description: "Detects pnpm commands",
+        grammar: "bash",
+        patterns: ["pnpm $SUB $$$ARGS"],
+        permission: {
+            tool: "pnpm",
+            scope: "sys",
+            permission: "shell",
+            metadata: { subcommand: "SUB" },
+        },
+    },
+    {
+        id: "shell-yarn",
+        description: "Detects yarn commands",
+        grammar: "bash",
+        patterns: ["yarn $SUB $$$ARGS"],
+        permission: {
+            tool: "yarn",
+            scope: "sys",
+            permission: "shell",
+            metadata: { subcommand: "SUB" },
+        },
+    },
+    {
+        id: "shell-deno",
+        description: "Detects deno commands",
+        grammar: "bash",
+        patterns: ["deno $SUB $$$ARGS"],
+        permission: {
+            tool: "deno",
+            scope: "sys",
+            permission: "shell",
+            metadata: { subcommand: "SUB" },
+        },
+    },
+    {
+        id: "shell-node",
+        description: "Detects node commands",
+        grammar: "bash",
+        patterns: ["node $FILE $$$ARGS"],
+        permission: {
+            tool: "node",
+            scope: "sys",
+            permission: "shell",
+            metadata: { file: "FILE" },
+        },
+    },
+];

package/src/analyzer/rules/bash/commands/openspec.ts

@@ -0,0 +1,16 @@
+import type { AstGrepRule } from "../../../astgrep/client.js";
+
+export const OPENSPEC_RULES: AstGrepRule[] = [
+    {
+        id: "shell-openspec",
+        description: "Detects openspec commands",
+        grammar: "bash",
+        patterns: ["openspec $SUB $$$ARGS"],
+        permission: {
+            tool: "openspec",
+            scope: "sys",
+            permission: "shell",
+            metadata: { subcommand: "SUB" },
+        },
+    },
+];

package/src/analyzer/rules/bash/commands/pip.ts

@@ -0,0 +1,16 @@
+import type { AstGrepRule } from "../../../astgrep/client.js";
+
+export const PIP_RULES: AstGrepRule[] = [
+    {
+        id: "shell-pip",
+        description: "Detects pip commands",
+        grammar: "bash",
+        patterns: ["pip $SUB $$$ARGS", "pip3 $SUB $$$ARGS"],
+        permission: {
+            tool: "pip",
+            scope: "sys",
+            permission: "shell",
+            metadata: { subcommand: "SUB" },
+        },
+    },
+];

package/src/analyzer/rules/bash/commands/sudo.ts

@@ -0,0 +1,21 @@
+import type { AstGrepRule } from "../../../astgrep/client.js";
+
+export const SUDO_RULES: AstGrepRule[] = [
+    {
+        id: "shell-sudo",
+        description: "Detects sudo usage",
+        grammar: "bash",
+        patterns: ["sudo $CMD $$$ARGS"],
+        permission: {
+            tool: "sudo",
+            scope: "sys",
+            permission: "sudo",
+            metadata: { command: "CMD" },
+            mappedRisks: [{
+                code: "PRIVILEGE:privilege_escalation",
+                severity: "critical",
+                message: "Privilege escalation via sudo",
+            }],
+        },
+    },
+];

package/src/analyzer/rules/bash/destructive.ts

@@ -0,0 +1,28 @@
+import type { AstGrepRule } from "../../astgrep/client.js";
+
+export const BASH_DESTRUCTIVE_RULES: AstGrepRule[] = [
+    {
+        id: "destructive-format",
+        description: "Detects disk format commands",
+        grammar: "bash",
+        patterns: ["mkfs $DEVICE", "format $DEVICE"],
+        permission: {
+            tool: "format",
+            scope: "fs",
+            permission: "write",
+            metadata: { device: "DEVICE" },
+        },
+    },
+    {
+        id: "destructive-config-write",
+        description: "Detects config file overwrite",
+        grammar: "bash",
+        patterns: ["echo $VALUE > $FILE"],
+        permission: {
+            tool: "write",
+            scope: "fs",
+            permission: "write",
+            metadata: { file: "FILE" },
+        },
+    },
+];

package/src/analyzer/rules/bash/extractFileRefs.ts

@@ -0,0 +1,101 @@
+/**
+ * File reference extractor for Bash/shell scripts.
+ *
+ * Detects:
+ * - External URLs referenced via curl/wget → via: "url"
+ * - Local file includes via source/. → via: "source"
+ * - Host filesystem paths in command arguments → via: "bare-path"
+ *
+ * Uses ast-grep AST traversal on `command` nodes.
+ */
+
+import { isHostFsPath, isUrl, looksLikePath } from "../shared/file-refs.js";
+import type { AnalyzerContext, FileRefDiscovery } from "../../types.js";
+import { BASH_NODE } from "./astTypes.js";
+
+export async function extractBashFileRefs(
+    context: AnalyzerContext,
+    content: string,
+): Promise<FileRefDiscovery[]> {
+    const refs: FileRefDiscovery[] = [];
+
+    const ast = await context.astgrepClient.parse("bash", content);
+    const root = ast.root();
+
+    const commandNodes = root.findAll({ rule: { kind: BASH_NODE.COMMAND } });
+
+    for (const node of commandNodes) {
+        const line = node.range().start.line + 1;
+
+        const nameNode = node.field("name");
+        const commandName = nameNode?.text() ?? "";
+
+        // ── source / . includes ──────────────────────────────────────────────
+        if (commandName === "source" || commandName === ".") {
+            const argNode = node.field("argument");
+            const path = argNode?.text() ?? "";
+            if (path && looksLikePath(path)) {
+                refs.push({ path, line, via: "source" });
+            }
+            continue;
+        }
+
+        // ── curl / wget URLs ─────────────────────────────────────────────────
+        if (commandName === "curl" || commandName === "wget") {
+            // All word children — find URL args
+            const wordNodes = node.findAll({ rule: { kind: BASH_NODE.WORD } });
+            for (const word of wordNodes) {
+                const text = word.text();
+                if (isUrl(text)) {
+                    refs.push({ path: text, line, via: "url" });
+                }
+            }
+            continue;
+        }
+
+        // ── file operation commands ──────────────────────────────────────────
+        const FILE_CMDS = new Set([
+            "cat",
+            "cp",
+            "mv",
+            "ln",
+            "touch",
+            "mkdir",
+            "rm",
+            "chmod",
+            "chown",
+            "open",
+            "exec",
+            "read",
+        ]);
+
+        if (FILE_CMDS.has(commandName)) {
+            const wordNodes = node.findAll({ rule: { kind: BASH_NODE.WORD } });
+            for (const word of wordNodes) {
+                const text = word.text();
+                // Skip flags and the command name itself
+                if (text === commandName || text.startsWith("-")) continue;
+                if (isHostFsPath(text)) {
+                    refs.push({ path: text, line, via: "bare-path" });
+                }
+            }
+            continue;
+        }
+
+        // ── command itself is a script path (e.g. `scripts/run.py`) ─────────
+        if (looksLikePath(commandName) && !isUrl(commandName)) {
+            refs.push({ path: commandName, line, via: "bare-path" });
+        }
+
+        // ── default: check first argument for path-like value ────────────────
+        const argNode = node.field("argument");
+        if (argNode) {
+            const text = argNode.text();
+            if (looksLikePath(text) && !isUrl(text)) {
+                refs.push({ path: text, line, via: "bare-path" });
+            }
+        }
+    }
+
+    return refs;
+}

package/src/analyzer/rules/bash/filesystem.ts

@@ -0,0 +1,50 @@
+import type { AstGrepRule } from "../../astgrep/client.js";
+
+export const BASH_FILESYSTEM_RULES: AstGrepRule[] = [
+    {
+        id: "fs-read-cat",
+        description: "Detects cat file reads",
+        grammar: "bash",
+        patterns: ["cat $FILE", "less $FILE", "head $FILE", "tail $FILE"],
+        permission: {
+            tool: "cat",
+            scope: "fs",
+            permission: "read",
+            metadata: { file: "FILE" },
+        },
+    },
+    {
+        id: "fs-rm-rf",
+        description: "Detects recursive delete",
+        grammar: "bash",
+        patterns: ["rm -rf $PATH", "rm -fr $PATH"],
+        permission: {
+            tool: "rm",
+            scope: "fs",
+            permission: "write",
+            metadata: { path: "PATH" },
+            mappedRisks: [{
+                code: "DESTRUCTIVE:destructive_behavior",
+                severity: "critical",
+                message: "Recursive delete detected",
+            }],
+        },
+    },
+    {
+        id: "fs-chmod-777",
+        description: "Detects permissive chmod",
+        grammar: "bash",
+        patterns: ["chmod 777 $PATH", "chmod -R 777 $PATH"],
+        permission: {
+            tool: "chmod",
+            scope: "fs",
+            permission: "write",
+            metadata: { path: "PATH" },
+            mappedRisks: [{
+                code: "DESTRUCTIVE:permission_weakening",
+                severity: "warning",
+                message: "Overly permissive chmod detected",
+            }],
+        },
+    },
+];

package/src/analyzer/rules/bash/injection.ts

@@ -0,0 +1,21 @@
+import type { AstGrepRule } from "../../astgrep/client.js";
+
+export const BASH_INJECTION_RULES: AstGrepRule[] = [
+    {
+        id: "inject-substitution",
+        description: "Detects shell command substitution",
+        grammar: "bash",
+        patterns: ["$($CMD)", "`$CMD`"],
+        permission: {
+            tool: "bash",
+            scope: "sys",
+            permission: "shell",
+            metadata: { command: "CMD" },
+            mappedRisks: [{
+                code: "INJECTION:command_injection",
+                severity: "warning",
+                message: "Command substitution can enable injection",
+            }],
+        },
+    },
+];

package/src/analyzer/rules/bash/inline-command-classifier.ts

@@ -0,0 +1,94 @@
+import type { AnalyzerContext } from "../../types.js";
+import { looksLikePath } from "../shared/file-refs.js";
+import { BASH_COMMAND_RULES } from "./commands/mod.js";
+
+const GENERIC_COMMAND_RULE_ID = "shell-generic-command";
+
+const CONTEXT_VERB_PATTERN =
+    /\b(run|execute|invoke|call|terminal|shell|command|cmd|bash|zsh|sh)\b/i;
+
+const CONTEXT_COMMAND_ALLOWLIST = new Set([
+    "git",
+    "gh",
+    "npm",
+    "pnpm",
+    "yarn",
+    "bun",
+    "deno",
+    "node",
+    "python",
+    "python3",
+    "pip",
+    "pip3",
+    "docker",
+    "docker-compose",
+    "kubectl",
+    "curl",
+    "wget",
+    "bd",
+    "slab",
+    "bash",
+    "sh",
+    "zsh",
+]);
+
+const SPECIFIC_COMMAND_RULES = BASH_COMMAND_RULES.filter((rule) =>
+    rule.id !== GENERIC_COMMAND_RULE_ID
+);
+
+const KNOWN_COMMAND_TOOLS = new Set(
+    SPECIFIC_COMMAND_RULES
+        .map((rule) => String(rule.permission.tool ?? "").toLowerCase())
+        .filter((tool) => tool && tool !== "detected"),
+);
+
+export async function isLikelyInlineBashCommand(
+    context: AnalyzerContext,
+    input: { snippet: string; lineContext?: string },
+): Promise<boolean> {
+    const snippet = normalizeInlineSnippet(input.snippet);
+    if (!snippet) return false;
+    if (looksLikeFormattingToken(snippet)) return false;
+    const tokens = snippet.split(/\s+/).filter(Boolean);
+    if (tokens.length === 1 && looksLikePath(snippet)) return false;
+
+    if (await matchesSpecificBashCommandRule(context, snippet)) return true;
+
+    const firstToken = tokens[0]?.toLowerCase() ?? "";
+    const hasContextVerb = CONTEXT_VERB_PATTERN.test(input.lineContext ?? "");
+    const knownTool = firstToken &&
+        (CONTEXT_COMMAND_ALLOWLIST.has(firstToken) || KNOWN_COMMAND_TOOLS.has(firstToken));
+
+    if (tokens.length >= 2 && knownTool) {
+        return true;
+    }
+
+    if (tokens.length === 1 && knownTool && hasContextVerb) {
+        return true;
+    }
+
+    return false;
+}
+
+async function matchesSpecificBashCommandRule(
+    context: AnalyzerContext,
+    snippet: string,
+): Promise<boolean> {
+    const matches = await context.astgrepClient.scanWithRules(
+        snippet,
+        "bash",
+        SPECIFIC_COMMAND_RULES,
+    );
+    return matches.length > 0;
+}
+
+function normalizeInlineSnippet(raw: string): string {
+    return raw.trim().replace(/^`+/, "").replace(/`+$/, "").trim();
+}
+
+function looksLikeFormattingToken(snippet: string): boolean {
+    if (!snippet) return true;
+    if (/^[*]{1,2}[^*]+[*]{1,2}$/.test(snippet)) return true;
+    if (/^[A-Z][a-z]+(?:\s+[A-Z][a-z]+)*$/.test(snippet)) return true;
+    return false;
+}

package/src/analyzer/rules/bash/mod.ts

@@ -0,0 +1,23 @@
+import type { AstGrepRule } from "../../astgrep/client.js";
+import { FileTypeConfig } from "../../types.js";
+import { BASH_COMMAND_RULES } from "./commands/mod.js";
+import { BASH_DESTRUCTIVE_RULES } from "./destructive.js";
+import { extractBashFileRefs } from "./extractFileRefs.js";
+import { BASH_FILESYSTEM_RULES } from "./filesystem.js";
+import { BASH_INJECTION_RULES } from "./injection.js";
+import { BASH_NETWORK_RULES } from "./network.js";
+import { BASH_SECRET_DETECTION_RULES } from "./secret-detection.js";
+
+export const BASH_RULES: AstGrepRule[] = [
+    ...BASH_NETWORK_RULES,
+    ...BASH_FILESYSTEM_RULES,
+    ...BASH_COMMAND_RULES,
+    ...BASH_DESTRUCTIVE_RULES,
+    ...BASH_INJECTION_RULES,
+    ...BASH_SECRET_DETECTION_RULES,
+];
+
+export const BASH_FILETYPE_CONFIS: FileTypeConfig = {
+    defaultLanguage: "bash",
+    extractFileRefs: extractBashFileRefs,
+};

package/src/analyzer/rules/bash/network.ts

@@ -0,0 +1,64 @@
+import type { AstGrepRule } from "../../astgrep/client.js";
+import {
+    DETECT_NETWORK_FETCH_RISKS,
+    DETECT_REMOTE_CODE_EXECUTION_RISK,
+} from "../shared/network-evaluators.js";
+
+export const BASH_NETWORK_RULES: AstGrepRule[] = [
+    {
+        id: "net-curl",
+        description: "Detects curl usage",
+        grammar: "bash",
+        patterns: [
+            "curl $URL",
+            "curl -X $METHOD $URL",
+            "curl --request $METHOD $URL",
+            "curl $$$FLAGS -H $HEADER $$$REST",
+            "curl $$$FLAGS --header $HEADER $$$REST",
+            "curl $$$FLAGS $URL?token=$TOKEN",
+        ],
+        permission: {
+            tool: "curl",
+            scope: "net",
+            permission: "fetch",
+            metadata: {
+                method: "METHOD",
+                url: "URL",
+                header: "HEADER",
+                token: "TOKEN",
+            },
+            mappedRisks: [DETECT_NETWORK_FETCH_RISKS],
+        },
+    },
+    {
+        id: "net-wget",
+        description: "Detects wget usage",
+        grammar: "bash",
+        patterns: ["wget $URL", "wget --post-data=$DATA $URL"],
+        permission: {
+            tool: "wget",
+            scope: "net",
+            permission: "fetch",
+            metadata: {
+                url: "URL",
+                data: "DATA",
+            },
+            mappedRisks: [DETECT_NETWORK_FETCH_RISKS],
+        },
+    },
+    {
+        id: "net-pipe-shell",
+        description: "Detects network pipe to shell",
+        grammar: "bash",
+        patterns: ["curl $$$ARGS | bash", "curl $$$ARGS | sh", "wget $$$ARGS | bash"],
+        permission: {
+            tool: "bash",
+            scope: "sys",
+            permission: "shell",
+            metadata: {
+                command: "ARGS",
+            },
+            mappedRisks: [DETECT_REMOTE_CODE_EXECUTION_RISK],
+        },
+    },
+];

package/src/analyzer/rules/bash/secret-detection.ts

@@ -0,0 +1,43 @@
+import type { AstGrepRule } from "../../astgrep/client.js";
+import { DETECT_SECRET_NAME_RISK } from "../shared/secret-evaluators.js";
+
+export const BASH_SECRET_DETECTION_RULES: AstGrepRule[] = [
+    {
+        id: "secret-bash-env-read-plain",
+        description: "Detects bash env var read with $VAR",
+        grammar: "bash",
+        patterns: ["echo \\$$VAR", "printf \\$$VAR"],
+        permission: {
+            tool: "env",
+            scope: "env",
+            permission: "read",
+            metadata: { key: "VAR" },
+            mappedRisks: [DETECT_SECRET_NAME_RISK],
+        },
+    },
+    {
+        id: "secret-bash-env-read-braced",
+        description: "Detects bash env var read with ${VAR}",
+        grammar: "bash",
+        patterns: ["echo \\${$VAR}", "printf \\${$VAR}"],
+        permission: {
+            tool: "env",
+            scope: "env",
+            permission: "read",
+            metadata: { key: "VAR" },
+            mappedRisks: [DETECT_SECRET_NAME_RISK],
+        },
+    },
+    {
+        id: "secret-bash-env-write",
+        description: "Detects export env var write",
+        grammar: "bash",
+        patterns: ["export $KEY=$VALUE"],
+        permission: {
+            tool: "env",
+            scope: "env",
+            permission: "write",
+            metadata: { key: "KEY" },
+        },
+    },
+];

package/src/analyzer/rules/javascript/astTypes.ts

@@ -0,0 +1,8 @@
+/** ast-grep node types for JavaScript and TypeScript. */
+export const JS_NODE = {
+    IMPORT_STATEMENT: "import_statement",
+    EXPORT_STATEMENT: "export_statement",
+    CALL_EXPRESSION: "call_expression",
+    STRING: "string",
+    STRING_FRAGMENT: "string_fragment",
+} as const;