docling-project__docling-2983

The user is reporting a crash in `AsciiDocBackend._parse_picture()` when the image alt text contains commas.
The problem is specifically in `docling/backend/asciidoc_backend.py`.

Let's start by analyzing `docling/backend/asciidoc_backend.py` and searching for `_parse_picture`.

{
  "command": "grep -rn --include=\"*.py\" \"_parse_picture\" ."
}

{
  "status": "ok",
  "stdout": "./docling/backend/asciidoc_backend.py:204:                item = self._parse_picture(line)\n./docling/backend/asciidoc_backend.py:404:    def _parse_picture(line):\n./tests/test_backend_asciidoc.py:25:def test_parse_picture():\n./tests/test_backend_asciidoc.py:29:    res = AsciiDocBackend._parse_picture(line)\n./tests/test_backend_asciidoc.py:36:    res = AsciiDocBackend._parse_picture(line)\n",
  "stderr": "",
  "exit_code": 0
}

Okay, the method is in `docling/backend/asciidoc_backend.py` at line 404.
Let's examine the implementation of `_parse_picture` and its usage.

{
  "end_line": 450,
  "filepath": "docling/backend/asciidoc_backend.py",
  "start_line": 400
}

{
  "status": "ok",
  "filepath": "docling/backend/asciidoc_backend.py",
  "content": "    def _is_picture(line):\n        return re.match(r\"^image::\", line)\n\n    @staticmethod\n    def _parse_picture(line):\n        \"\"\"\n        Parse an image macro, extracting its path and attributes.\n        Syntax: image::path/to/image.png[Alt Text, width=200, height=150, align=center]\n        \"\"\"\n        mtch = re.match(r\"^image::(.+)\\[(.*)\\]$\", line)\n        if mtch:\n            picture_path = mtch.group(1).strip()\n            attributes = mtch.group(2).split(\",\")\n            picture_info = {\"type\": \"picture\", \"uri\": picture_path}\n\n            # Extract optional attributes (alt text, width, height, alignment)\n            if attributes:\n                picture_info[\"alt\"] = attributes[0].strip() if attributes[0] else \"\"\n                for attr in attributes[1:]:\n                    key, value = attr.split(\"=\")\n                    picture_info[key.strip()] = value.strip()\n\n            return picture_info\n\n        return {\"type\": \"picture\", \"uri\": line}\n\n    #   =========   Captions\n    @staticmethod\n    def _is_caption(line):\n        return re.match(r\"^\\.(.+)\", line)\n\n    @staticmethod\n    def _parse_caption(line):\n        mtch = re.match(r\"^\\.(.+)\", line)\n        if mtch:\n            text = mtch.group(1)\n            return {\"type\": \"caption\", \"text\": text}\n\n        return {\"type\": \"caption\", \"text\": \"\"}\n\n    #   =========   Plain text\n    @staticmethod\n    def _parse_text(line):\n        return {\"type\": \"text\", \"text\": line.strip()}",
  "start_line": 400,
  "end_line": 443,
  "total_lines": 443,
  "is_truncated": false
}

