@doccident/doccident 0.0.3 → 0.0.4

package/README.md

@@ -1,17 +1,30 @@
 # doccident
 
 [![npm version](https://badge.fury.io/js/doccident.svg)](http://badge.fury.io/js/doccident)
+[![Doccident Tested](https://img.shields.io/badge/doccident-tested-brightgreen.svg)](README.md)
 
 **Test the code examples in your Markdown documentation.**
 
 ## Overview
 
-As an open source developer, few things are more frustrating for users than encountering broken examples in a README. `doccident` ensures your documentation remains accurate by treating your examples as testable code. It parses your Markdown files, extracts JavaScript and TypeScript code blocks, and executes them in a sandboxed environment to verify they run without errors.
+As an open source developer, few things are more frustrating for users than encountering broken examples in a README. `doccident` ensures your documentation remains accurate by treating your examples as testable code. It parses your Markdown files, extracts code blocks for multiple languages, and executes them in a sandboxed environment to verify they run without errors.
+
+**Supported Languages:**
+*   JavaScript (Node.js)
+*   TypeScript
+*   Python
+*   Shell (Bash, Sh, Zsh)
+*   Go
+*   Rust
+*   Fortran
+*   COBOL
+*   C
 
 > **Note**: `doccident` primarily verifies that your code *runs* without throwing exceptions. While you can add assertions to your examples to test correctness, its main goal is to ensure your documentation examples are valid and runnable.
 
 ## Installation
 
+<!-- skip-example -->
 ```bash
 npm install --save-dev @doccident/doccident
 ```
@@ -20,24 +33,41 @@ npm install --save-dev @doccident/doccident
 
 Run `doccident` in your project root. By default, it recursively checks all `.md` and `.markdown` files (excluding `node_modules`).
 
+<!-- skip-example -->
 ```bash
 npx doccident
 ```
 
 You can also target specific files or directories:
 
+<!-- skip-example -->
 ```bash
 npx doccident docs/**/*.md
 ```
 
 ### Language Support & Recipes
 
-`doccident` executes code inside `js`, `javascript`, `es6`, `ts`, or `typescript` fenced code blocks. It automatically transforms modern JavaScript and TypeScript using **esbuild** before execution.
+`doccident` executes code inside fenced code blocks for the following languages:
+
+*   **JavaScript**: `js`, `javascript`, `es6`
+*   **TypeScript**: `ts`, `typescript`
+*   **Python**: `py`, `python`
+*   **Shell**: `sh`, `bash`, `zsh`, `shell`
+*   **Go**: `go`
+*   **Rust**: `rust`, `rs`
+*   **Fortran**: `fortran`, `f90`, `f95`
+*   **COBOL**: `cobol`, `cob`
+*   **C**: `c`
+
+It automatically transforms modern JavaScript and TypeScript using **esbuild** before execution.
 
 #### JavaScript
 
 Use `js`, `javascript`, or `es6` for JavaScript examples.
 
+**Execution Model:**
+Runs directly in a Node.js `vm` sandbox.
+
 **Recipe:**
 
 1.  Use `js` fenced code blocks.
@@ -53,6 +83,9 @@ Use `js`, `javascript`, or `es6` for JavaScript examples.
 
 Use `ts` or `typescript` for TypeScript examples.
 
+**Execution Model:**
+Transpiled via `esbuild`, then runs in a Node.js `vm` sandbox.
+
 **Recipe:**
 
 1.  Use `ts` fenced code blocks.
@@ -69,6 +102,179 @@ Use `ts` or `typescript` for TypeScript examples.
     console.log(user.name);
     ```
 
+#### Python
+
+Use `py` or `python` for Python examples.
+
+**Prerequisites:**
+*   `python3` must be installed and available in your system path.
+    *   **macOS**: `brew install python`
+    *   **Ubuntu/Debian**: `sudo apt-get install python3`
+
+**Execution Model:**
+Spawns a `python3` subprocess with the code piped to stdin.
+
+**Recipe:**
+
+1.  Use `python` fenced code blocks.
+2.  Standard library imports work out of the box.
+3.  State can be shared between blocks using `<!-- share-code-between-examples -->`.
+
+    ```python
+    import json
+    data = {"key": "value"}
+    assert json.loads('{"key": "value"}') == data
+    ```
+
+#### Shell Scripts
+
+Use `sh`, `bash`, `zsh` or `shell` (defaults to bash) for shell examples.
+
+**Prerequisites:**
+*   The specified shell (`bash`, `sh`, or `zsh`) must be available in your system path.
+
+**Execution Model:**
+Spawns a subprocess using the specified shell, with the code piped to stdin.
+
+**Recipe:**
+
+1.  Use specific shell tags like `bash` or `zsh` if your script relies on shell-specific syntax.
+2.  Use `sh` for POSIX-compliant scripts.
+3.  State (variables) can be shared between blocks using `<!-- share-code-between-examples -->`.
+
+    ```bash
+    export MY_VAR="hello"
+    ```
+    
+    ```bash
+    if [ "$MY_VAR" != "hello" ]; then exit 1; fi
+    ```
+
+#### Go
+
+Use `go` for Go examples.
+
+**Prerequisites:**
+*   `go` must be installed and available in your system path.
+    *   **macOS**: `brew install go`
+    *   **Ubuntu/Debian**: `sudo apt-get install golang-go`
+
+**Execution Model:**
+Writes code to a temporary file and executes it via `go run`.
+
+**Recipe:**
+
+1.  Use `go` fenced code blocks.
+2.  You can provide a full program (including `package main`) OR a simple snippet.
+3.  Simple snippets (without `package main`) are automatically wrapped in a `main` function and include `import "fmt"`.
+4.  **Note**: `<!-- share-code-between-examples -->` is **not** supported for Go.
+
+    **Simple Snippet:**
+    ```go
+    fmt.Println("Hello Go")
+    ```
+
+#### Rust
+
+Use `rust` or `rs` for Rust examples.
+
+**Prerequisites:**
+*   `rustc` (Rust compiler) must be installed and available in your system path.
+    *   **macOS**: `brew install rust`
+    *   **Ubuntu/Debian**: `curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh` or `sudo apt-get install rustc`
+
+**Execution Model:**
+Compiles the code using `rustc` into a temporary binary, then executes the binary.
+
+**Recipe:**
+
+1.  Use `rust` fenced code blocks.
+2.  You can provide a full program (including `fn main()`) OR a simple snippet.
+3.  Simple snippets (without `fn main`) are automatically wrapped in a `main` function.
+4.  **Note**: `<!-- share-code-between-examples -->` is **not** supported for Rust.
+
+    **Simple Snippet:**
+    ```rust
+    println!("Hello Rust");
+    let x = 5;
+    assert_eq!(x, 5);
+    ```
+
+#### Fortran
+
+Use `fortran`, `f90`, or `f95` for Fortran examples.
+
+**Prerequisites:**
+*   `gfortran` must be installed and available in your system path.
+    *   **macOS**: `brew install gcc` (includes gfortran)
+    *   **Ubuntu/Debian**: `sudo apt-get install gfortran`
+
+**Execution Model:**
+Compiles the code using `gfortran` into a temporary binary, then executes the binary.
+
+**Recipe:**
+
+1.  Use `fortran` fenced code blocks.
+2.  You can provide a full program (starting with `program name`) OR a simple snippet.
+3.  Simple snippets are automatically wrapped in a `program main ... end program main` block.
+4.  **Note**: `<!-- share-code-between-examples -->` is **not** supported for Fortran.
+
+    **Simple Snippet:**
+    ```fortran
+    print *, "Hello Fortran"
+    ```
+
+#### COBOL
+
+Use `cobol` or `cob` for COBOL examples.
+
+**Prerequisites:**
+*   `cobc` (GnuCOBOL) must be installed and available in your system path.
+    *   **macOS**: `brew install gnucobol`
+    *   **Ubuntu/Debian**: `sudo apt-get install gnucobol`
+
+**Execution Model:**
+Compiles the code using `cobc -x -free` into a temporary executable, then runs it.
+
+**Recipe:**
+
+1.  Use `cobol` fenced code blocks.
+2.  Provide a full COBOL program (including `IDENTIFICATION DIVISION`).
+3.  The compiler is run in free-format mode (`-free`).
+4.  **Note**: `<!-- share-code-between-examples -->` is **not** supported for COBOL.
+
+    ```cobol
+    IDENTIFICATION DIVISION.
+    PROGRAM-ID. HELLO.
+    PROCEDURE DIVISION.
+    DISPLAY 'Hello COBOL'.
+    STOP RUN.
+    ```
+
+#### C
+
+Use `c` for C examples.
+
+**Prerequisites:**
+*   `gcc` must be installed and available in your system path.
+    *   **macOS**: `xcode-select --install` or `brew install gcc`
+    *   **Ubuntu/Debian**: `sudo apt-get install build-essential`
+
+**Execution Model:**
+Compiles the code using `gcc` into a temporary binary, then executes the binary.
+
+**Recipe:**
+
+1.  Use `c` fenced code blocks.
+2.  You can provide a full program (including `main()`) OR a simple snippet.
+3.  Simple snippets are automatically wrapped in a `main` function and include `stdio.h`.
+4.  **Note**: `<!-- share-code-between-examples -->` is **not** supported for C.
+
+    **Simple Snippet:**
+    ```c
+    printf("Hello C\n");
+    ```
+
 ### Skipping Examples
 
 To skip a specific code block, add the `<!-- skip-example -->` comment immediately before it:
@@ -79,6 +285,23 @@ To skip a specific code block, add the `<!-- skip-example -->` comment immediate
     fetch('https://example.com');
     ```
 
+### Sharing Code Between Examples
+
+By default, each code block is executed in isolation. To share state (variables, functions, classes) between multiple code blocks in the same file, add the `<!-- share-code-between-examples -->` comment. This applies to the entire file.
+
+> **Note**: This feature is currently supported for JavaScript, TypeScript, Python, and Shell, but **not** compiled languages like Go, Rust, Fortran, COBOL, and C.
+
+    <!-- share-code-between-examples -->
+
+    ```python
+    x = 10
+    ```
+
+    ```python
+    # x is still available here
+    assert x == 10
+    ```
+
 ## Configuration
 
 Create a `.doccident-setup.js` file in your project root to configure the test environment.
@@ -94,7 +317,7 @@ module.exports = {
     // Make 'my-library' available when examples call require('my-library')
     'my-library': require('./index.js'),
     'lodash': require('lodash')
-  }
+    }
 };
 ```
 
@@ -127,13 +350,14 @@ module.exports = {
     *   Reads Markdown content line-by-line.
     *   Uses a robust state machine to identify code fences and control comments (like `skip-example`).
     *   Extracts valid snippets into structured objects containing code, file paths, and line numbers.
-    *   **TypeScript Support**: Now recognizes `ts` and `typescript` blocks in addition to JS.
+    *   **Multi-Language Support**: Recognizes `js`, `ts`, `python`, `shell`, `go`, `rust`, `fortran`, `cobol`, and `c` blocks.
 
 2.  **Test Runner (`src/doctest.ts`)**
     *   The orchestrator of the application.
     *   Iterates through parsed snippets and manages the execution lifecycle.
-    *   **Sandboxing**: Uses Node.js's `vm` module (`runInNewContext`) to execute code in isolation. This prevents examples from polluting the global scope of the runner itself, while allowing controlled injection of dependencies via the configuration.
-    *   **Transformation**: Uses **esbuild** to compile modern JavaScript and TypeScript code down to a compatible format before execution. This ensures that modern syntax and type annotations run correctly in all environments, and is significantly faster than the previous Babel implementation.
+    *   **Sandboxing**: Uses Node.js's `vm` module (`runInNewContext`) to execute JS/TS code in isolation.
+    *   **Subprocess Execution**: Spawns `python3`, `go`, `rustc`, `gfortran`, `cobc`, `gcc`, or shell subprocesses for non-JS languages.
+    *   **Transformation**: Uses **esbuild** to compile modern JavaScript and TypeScript code down to a compatible format before execution.
 
 3.  **Reporter (`src/reporter.ts`)**
     *   Collects execution results (pass, fail, skip).

package/dist/doctest.js

@@ -6,13 +6,19 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.printResults = void 0;
 exports.runTests = runTests;
 const fs_1 = require("fs");
-const vm_1 = require("vm");
-const esbuild_1 = require("esbuild");
 const chalk_1 = __importDefault(require("chalk"));
 const utils_1 = require("./utils");
 const parse_code_snippets_from_markdown_1 = __importDefault(require("./parse-code-snippets-from-markdown"));
 const reporter_1 = require("./reporter");
 Object.defineProperty(exports, "printResults", { enumerable: true, get: function () { return reporter_1.printResults; } });
+const python_1 = require("./languages/python");
+const shell_1 = require("./languages/shell");
+const go_1 = require("./languages/go");
+const rust_1 = require("./languages/rust");
+const fortran_1 = require("./languages/fortran");
+const cobol_1 = require("./languages/cobol");
+const c_1 = require("./languages/c");
+const javascript_1 = require("./languages/javascript");
 function runTests(files, config) {
     const results = files
         .map(read)
@@ -78,25 +84,46 @@ function test(config, _filename, sandbox) {
             }
         }
         let perSnippetSandbox;
+        let activeSandbox;
+        let isSharedSandbox = false;
         if (sandbox === undefined) {
             perSnippetSandbox = makeTestSandbox(config);
+            activeSandbox = perSnippetSandbox;
+        }
+        else {
+            activeSandbox = sandbox;
+            isSharedSandbox = true;
         }
         if (config.beforeEach) {
             config.beforeEach();
         }
-        try {
-            const result = (0, esbuild_1.transformSync)(code, {
-                loader: 'ts',
-                format: 'cjs',
-                target: 'node12'
-            });
-            code = result.code || "";
-            (0, vm_1.runInNewContext)(code, perSnippetSandbox || sandbox);
-            success = true;
+        let result;
+        if (codeSnippet.language === 'python') {
+            result = (0, python_1.pythonHandler)(code, codeSnippet, config, activeSandbox, isSharedSandbox);
+        }
+        else if (['bash', 'sh', 'zsh'].includes(codeSnippet.language || '')) {
+            result = (0, shell_1.shellHandler)(code, codeSnippet, config, activeSandbox, isSharedSandbox);
+        }
+        else if (codeSnippet.language === 'go') {
+            result = (0, go_1.goHandler)(code, codeSnippet, config, activeSandbox, isSharedSandbox);
+        }
+        else if (codeSnippet.language === 'rust') {
+            result = (0, rust_1.rustHandler)(code, codeSnippet, config, activeSandbox, isSharedSandbox);
         }
-        catch (e) {
-            stack = e.stack || "";
+        else if (codeSnippet.language === 'fortran') {
+            result = (0, fortran_1.fortranHandler)(code, codeSnippet, config, activeSandbox, isSharedSandbox);
+        }
+        else if (codeSnippet.language === 'cobol') {
+            result = (0, cobol_1.cobolHandler)(code, codeSnippet, config, activeSandbox, isSharedSandbox);
+        }
+        else if (codeSnippet.language === 'c') {
+            result = (0, c_1.cHandler)(code, codeSnippet, config, activeSandbox, isSharedSandbox);
+        }
+        else {
+            result = (0, javascript_1.javascriptHandler)(code, codeSnippet, config, activeSandbox, isSharedSandbox);
         }
+        success = result.success;
+        stack = result.stack;
         const status = success ? "pass" : "fail";
         process.stdout.write(success ? chalk_1.default.green(".") : chalk_1.default.red("x"));
         return { status, codeSnippet, stack };

package/dist/languages/c.js

@@ -0,0 +1,58 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.cHandler = void 0;
+const child_process_1 = require("child_process");
+const fs_1 = require("fs");
+const path_1 = require("path");
+const os_1 = require("os");
+const cHandler = (code, _snippet, _config, _sandbox, _isSharedSandbox) => {
+    let success = false;
+    let stack = "";
+    // C execution logic
+    // Auto-wrap in main function if not present
+    let cCode = code;
+    if (!cCode.includes('main(')) {
+        cCode = `#include <stdio.h>
+ int main() {
+ ${cCode}
+ return 0;
+ }`;
+    }
+    const uniqueId = `${Date.now()}_${Math.random().toString(36).substring(7)}`;
+    const tempSourceFile = (0, path_1.join)((0, os_1.tmpdir)(), `doccident_c_${uniqueId}.c`);
+    const tempExeFile = (0, path_1.join)((0, os_1.tmpdir)(), `doccident_c_${uniqueId}`);
+    try {
+        (0, fs_1.writeFileSync)(tempSourceFile, cCode);
+        // Compile with gcc
+        const compileResult = (0, child_process_1.spawnSync)('gcc', [tempSourceFile, '-o', tempExeFile], { encoding: 'utf-8' });
+        if (compileResult.status !== 0) {
+            stack = compileResult.stderr || "C compilation failed";
+        }
+        else {
+            // Run
+            const runResult = (0, child_process_1.spawnSync)(tempExeFile, [], { encoding: 'utf-8' });
+            if (runResult.status === 0) {
+                success = true;
+            }
+            else {
+                stack = runResult.stderr || "C execution failed with non-zero exit code";
+            }
+        }
+    }
+    catch (e) {
+        stack = e.message || "Failed to execute gcc or run binary";
+    }
+    finally {
+        try {
+            if ((0, fs_1.existsSync)(tempSourceFile))
+                (0, fs_1.unlinkSync)(tempSourceFile);
+            if ((0, fs_1.existsSync)(tempExeFile))
+                (0, fs_1.unlinkSync)(tempExeFile);
+        }
+        catch {
+            // Ignore cleanup error
+        }
+    }
+    return { success, stack };
+};
+exports.cHandler = cHandler;

package/dist/languages/cobol.js

@@ -0,0 +1,50 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.cobolHandler = void 0;
+const child_process_1 = require("child_process");
+const fs_1 = require("fs");
+const path_1 = require("path");
+const os_1 = require("os");
+const cobolHandler = (code, _snippet, _config, _sandbox, _isSharedSandbox) => {
+    let success = false;
+    let stack = "";
+    // COBOL execution logic
+    // Use shorter filename as cobc has strict length limits
+    const uniqueId = Math.random().toString(36).substring(2, 10);
+    const tempSourceFile = (0, path_1.join)((0, os_1.tmpdir)(), `cob_${uniqueId}.cob`);
+    const tempExeFile = (0, path_1.join)((0, os_1.tmpdir)(), `cob_${uniqueId}`);
+    try {
+        (0, fs_1.writeFileSync)(tempSourceFile, code);
+        // Compile with cobc -x (executable) -free (free format)
+        const compileResult = (0, child_process_1.spawnSync)('cobc', ['-x', '-free', '-o', tempExeFile, tempSourceFile], { encoding: 'utf-8' });
+        if (compileResult.status !== 0) {
+            stack = compileResult.stderr || "COBOL compilation failed";
+        }
+        else {
+            // Run
+            const runResult = (0, child_process_1.spawnSync)(tempExeFile, [], { encoding: 'utf-8' });
+            if (runResult.status === 0) {
+                success = true;
+            }
+            else {
+                stack = runResult.stderr || "COBOL execution failed with non-zero exit code";
+            }
+        }
+    }
+    catch (e) {
+        stack = e.message || "Failed to execute cobc or run binary";
+    }
+    finally {
+        try {
+            if ((0, fs_1.existsSync)(tempSourceFile))
+                (0, fs_1.unlinkSync)(tempSourceFile);
+            if ((0, fs_1.existsSync)(tempExeFile))
+                (0, fs_1.unlinkSync)(tempExeFile);
+        }
+        catch {
+            // Ignore cleanup error
+        }
+    }
+    return { success, stack };
+};
+exports.cobolHandler = cobolHandler;

package/dist/languages/fortran.js

@@ -0,0 +1,56 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.fortranHandler = void 0;
+const child_process_1 = require("child_process");
+const fs_1 = require("fs");
+const path_1 = require("path");
+const os_1 = require("os");
+const fortranHandler = (code, _snippet, _config, _sandbox, _isSharedSandbox) => {
+    let success = false;
+    let stack = "";
+    // Fortran execution logic
+    // Auto-wrap if 'program' is missing
+    let fortranCode = code;
+    if (!fortranCode.toLowerCase().includes('program ')) {
+        fortranCode = `program main
+ ${fortranCode}
+ end program main`;
+    }
+    const uniqueId = `${Date.now()}_${Math.random().toString(36).substring(7)}`;
+    const tempSourceFile = (0, path_1.join)((0, os_1.tmpdir)(), `doccident_fortran_${uniqueId}.f90`);
+    const tempExeFile = (0, path_1.join)((0, os_1.tmpdir)(), `doccident_fortran_${uniqueId}`);
+    try {
+        (0, fs_1.writeFileSync)(tempSourceFile, fortranCode);
+        // Compile with gfortran
+        const compileResult = (0, child_process_1.spawnSync)('gfortran', [tempSourceFile, '-o', tempExeFile], { encoding: 'utf-8' });
+        if (compileResult.status !== 0) {
+            stack = compileResult.stderr || "Fortran compilation failed";
+        }
+        else {
+            // Run
+            const runResult = (0, child_process_1.spawnSync)(tempExeFile, [], { encoding: 'utf-8' });
+            if (runResult.status === 0) {
+                success = true;
+            }
+            else {
+                stack = runResult.stderr || "Fortran execution failed with non-zero exit code";
+            }
+        }
+    }
+    catch (e) {
+        stack = e.message || "Failed to execute gfortran or run binary";
+    }
+    finally {
+        try {
+            if ((0, fs_1.existsSync)(tempSourceFile))
+                (0, fs_1.unlinkSync)(tempSourceFile);
+            if ((0, fs_1.existsSync)(tempExeFile))
+                (0, fs_1.unlinkSync)(tempExeFile);
+        }
+        catch {
+            // Ignore cleanup error
+        }
+    }
+    return { success, stack };
+};
+exports.fortranHandler = fortranHandler;

package/dist/languages/go.js

@@ -0,0 +1,45 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.goHandler = void 0;
+const child_process_1 = require("child_process");
+const fs_1 = require("fs");
+const path_1 = require("path");
+const os_1 = require("os");
+const goHandler = (code, _snippet, _config, _sandbox, _isSharedSandbox) => {
+    let success = false;
+    let stack = "";
+    // No shared context for Go yet, as it's compiled and strict structure
+    // We support standalone files or body snippets wrapped in main
+    let goCode = code;
+    if (!goCode.includes('package main')) {
+        goCode = `package main
+import "fmt"
+func main() {
+${goCode}
+}`;
+    }
+    const tempFile = (0, path_1.join)((0, os_1.tmpdir)(), `doccident_go_${Date.now()}_${Math.random().toString(36).substring(7)}.go`);
+    try {
+        (0, fs_1.writeFileSync)(tempFile, goCode);
+        const result = (0, child_process_1.spawnSync)('go', ['run', tempFile], { encoding: 'utf-8' });
+        if (result.status === 0) {
+            success = true;
+        }
+        else {
+            stack = result.stderr || "Go execution failed with non-zero exit code";
+        }
+    }
+    catch (e) {
+        stack = e.message || "Failed to execute go run";
+    }
+    finally {
+        try {
+            (0, fs_1.unlinkSync)(tempFile);
+        }
+        catch {
+            // Ignore cleanup error
+        }
+    }
+    return { success, stack };
+};
+exports.goHandler = goHandler;

package/dist/languages/interface.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/languages/javascript.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.javascriptHandler = void 0;
+const vm_1 = require("vm");
+const esbuild_1 = require("esbuild");
+const javascriptHandler = (code, _snippet, _config, sandbox, _isSharedSandbox) => {
+    let success = false;
+    let stack = "";
+    try {
+        const result = (0, esbuild_1.transformSync)(code, {
+            loader: 'ts',
+            format: 'cjs',
+            target: 'node12'
+        });
+        const compiledCode = result.code || "";
+        (0, vm_1.runInNewContext)(compiledCode, sandbox);
+        success = true;
+    }
+    catch (e) {
+        stack = e.stack || "";
+    }
+    return { success, stack };
+};
+exports.javascriptHandler = javascriptHandler;

package/dist/languages/python.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.pythonHandler = void 0;
+const child_process_1 = require("child_process");
+const pythonHandler = (code, _snippet, _config, sandbox, isSharedSandbox) => {
+    let success = false;
+    let stack = "";
+    const context = sandbox;
+    // If sharing code, we need to accumulate previous python snippets
+    if (isSharedSandbox) {
+        if (!context._pythonContext) {
+            context._pythonContext = "";
+        }
+        context._pythonContext += code + "\n";
+        code = context._pythonContext;
+    }
+    try {
+        const result = (0, child_process_1.spawnSync)('python3', [], { input: code, encoding: 'utf-8' });
+        if (result.status === 0) {
+            success = true;
+        }
+        else {
+            stack = result.stderr || "Python execution failed with non-zero exit code";
+        }
+    }
+    catch (e) {
+        stack = e.message || "Failed to spawn python3";
+    }
+    return { success, stack };
+};
+exports.pythonHandler = pythonHandler;

package/dist/languages/rust.js

@@ -0,0 +1,56 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.rustHandler = void 0;
+const child_process_1 = require("child_process");
+const fs_1 = require("fs");
+const path_1 = require("path");
+const os_1 = require("os");
+const rustHandler = (code, _snippet, _config, _sandbox, _isSharedSandbox) => {
+    let success = false;
+    let stack = "";
+    // Rust execution logic
+    // Auto-wrap in main function if not present
+    let rustCode = code;
+    if (!rustCode.includes('fn main()')) {
+        rustCode = `fn main() {
+ ${rustCode}
+ }`;
+    }
+    const uniqueId = `${Date.now()}_${Math.random().toString(36).substring(7)}`;
+    const tempSourceFile = (0, path_1.join)((0, os_1.tmpdir)(), `doccident_rust_${uniqueId}.rs`);
+    const tempExeFile = (0, path_1.join)((0, os_1.tmpdir)(), `doccident_rust_${uniqueId}`);
+    try {
+        (0, fs_1.writeFileSync)(tempSourceFile, rustCode);
+        // Compile
+        const compileResult = (0, child_process_1.spawnSync)('rustc', [tempSourceFile, '-o', tempExeFile], { encoding: 'utf-8' });
+        if (compileResult.status !== 0) {
+            stack = compileResult.stderr || "Rust compilation failed";
+        }
+        else {
+            // Run
+            const runResult = (0, child_process_1.spawnSync)(tempExeFile, [], { encoding: 'utf-8' });
+            if (runResult.status === 0) {
+                success = true;
+            }
+            else {
+                stack = runResult.stderr || "Rust execution failed with non-zero exit code";
+            }
+        }
+    }
+    catch (e) {
+        stack = e.message || "Failed to execute rustc or run binary";
+    }
+    finally {
+        try {
+            if ((0, fs_1.existsSync)(tempSourceFile))
+                (0, fs_1.unlinkSync)(tempSourceFile);
+            if ((0, fs_1.existsSync)(tempExeFile))
+                (0, fs_1.unlinkSync)(tempExeFile);
+        }
+        catch {
+            // Ignore cleanup error
+        }
+    }
+    return { success, stack };
+};
+exports.rustHandler = rustHandler;

package/dist/languages/shell.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.shellHandler = void 0;
+const child_process_1 = require("child_process");
+const shellHandler = (code, snippet, _config, sandbox, isSharedSandbox) => {
+    let success = false;
+    let stack = "";
+    const context = sandbox;
+    const shell = snippet.language || 'bash';
+    // If sharing code, we need to accumulate previous shell snippets
+    if (isSharedSandbox) {
+        if (!context._shellContext) {
+            context._shellContext = {};
+        }
+        if (!context._shellContext[shell]) {
+            context._shellContext[shell] = "";
+        }
+        context._shellContext[shell] += code + "\n";
+        code = context._shellContext[shell];
+    }
+    try {
+        // Use the detected shell
+        const result = (0, child_process_1.spawnSync)(shell, ['-s'], { input: code, encoding: 'utf-8' });
+        if (result.status === 0) {
+            success = true;
+        }
+        else {
+            const exitCode = result.status !== null ? result.status : 'signal';
+            stack = result.stderr || result.stdout || `${shell} execution failed with non-zero exit code: ${exitCode}`;
+        }
+    }
+    catch (e) {
+        stack = e.message || `Failed to spawn ${shell}`;
+    }
+    return { success, stack };
+};
+exports.shellHandler = shellHandler;

package/dist/parse-code-snippets-from-markdown.js

@@ -1,15 +1,40 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-const isStartOfSnippet = (line) => line.trim().match(/```\W*(JavaScript|js|es6|ts|typescript)\s?$/i);
+// Capture indentation (group 1) and language (group 2)
+const START_REGEX = /^(\s*)```\W*(JavaScript|js|es6|ts|typescript|python|py|bash|sh|zsh|shell|go|rust|rs|fortran|f90|f95|cobol|cob|c)\s?$/i;
+const isStartOfSnippet = (line) => line.match(START_REGEX);
 const isEndOfSnippet = (line) => line.trim() === "```";
 const isSkip = (line) => line.trim() === "<!-- skip-example -->";
 const isCodeSharedInFile = (line) => line.trim() === "<!-- share-code-between-examples -->";
-function startNewSnippet(snippets, fileName, lineNumber) {
+function startNewSnippet(snippets, fileName, lineNumber, language, indentation) {
     const skip = snippets.skip;
     snippets.skip = false;
+    let normalizedLang = 'javascript';
+    const langLower = language.toLowerCase();
+    if (['python', 'py'].includes(langLower)) {
+        normalizedLang = 'python';
+    }
+    else if (['bash', 'sh', 'zsh', 'shell'].includes(langLower)) {
+        normalizedLang = langLower === 'shell' ? 'bash' : langLower;
+    }
+    else if (langLower === 'go') {
+        normalizedLang = 'go';
+    }
+    else if (['rust', 'rs'].includes(langLower)) {
+        normalizedLang = 'rust';
+    }
+    else if (['fortran', 'f90', 'f95'].includes(langLower)) {
+        normalizedLang = 'fortran';
+    }
+    else if (['cobol', 'cob'].includes(langLower)) {
+        normalizedLang = 'cobol';
+    }
+    else if (langLower === 'c') {
+        normalizedLang = 'c';
+    }
     return Object.assign(snippets, {
         snippets: snippets.snippets.concat([
-            { code: "", fileName, lineNumber, complete: false, skip: skip ?? false }
+            { code: "", language: normalizedLang, fileName, lineNumber, complete: false, skip: skip ?? false, indentation }
         ])
     });
 }
@@ -17,7 +42,11 @@ function addLineToLastSnippet(line) {
     return function addLine(snippets) {
         const lastSnippet = snippets.snippets[snippets.snippets.length - 1];
         if (lastSnippet && !lastSnippet.complete) {
-            lastSnippet.code += line + "\n";
+            let lineToAdd = line;
+            if (lastSnippet.indentation && line.startsWith(lastSnippet.indentation)) {
+                lineToAdd = line.slice(lastSnippet.indentation.length);
+            }
+            lastSnippet.code += lineToAdd + "\n";
         }
         return snippets;
     };
@@ -38,8 +67,10 @@ function shareCodeInFile(snippets) {
     return snippets;
 }
 function parseLine(line) {
-    if (isStartOfSnippet(line)) {
-        return startNewSnippet;
+    const startMatch = isStartOfSnippet(line);
+    if (startMatch) {
+        // startMatch[1] is indentation, startMatch[2] is language
+        return (snippets, fileName, lineNumber) => startNewSnippet(snippets, fileName, lineNumber, startMatch[2], startMatch[1]);
     }
     if (isEndOfSnippet(line)) {
         return endSnippet;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@doccident/doccident",
-  "version": "0.0.3",
+  "version": "0.0.4",
   "description": "Test all the code in your markdown docs!",
   "main": "dist/doctest.js",
   "files": [
@@ -14,7 +14,8 @@
     "build": "tsc",
     "lint": "eslint .",
     "test": "vitest run",
-    "precommit": "npm run lint && npm run test",
+    "test:readme": "node bin/cmd.js README.md",
+    "precommit": "npm run lint && npm run test && npm run test:readme",
     "clean": "rm -rf dist",
     "prepublishOnly": "npm run clean && npm run build"
   },