/// Supports both standard and indented code blocks (up to 3 spaces of

/// indentation).

pub fn new(content: &str) -> Self {

let mut code_lines: Vec<&str> = Vec::new();

let mut lang = String::new();

for line in &original_lines {

// Check if line is a code fence (with or without indentation)

if let Some(fence_lang) = Self::detect_code_fence(line) {

if !in_code {

// Opening fence

lang = fence_lang;

} else {

// Closing fence

blocks.push(CodeBlock { code: code_lines.join("\n"), lang: lang.clone() });

} else if in_code {

// Inside code block - collect lines

code_lines.push(line);

} else {

// Regular markdown line

result.push_str(line);

result.push('\n');

/// Detect if a line is a code fence marker (```).

/// Returns Some(language) if it's an opening fence with a language tag,

/// Some("") if it's a fence without a language tag (opening or closing),

/// None if it's not a code fence.

fn detect_code_fence(line: &str) -> Option<String> {

let trimmed = line.trim_start();

if let Some(stripped) = trimmed.strip_prefix("```") {

// Extract language tag (everything after ``` until whitespace or end)

let lang = stripped.split_whitespace().next().unwrap_or("");

Some(lang.to_string())

} else {

None

}

}

use pretty_assertions::assert_eq;

fn fixture_parser(name: &str) -> CodeBlockParser {

let content = match name {

"code-01" => include_str!("fixtures/code-01.md"),

"code-02" => include_str!("fixtures/code-02.md"),

_ => panic!("Unknown fixture: {}", name),

};

CodeBlockParser::new(content)

}

let fixture = "Hello world\nThis is plain text.";

let parser = CodeBlockParser::new(fixture);

let actual = parser.blocks().len();

let expected = 0;

assert_eq!(actual, expected);

let fixture = "```rust\nfn main() {}\n```";

let parser = CodeBlockParser::new(fixture);

let actual = parser.blocks().len();

let expected = 1;

assert_eq!(actual, expected);

assert_eq!(parser.blocks()[0].lang, "rust");

assert_eq!(parser.blocks()[0].code, "fn main() {}");

fn test_preserves_indentation_inside_code_block() {

let fixture = "```rust\n let x = 1;\n```";

let parser = CodeBlockParser::new(fixture);

let actual = &parser.blocks()[0].code;

let expected = " let x = 1;";

assert_eq!(actual, expected);

fn test_detects_indented_code_fence() {

let fixture = "1. Item\n\n ```rust\n code\n ```";

let parser = CodeBlockParser::new(fixture);

let actual = parser.blocks().len();

let expected = 1;

assert_eq!(actual, expected);

assert_eq!(parser.blocks()[0].lang, "rust");

fn test_multiple_languages() {

let fixture = "```rust\nrust code\n```\n\n```python\npython code\n```";

let parser = CodeBlockParser::new(fixture);

let actual = parser.blocks().len();

let expected = 2;

assert_eq!(actual, expected);

assert_eq!(parser.blocks()[0].lang, "rust");

assert_eq!(parser.blocks()[1].lang, "python");

}

#[test]

fn test_extracts_indented_code_blocks_from_fixture() {

let parser = fixture_parser("code-01");

let actual = parser.blocks().len();

let expected = 4;

assert_eq!(actual, expected);

}

#[test]

fn test_extracts_standard_code_blocks_from_fixture() {

let parser = fixture_parser("code-02");

let actual = parser.blocks().len();

let expected = 3;

assert_eq!(actual, expected);

}

#[test]

fn test_restore_replaces_placeholders_with_highlighted_code() {

let fixture = "```rust\ncode\n```";

let parser = CodeBlockParser::new(fixture);

let actual = strip_ansi(&parser.restore(&highlighter, parser.markdown().to_string()));

assert!(actual.contains("code"));

fn test_full_extraction_and_restoration_flow() {

let fixture = "Hi\n```rust\nlet x = 1;\n```\nBye";

let parser = CodeBlockParser::new(fixture);

let actual = strip_ansi(&parser.restore(&highlighter, parser.markdown().to_string()));

assert!(actual.contains("Hi"));

assert!(actual.contains("let x = 1"));

assert!(actual.contains("Bye"));

}

#[test]

fn test_highlighter_can_be_reused() {

let highlighter = SyntaxHighlighter::default();

let parser1 = CodeBlockParser::new("```rust\nlet x = 1;\n```");

let parser2 = CodeBlockParser::new("```python\nprint('hello')\n```");

let actual1 = strip_ansi(&parser1.restore(&highlighter, parser1.markdown().to_string()));

let actual2 = strip_ansi(&parser2.restore(&highlighter, parser2.markdown().to_string()));

assert!(actual1.contains("let x = 1"));

assert!(actual2.contains("print('hello')"));

Based on the codebase analysis, here's where permissions are checked before making a fetch request:

1. **Entry Point**: `crates/forge_app/src/tool_executor.rs:336`

```rust

if env.enable_permissions && self.check_tool_permission(&tool_input, context).await?

```

2. **Permission Check Method**: `crates/forge_app/src/tool_executor.rs:48-72`

- The `check_tool_permission()` method is called before executing any tool

- It converts the tool catalog to a policy operation

3. **Policy Operation Conversion**: `crates/forge_domain/src/tools/catalog.rs:680-684`

```rust

ToolCatalog::Fetch(input) => Some(crate::policies::PermissionOperation::Fetch {

url: input.url.clone(),

cwd,

message: format!("Fetch content from URL: {}", input.url),

})

```

4. **Permission Decision**: `crates/forge_services/src/policy.rs:163-208`

- The `check_operation_permission()` method evaluates the fetch operation against policies

- Uses `PolicyEngine::can_perform()` to check rules

5. **Rule Matching**: `crates/forge_domain/src/policies/rule.rs:88-96`

```rust

(Rule::Fetch(rule), PermissionOperation::Fetch { url, cwd, message: _ }) => {

let url_matches = match_pattern(&rule.url, url);

let dir_matches = match &rule.dir {

Some(wd_pattern) => match_pattern(wd_pattern, cwd),

None => true,

};

url_matches && dir_matches

}

```

6. **Actual Fetch Execution**: `crates/forge_app/src/tool_executor.rs:282-284`

- Only executed if permission is granted

```rust

ToolCatalog::Fetch(input) => {

let output = self.services.fetch(input.url.clone(), input.raw).await?;

(input, output).into()

}

```

- **Gating Condition**: Permissions are only checked if `env.enable_permissions` is true

- **Permission Denial**: If denied, returns a "Permission Denied" error without executing the fetch

- **Policy Types**: Can be `Allow`, `Deny`, or `Confirm` (prompts user)

- **Pattern Matching**: Fetch rules match against URL patterns (e.g., `"https://api.example.com/*"`)

- **User Confirmation**: If no policy matches, the user is prompted to Allow, Deny, or Remember the decision

The permission check is a **gating mechanism** that prevents the actual HTTP fetch from occurring unless explicitly allowed by the policy engine.