The bug is indeed here:
```python
            if attributes:
                picture_info["alt"] = attributes[0].strip() if attributes[0] else ""
                for attr in attributes[1:]:
                    key, value = attr.split("=")
                    picture_info[key.strip()] = value.strip()
```
If `attributes` contains more than one element, the code assumes all subsequent elements (after index 0) are `key=value` pairs.
If the alt text itself contains commas, `attributes[0]` will only be the first part of the alt text, and the subsequent parts of the alt text (which don't have `=`) will cause `attr.split("=")` to return a list of length 1, which fails when unpacking into `key, value`.

Actually, the problem description says:
`image::images/screenshot.png[A screenshot showing a dialog box, containing text fields, buttons, and validation errors, width=604, height=422]`

In this case:
`mtch.group(1)` is `images/screenshot.png`
`mtch.group(2)` is `A screenshot showing a dialog box, containing text fields, buttons, and validation errors, width=604, height=422`
`attributes` will be `['A screenshot showing a dialog box', ' containing text fields', ' buttons', ' and validation errors', ' width=604', ' height=422']`
Then:
`picture_info["alt"] = 'A screenshot showing a dialog box'`
Then for `attr` = `' containing text fields'`, `attr.split("=")` returns `[' containing text fields']`, and `key, value = [' containing text fields']` raises `ValueError: not enough values to unpack (expected 2, got 1)`.

The fix should be to only treat as attribute pairs those that actually contain `=`. Everything before the first `=` (excluding the first element if it's just alt text) might be part of the alt text, or more accurately, the alt text is the first "part" but if subsequent parts don't have `=`, they should probably be appended to the alt text.

Wait, AsciiDoc image macro syntax: `image::filename[,alttext][,width=X][,height=Y][,align=Z]`
The alt text is optional and is the first parameter.

If we have `[Alt text with commas, width=100]`, the `split(",")` approach is flawed if alt text contains commas.

Wait, are alt text commas allowed in AsciiDoc?
According to AsciiDoc documentation, the image macro attributes are comma-separated. If the alt text needs commas, it should probably be handled carefully. However, the issue says these are common in auto-generated exports.

If the alt text is the first argument, and other arguments are `key=value`, we can assume that any argument that doesn't contain `=` and is not the first argument should be part of the alt text? Or maybe we should join all initial arguments that don't have `=` into the alt text?

Let's re-read the example:
`image::images/screenshot.png[A screenshot showing a dialog box, containing text fields, buttons, and validation errors, width=604, height=422]`

Here, the alt text is `A screenshot showing a dialog box, containing text fields, buttons, and validation errors`.
The attributes are `width=604` and `height=422`.

So the logic should be:
1. Split by comma.
2. The first element is always treated as alt text (if it exists).
3. For subsequent elements:
   - If it contains `=`, it's a key-value pair.
   - If it doesn't contain `=`, it's part of the alt text.

Wait, if it's part of the alt text, we should probably append it to the alt text with a comma.

Let's refine this:
Initialize `alt_text` as `attributes[0]` (if attributes exist).
For `attr` in `attributes[1:]`:
  if `=` in `attr`:
    split and add to `picture_info`
  else:
    append `, ` + `attr.strip()` to `alt_text`.

Wait, if `attributes[0]` was already used as alt text, then subsequent comma-separated parts that are not `key=value` should be joined back to it.

Example: `[Alt, text, width=100]`
`attributes` = `['Alt', ' text', ' width=100']`
1. `alt` = 'Alt'
2. `attr` = ' text'. No `=`. `alt` = 'Alt, text'
3. `attr` = ' width=100'. Has `=`. `width` = '100'.

Example: `[width=100, height=200]`
`attributes` = `['width=100', ' height=200']`
1. `alt` = 'width=100'  <-- This is WRONG. If the first element contains `=`, it's not alt text, it's an attribute.

So:
1. The alt text is any initial contiguous sequence of comma-separated parts that do NOT contain `=`.
2. Once we hit a part that contains `=`, all subsequent parts are treated as `key=value` pairs? Not necessarily, maybe there's a value that contains a comma? But typically AsciiDoc attributes are `key=value`.

Actually, in AsciiDoc, the alt text is the *first* optional attribute. If it's omitted, the first attribute will be the first `key=value` pair.

Correct logic for AsciiDoc image macro:
- The first argument (if it doesn't contain `=`) is the alt text.
- Any subsequent arguments that don't contain `=` are also part of the alt text IF they appear before any `key=value` pair?
- Actually, looking at how other AsciiDoc parsers work, the alt text is simply the first argument. If it contains commas, it's problematic unless quoted, but the user says they have this issue with auto-generated content.

If we want to be robust:
The attributes are `[attr1, attr2, ...]`.
One of them (the first one, potentially) is the alt text if it doesn't have `=`.
But if the first one DOES have `=`, then there is no alt text.
Wait, if the first one has `=`, then everything after it should also be `key=value`?

Let's see: `[width=100, alt=something]` - here `width` is first.
`[Alt text, width=100]` - here `Alt text` is first.

What if the alt text contains `=`? That's unlikely for alt text.

So a better approach:
1. Split by `,`.
2. Iterate through the parts.
3. The first part that doesn't have `=` is NOT necessarily the alt text if it comes after a part that HAS `=`.
Actually, the specification says the alt text is the first optional attribute.

If we have `[Part1, Part2, Part3, key1=val1, key2=val2]`, and Part1, Part2, Part3 don't have `=`, then they should all be part of the alt text.

Let's try this:
```python
            attributes = mtch.group(2).split(",")
            picture_info = {"type": "picture", "uri": picture_path}
            
            alt_parts = []
            for attr in attributes:
                attr = attr.strip()
                if not attr:
                    continue
                if "=" in attr:
                    key, value = attr.split("=", 1)
                    picture_info[key.strip()] = value.strip()
                else:
                    alt_parts.append(attr)
            
            if alt_parts:
                picture_info["alt"] = ", ".join(alt_parts)
            else:
                picture_info["alt"] = ""
```
Wait, if I have `[Part1, key1=val1, Part2]`, then `Part1` and `Part2` would both become part of the alt text. Is that correct?
Probably not. Usually, once you start attributes, you don't go back to alt text.
But the alt text must be at the beginning.

Let's refine:
```python
            attributes = mtch.group(2).split(",")
            picture_info = {"type": "picture", "uri": picture_path}
            
            alt_text_parts = []
            first_kv_index = -1
            
            for i, attr in enumerate(attributes):
                if "=" in attr:
                    first_kv_index = i
                    break
            
            if first_kv_index == -1:
                # No KV pairs, everything is alt text
                alt_text = ", ".join([a.strip() for a in attributes])
                picture_info["alt"] = alt_text.strip()
            else:
                # Everything before first_kv_index is alt text
                alt_text = ", ".join([a.strip() for a in attributes[:first_kv_index]])
                picture_info["alt"] = alt_text.strip()
                
                # Everything from first_kv_index onwards are KV pairs
                for attr in attributes[first_kv_index:]:
                    if "=" in attr:
                        key, value = attr.split("=", 1)
                        picture_info[key.strip()] = value.strip()
                    else:
                        # This is a weird case: something without '=' after a KV pair
                        # We can either ignore it or add it to alt text. 
                        # Given the bug report, it's probably part of alt text.
                        # But let's see.
                        pass
```

Wait, if the alt text is `A screenshot showing a dialog box, containing text fields, buttons, and validation errors`, then:
`attributes` = `['A screenshot showing a dialog box', ' containing text fields', ' buttons', ' and validation errors', ' width=604', ' height=422']`
`first_kv_index` = 4 (for ` width=604`)
`alt_text` = `, ".join(['A screenshot showing a dialog box', 'containing text fields', 'buttons', 'and validation errors'])`
`alt_text` = `A screenshot showing a dialog box, containing text fields, buttons, and validation errors`
Then it processes ` width=604` and ` height=422`.
This looks correct and matches the reproduction case.

What if `[width=604, height=422]`?
`first_kv_index` = 0
`alt_text` = `, ".join([])` = `""`
`picture_info["alt"]` = `""`
Then it processes `width=604` and `height=422`.
Correct.

What if `[A screenshot, width=604]`?
`first_kv_index` = 1
`alt_text` = `, ".join(['A screenshot'])` = `A screenshot`
Then it processes `width=604`.
Correct.

One detail: `attr.split("=", 1)` is safer than `attr.split("=")` in case the value contains `=`.

Wait, if the `attributes` string is empty: `[]`
`mtch.group(2)` will be `""`.
`"".split(",")` is `['']`.
`first_kv_index` will be -1.
`alt_text` will be `", ".join([''])` which is `""`.
`picture_info["alt"]` will be `""`.
Correct.

Now let's see if there are other places where this logic is used. `_parse_picture` is the only place here.

Let's create a reproduction script to confirm the bug and the fix.

{
  "content": "from docling.document_converter import DocumentConverter\nfrom docling.datamodel.base_models import InputFormat\nfrom pathlib import Path\nimport tempfile\n\n# Minimal .adoc file with commas in alt text\ncontent = \"\"\"= Test Document\n\nimage::images/screenshot.png[A screenshot showing a dialog box, containing text fields, buttons, and validation errors, width=604, height=422]\n  \"\"\"\n\nwith tempfile.NamedTemporaryFile(suffix=\".adoc\", mode=\"w\", delete=False) as f:\n    f.write(content)\n    tmp_path = Path(f.name)\n\ntry:\n    converter = DocumentConverter(allowed_formats=[InputFormat.ASCIIDOC])\n    result = list(converter.convert_all(source=[tmp_path], raises_on_error=False))\n    print(f\"Status: {result[0].status}\")\n    print(f\"Errors: {result[0].errors}\")\nexcept Exception as e:\n    print(f\"Exception: {e}\")\nfinally:\n    tmp_path.unlink()\n",
  "filepath": "/tmp/repro.py"
}

{
  "status": "error",
  "error_type": "FileWriteError",
  "error_message": "Path traversal detected: '/tmp/repro.py' escapes workspace root."
}

Ah, I cannot write to `/tmp/repro.py` using `write_file` if it's outside `/workspace`. Wait, the instructions said: "Never leave reproduction or scratch files inside /workspace — run reproductions inline via `python3 - <<'PY'` or inside `/tmp/repro.py` in a single `run_command`."

So I should use `run_command` to run it.

{
  "command": "python3 - <<'PY'\nfrom docling.document_converter import DocumentConverter\nfrom docling.datamodel.base_models import InputFormat\nfrom pathlib import Path\nimport tempfile\nimport os\n\n# Minimal .adoc file with commas in alt text\ncontent = \"\"\"= Test Document\n\nimage::images/screenshot.png[A screenshot showing a dialog box, containing text fields, buttons, and validation errors, width=604, height=422]\n  \"\"\"\n\nwith tempfile.NamedTemporaryFile(suffix=\".adoc\", mode=\"w\", delete=False) as f:\n    f.write(content)\n    tmp_path = Path(f.name)\n\ntry:\n    converter = DocumentConverter(allowed_formats=[InputFormat.ASCIIDOC])\n    result = list(converter.convert_all(source=[tmp_path], raises_on_error=False))\n    print(f\"Status: {result[0].status}\")\n    print(f\"Errors: {result[0].errors}\")\nexcept Exception as e:\n    print(f\"Exception: {e}\")\nfinally:\n    if tmp_path.exists():\n        tmp_path.unlink()\nPY\n"
}

{
  "status": "ok",
  "stdout": "Status: failure\nErrors: [ErrorItem(component_type=<DoclingComponentType.PIPELINE: 'pipeline'>, module_name='SimplePipeline', error_message='not enough values to unpack (expected 2, got 1)')]\n",
  "stderr": "",
  "exit_code": 0
}

Confirmed. The status is `failure` and the error message is `not enough values to unpack (expected 2, got 1)`.

Now let's apply the fix to `docling/backend/asciidoc_backend.py`.

I'll use the logic:
1. Find the first attribute that contains `=`.
2. Everything before it is part of the alt text.
3. Everything from it onwards are key-value pairs.

Let's refine the implementation to be minimal.

Current code:
```python
            if attributes:
                picture_info["alt"] = attributes[0].strip() if attributes[0] else ""
                for attr in attributes[1:]:
                    key, value = attr.split("=")
                    picture_info[key.strip()] = value.strip()
```

Proposed new code:
```python
            if attributes:
                first_kv_index = next((i for i, attr in enumerate(attributes) if "=" in attr), None)
                if first_kv_index is None:
                    picture_info["alt"] = ", ".join([a.strip() for a in attributes]).strip()
                else:
                    picture_info["alt"] = ", ".join([a.strip() for a in attributes[:first_kv_index]]).strip()
                    for attr in attributes[first_kv_index:]:
                        if "=" in attr:
                            key, value = attr.split("=", 1)
                            picture_info[key.strip()] = value.strip()
```

Wait, if `attributes[0]` is `""` (empty brackets `[]`), then `attributes` is `['']`.
`first_kv_index` will be `None`.
`picture_info["alt"]` will be `", ".join(['']).strip()` which is `""`.
Correct.

If `attributes` is `['A', 'B', 'width=100']`:
`first_kv_index` = 2.
`picture_info["alt"]` = `", ".join(['A', 'B']).strip()` = `"A, B"`.
`attr` = `'width=100'`, `key`='width', `value`='100'.
Correct.

If `attributes` is `['width=100', 'height=200']`:
`first_kv_index` = 0.
`picture_info["alt"]` = `", ".join([]).strip()` = `""`.
`attr`='width=100' -> width=100
`attr`='height=200' -> height=200
Correct.

Let's apply the edit.

{
  "filepath": "docling/backend/asciidoc_backend.py",
  "new_string": "            # Extract optional attributes (alt text, width, height, alignment)\n            if attributes:\n                first_kv_index = next((i for i, attr in enumerate(attributes) if \"=\" in attr), None)\n                if first_kv_index is None:\n                    picture_info[\"alt\"] = \", \".join([a.strip() for a in attributes]).strip()\n                else:\n                    picture_info[\"alt\"] = \", \".join([a.strip() for a in attributes[:first_kv_index]]).strip()\n                    for attr in attributes[first_kv_index:]:\n                        if \"=\" in attr:\n                            key, value = attr.split(\"=\", 1)\n                            picture_info[key.strip()] = value.strip()\n",
  "old_string": "            # Extract optional attributes (alt text, width, height, alignment)\n            if attributes:\n                picture_info[\"alt\"] = attributes[0].strip() if attributes[0] else \"\"\n                for attr in attributes[1:]:\n                    key, value = attr.split(\"=\")\n                    picture_info[key.strip()] = value.strip()\n"
}

{
  "status": "ok",
  "filepath": "docling/backend/asciidoc_backend.py",
  "occurrences": 1,
  "strategy": "exact",
  "diff": "--- a/docling/backend/asciidoc_backend.py\n+++ b/docling/backend/asciidoc_backend.py\n@@ -414,10 +414,15 @@\n \n             # Extract optional attributes (alt text, width, height, alignment)\n             if attributes:\n-                picture_info[\"alt\"] = attributes[0].strip() if attributes[0] else \"\"\n-                for attr in attributes[1:]:\n-                    key, value = attr.split(\"=\")\n-                    picture_info[key.strip()] = value.strip()\n+                first_kv_index = next((i for i, attr in enumerate(attributes) if \"=\" in attr), None)\n+                if first_kv_index is None:\n+                    picture_info[\"alt\"] = \", \".join([a.strip() for a in attributes]).strip()\n+                else:\n+                    picture_info[\"alt\"] = \", \".join([a.strip() for a in attributes[:first_kv_index]]).strip()\n+                    for attr in attributes[first_kv_index:]:\n+                        if \"=\" in attr:\n+                            key, value = attr.split(\"=\", 1)\n+                            picture_info[key.strip()] = value.strip()\n \n             return picture_info\n \n",
  "is_truncated": false
}

Now let's run the reproduction script again to verify the fix.

{
  "command": "python3 - <<'PY'\nfrom docling.document_converter import DocumentConverter\nfrom docling.datamodel.base_models import InputFormat\nfrom pathlib import Path\nimport tempfile\nimport os\n\n# Minimal .adoc file with commas in alt text\ncontent = \"\"\"= Test Document\n\nimage::images/screenshot.png[A screenshot showing a dialog box, containing text fields, buttons, and validation errors, width=604, height=422]\n  \"\"\"\n\nwith tempfile.NamedTemporaryFile(suffix=\".adoc\", mode=\"w\", delete=False) as f:\n    f.write(content)\n    tmp_path = Path(f.name)\n\ntry:\n    converter = DocumentConverter(allowed_formats=[InputFormat.ASCIIDOC])\n    result = list(converter.convert_all(source=[tmp_path], raises_on_error=False))\n    print(f\"Status: {result[0].status}\")\n    print(f\"Errors: {result[0].errors}\")\nexcept Exception as e:\n    print(f\"Exception: {e}\")\nfinally:\n    if tmp_path.exists():\n        tmp_path.unlink()\nPY\n"
}

{
  "status": "ok",
  "stdout": "Status: success\nErrors: []\n",
  "stderr": "",
  "exit_code": 0
}

Great! The reproduction case now passes (Status: success, Errors: []).

Now I should also check if this broke any existing tests.
The `tests/test_backend_asciidoc.py` file has `test_parse_picture`. Let's run it.

{
  "command": "pytest tests/test_backend_asciidoc.py -k test_parse_picture -q --tb=short --no-header"
}

{
  "status": "ok",
  "stdout": ".                                                                        [100%]\n1 passed, 1 deselected in 2.20s\n",
  "stderr": "",
  "exit_code": 0
}

The tests passed. But I only ran one test. Let's run all tests in `tests/test_backend_asciidoc.py` just to be sure.

{
  "command": "pytest tests/test_backend_asciidoc.py -q --tb=short --no-header"
}

{
  "status": "ok",
  "stdout": "..                                                                       [100%]\n2 passed in 2.07s\n",
  "stderr": "",
  "exit_code": 0
}

All tests in `tests/test_backend_asciidoc.py` passed.

Let's consider some edge cases.
1. Empty brackets: `image::path.png[]`
2. Only alt text: `image::path.png[Some alt text]`
3. Only attributes: `image::path.png[width=100, height=200]`
4. Alt text with no attributes but with commas: `image::path.png[Alt, text, with, commas]`
5. Mixed with commas in alt text and attributes: `image::path.png[Alt, text, width=100]`
6. Empty path or strange path: `image::[Alt]` (The regex handles this: `^image::(.+)\\[(.*)\\]$`, so it would probably not match and fall back to the basic return).

Let's verify these with a small script.

{
  "command": "python3 - <<'PY'\nfrom docling.backend.asciidoc_backend import AsciiDocBackend\nimport json\n\ntest_cases = [\n    (\"image::path.png[]\", {\"type\": \"picture\", \"uri\": \"path.png\", \"alt\": \"\"}),\n    (\"image::path.png[Some alt text]\", {\"type\": \"picture\", \"uri\": \"path.png\", \"alt\": \"Some alt text\"}),\n    (\"image::path.png[width=100, height=200]\", {\"type\": \"picture\", \"uri\": \"path.png\", \"alt\": \"\", \"width\": \"100\", \"height\": \"200\"}),\n    (\"image::path.png[Alt, text, with, commas]\", {\"type\": \"picture\", \"uri\": \"path.png\", \"alt\": \"Alt, text, with, commas\"}),\n    (\"image::path.png[Alt, text, width=100]\", {\"type\": \"picture\", \"uri\": \"path.png\", \"alt\": \"Alt, text\", \"width\": \"100\"}),\n]\n\nfor line, expected in test_cases:\n    result = AsciiDocBackend._parse_picture(line)\n    print(f\"Input: {line}\")\n    print(f\"Result: {result}\")\n    print(f\"Expected: {expected}\")\n    assert result == expected\n    print(\"---\")\nPY\n"
}

{
  "status": "ok",
  "stdout": "Input: image::path.png[]\nResult: {'type': 'picture', 'uri': 'path.png', 'alt': ''}\nExpected: {'type': 'picture', 'uri': 'path.png', 'alt': ''}\n---\nInput: image::path.png[Some alt text]\nResult: {'type': 'picture', 'uri': 'path.png', 'alt': 'Some alt text'}\nExpected: {'type': 'picture', 'uri': 'path.png', 'alt': 'Some alt text'}\n---\nInput: image::path.png[width=100, height=200]\nResult: {'type': 'picture', 'uri': 'path.png', 'alt': '', 'width': '100', 'height': '200'}\nExpected: {'type': 'picture', 'uri': 'path.png', 'alt': '', 'width': '100', 'height': '200'}\n---\nInput: image::path.png[Alt, text, with, commas]\nResult: {'type': 'picture', 'uri': 'path.png', 'alt': 'Alt, text, with, commas'}\nExpected: {'type': 'picture', 'uri': 'path.png', 'alt': 'Alt, text, with, commas'}\n---\nInput: image::path.png[Alt, text, width=100]\nResult: {'type': 'picture', 'uri': 'path.png', 'alt': 'Alt, text', 'width': '100'}\nExpected: {'type': 'picture', 'uri': 'path.png', 'alt': 'Alt, text', 'width': '100'}\n---\n",
  "stderr": "",
  "exit_code": 0
}

All edge cases pass.

One last check on the regex and split.
`mtch = re.match(r"^image::(.+)\\[(.*)\\]$", line)`
If the line is `image::path.png[Alt Text]`, `mtch.group(1)` is `path.png` and `mtch.group(2)` is `Alt Text`.
If the line is `image::path.png`, it doesn't match and returns `{"type": "picture", "uri": line}`. This is correct.

Wait, if we have multiple sets of brackets? AsciiDoc doesn't typically do that for images.
What if there are spaces around `[`? The regex `r"^image::(.+)\\[(.*)\\]$"` is quite strict. It requires the line to end with `]`.

Wait, what if the alt text contains `]`?
Example: `image::path.png[Alt [text], width=100]`
`mtch.group(2)` would be `Alt [text], width=100` because `(.*)` is greedy and it would match up to the LAST `]`.
Wait, if the line is `image::path.png[Alt] some other text`, the regex won't match because of `$`.
If the line is `image::path.png[Alt]`, it matches.

Actually, the regex `r"^image::(.+)\\[(.*)\\]$"` might be too simple, but that's what was there before, and I should probably only fix the reported bug. The bug is about comma splitting.

One more check: `attr.split("=", 1)`
If `attr` is `width=100=200`, `key` will be `width` and `value` will be `100=200`. This is reasonable.

Final check of the diff and status.
No untracked files in `/workspace`.
Only one file modified.

{
  "command": "git status --short && git diff"
}

{
  "status": "ok",
  "stdout": " M docling/backend/asciidoc_backend.py\ndiff --git a/docling/backend/asciidoc_backend.py b/docling/backend/asciidoc_backend.py\nindex c6a0d18..1cc6cf9 100644\n--- a/docling/backend/asciidoc_backend.py\n+++ b/docling/backend/asciidoc_backend.py\n@@ -414,10 +414,15 @@ class AsciiDocBackend(DeclarativeDocumentBackend):\n \n             # Extract optional attributes (alt text, width, height, alignment)\n             if attributes:\n-                picture_info[\"alt\"] = attributes[0].strip() if attributes[0] else \"\"\n-                for attr in attributes[1:]:\n-                    key, value = attr.split(\"=\")\n-                    picture_info[key.strip()] = value.strip()\n+                first_kv_index = next((i for i, attr in enumerate(attributes) if \"=\" in attr), None)\n+                if first_kv_index is None:\n+                    picture_info[\"alt\"] = \", \".join([a.strip() for a in attributes]).strip()\n+                else:\n+                    picture_info[\"alt\"] = \", \".join([a.strip() for a in attributes[:first_kv_index]]).strip()\n+                    for attr in attributes[first_kv_index:]:\n+                        if \"=\" in attr:\n+                            key, value = attr.split(\"=\", 1)\n+                            picture_info[key.strip()] = value.strip()\n \n             return picture_info\n \n",
  "stderr": "",
  "exit_code": 0
}

Everything looks clean. Ready to submit.

{
  "status": "ok",
  "patch_size": 1274,
  "files_changed": 1
}

The fix addresses the `ValueError` when the alt text in an AsciiDoc `image::` macro contains commas by correctly identifying the boundary between the alt text and subsequent key-value attributes based on the presence of the `=` character.

The `AsciiDocBackend._parse_picture` method was failing when the image alt text contained commas because it mistakenly treated all comma-separated values after the first one as `key=value` pairs. I updated the parsing logic to identify the first attribute containing an `=` sign; all preceding parts are now correctly joined as alt text, and all subsequent parts are treated as attributes provided they contain an `=` sign.