docling-project__docling-2983

The user is reporting a bug in `AsciiDocBackend._parse_picture()` where it crashes if the alt text in an `image::` macro contains commas.
The problem description gives a clear reproduction script.

First, I'll locate the `AsciiDocBackend._parse_picture` method. Based on the workspace layout, it should be in `docling/backend/asciidoc_backend.py`.

I'll start by reproducing the bug.

{
  "command": "python3 - <<'PY'\nfrom 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}\")\nfinally:\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
}

The bug is reproduced. Now I need to examine the code in `docling/backend/asciidoc_backend.py` to find `_parse_picture`.

{
  "filepath": "docling/backend/asciidoc_backend.py"
}

{
  "status": "ok",
  "filepath": "docling/backend/asciidoc_backend.py",
  "content": "import logging\nimport re\nfrom io import BytesIO\nfrom pathlib import Path\nfrom typing import Final, Union\n\nfrom docling_core.types.doc import (\n    DocItemLabel,\n    DoclingDocument,\n    DocumentOrigin,\n    GroupItem,\n    GroupLabel,\n    ImageRef,\n    Size,\n    TableCell,\n    TableData,\n)\n\nfrom docling.backend.abstract_backend import DeclarativeDocumentBackend\nfrom docling.datamodel.base_models import InputFormat\nfrom docling.datamodel.document import InputDocument\n\n_log = logging.getLogger(__name__)\n\nDEFAULT_IMAGE_WIDTH: Final = 128\nDEFAULT_IMAGE_HEIGHT: Final = 128\n\n\nclass AsciiDocBackend(DeclarativeDocumentBackend):\n    def __init__(self, in_doc: \"InputDocument\", path_or_stream: Union[BytesIO, Path]):\n        super().__init__(in_doc, path_or_stream)\n\n        self.path_or_stream = path_or_stream\n\n        try:\n            if isinstance(self.path_or_stream, BytesIO):\n                text_stream = self.path_or_stream.getvalue().decode(\"utf-8\")\n                self.lines = text_stream.split(\"\\n\")\n            if isinstance(self.path_or_stream, Path):\n                with open(self.path_or_stream, encoding=\"utf-8\") as f:\n                    self.lines = f.readlines()\n            self.valid = True\n\n        except Exception as e:\n            raise RuntimeError(\n                f\"Could not initialize AsciiDoc backend for file with hash {self.document_hash}.\"\n            ) from e\n        return\n\n    def is_valid(self) -> bool:\n        return self.valid\n\n    @classmethod\n    def supports_pagination(cls) -> bool:\n        return False\n\n    def unload(self):\n        return\n\n    @classmethod\n    def supported_formats(cls) -> set[InputFormat]:\n        return {InputFormat.ASCIIDOC}\n\n    def convert(self) -> DoclingDocument:\n        \"\"\"\n        Parses the ASCII into a structured document model.\n        \"\"\"\n\n        origin = DocumentOrigin(\n            filename=self.file.name or \"file\",\n            mimetype=\"text/asciidoc\",\n            binary_hash=self.document_hash,\n        )\n\n        doc = DoclingDocument(name=self.file.stem or \"file\", origin=origin)\n\n        doc = self._parse(doc)\n\n        return doc\n\n    def _parse(self, doc: DoclingDocument):\n        \"\"\"\n        Main function that orchestrates the parsing by yielding components:\n        title, section headers, text, lists, and tables.\n        \"\"\"\n\n        in_list = False\n        in_table = False\n\n        text_data: list[str] = []\n        table_data: list[str] = []\n        caption_data: list[str] = []\n\n        # parents: dict[int, Union[DocItem, GroupItem, None]] = {}\n        parents: dict[int, Union[GroupItem, None]] = {}\n        # indents: dict[int, Union[DocItem, GroupItem, None]] = {}\n        indents: dict[int, Union[GroupItem, None]] = {}\n\n        for i in range(10):\n            parents[i] = None\n            indents[i] = None\n\n        for line in self.lines:\n            # line = line.strip()\n\n            # Title\n            if self._is_title(line):\n                item = self._parse_title(line)\n                level = item[\"level\"]\n\n                parents[level] = doc.add_text(\n                    text=item[\"text\"], label=DocItemLabel.TITLE\n                )\n\n            # Section headers\n            elif self._is_section_header(line):\n                item = self._parse_section_header(line)\n                level = item[\"level\"]\n\n                parents[level] = doc.add_heading(\n                    text=item[\"text\"], level=item[\"level\"], parent=parents[level - 1]\n                )\n                for k, v in parents.items():\n                    if k > level:\n                        parents[k] = None\n\n            # Lists\n            elif self._is_list_item(line):\n                _log.debug(f\"line: {line}\")\n                item = self._parse_list_item(line)\n                _log.debug(f\"parsed list-item: {item}\")\n\n                level = self._get_current_level(parents)\n\n                if not in_list:\n                    in_list = True\n\n                    parents[level + 1] = doc.add_group(\n                        parent=parents[level], name=\"list\", label=GroupLabel.LIST\n                    )\n                    indents[level + 1] = item[\"indent\"]\n\n                elif in_list and item[\"indent\"] > indents[level]:\n                    parents[level + 1] = doc.add_group(\n                        parent=parents[level], name=\"list\", label=GroupLabel.LIST\n                    )\n                    indents[level + 1] = item[\"indent\"]\n\n                elif in_list and item[\"indent\"] < indents[level]:\n                    # print(item[\"indent\"], \" => \", indents[level])",
  "start_line": 1,
  "end_line": 150,
  "total_lines": 443,
  "is_truncated": true
}

I need to find `_parse_picture`. I'll search for it in the file.

{
  "command": "grep -n \"_parse_picture\" docling/backend/asciidoc_backend.py"
}

{
  "status": "ok",
  "stdout": "204:                item = self._parse_picture(line)\n404:    def _parse_picture(line):\n",
  "stderr": "",
  "exit_code": 0
}

Okay, it's around line 404. Let me read that part.

{
  "end_line": 443,
  "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 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[1:]` contains a string without `=`, `attr.split("=")` will return a list of length 1, and `key, value = ...` will fail with `ValueError: not enough values to unpack (expected 2, got 1)`.

This happens when the alt text (the first element of `attributes`) is consumed, but then subsequent commas in the alt text cause the rest of the alt text to be treated as separate attributes.

Wait, let's look at the AsciiDoc image macro syntax.
`image::path/to/image.png[Alt Text, width=200, height=150, align=center]`

The bracket content is `Alt Text, width=200, height=150, align=center`.
Splitting by `,`:
`['Alt Text', ' width=200', ' height=150', ' align=center']`

If alt text contains commas:
`image::images/screenshot.png[A screenshot showing a dialog box, containing text fields, buttons, and validation errors, width=604, height=422]`
Bracket content: `A screenshot showing a dialog box, containing text fields, buttons, and validation errors, width=604, height=422`
Splitting by `,`:
`['A screenshot showing a dialog box', ' containing text fields', ' buttons', ' and validation errors', ' width=604', ' height=422']`

`attributes[0]` is `A screenshot showing a dialog box`.
`attributes[1]` is ` containing text fields`. This doesn't have `=`. CRASH.

We need to correctly separate the alt text from the key-value attributes.
Since the alt text is always the first part and attributes are `key=value`, we can iterate through the split attributes and only treat them as key-value pairs if they contain `=`.

However, if the alt text can contain commas, the split by `,` is problematic for the alt text too. But wait, the alt text is the *first* thing in the brackets.

If we have `[Alt text with , commas, width=100]`, then:
`attributes[0]` = `Alt text with `
`attributes[1]` = ` commas`
`attributes[2]` = ` width=100`

Actually, the alt text is everything from the beginning up to the first `key=value` pair. Or more simply, any item that doesn't contain `=` and comes before any item that does contain `=` should be part of the alt text.

Wait, in AsciiDoc, the alt text is the first comma-separated value. If it contains commas, it's a bit ambiguous unless the other attributes are clearly `key=value`.

If the alt text contains commas, then the original code is splitting it into multiple parts.

Example: `[A screenshot showing a dialog box, containing text fields, buttons, and validation errors, width=604, height=422]`

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

A better way to parse this:
1. Split the bracket content by comma.
2. The first element is always part of the alt text.
3. For subsequent elements:
    - If it contains `=`, it's a key-value attribute.
    - If it doesn't contain `=`, it's continued alt text.

Wait, this assumes that no key-value attribute's value contains a comma (unlikely for width/height/align) and that the alt text doesn't start with something that looks like `key=value`.

Let's refine this:
We can collect all elements at the beginning that don't contain `=` and join them back into the alt text. Once we encounter an element with `=`, all subsequent elements that might be part of the alt text are unlikely (or should be handled differently).

Wait, what if the alt text itself contains something like `version=1`?
Actually, usually in AsciiDoc, the first element is the alt text. If it's empty, it's `[]` or `[, width=100]`.

Looking at the provided crash case:
`[A screenshot showing a dialog box, containing text fields, buttons, and validation errors, width=604, height=422]`

If we split by `,`:
`['A screenshot showing a dialog box', ' containing text fields', ' buttons', ' and validation errors', ' width=604', ' height=422']`

We can do:
```python
            if attributes:
                alt_parts = []
                kv_attrs = {}
                
                # The first one is always alt text (or start of it)
                # But wait, if the first one is 'width=100', then alt text is empty.
                # Actually, in AsciiDoc image attributes, the first one is always the alt text.
                # If you want no alt text but other attributes, you do [ , width=100].
                
                # Let's check if the first one is actually a KV pair.
                # If attributes[0] has '=', is it alt text or a KV pair?
                # According to AsciiDoc spec, the first attribute IS the alt text.
                
                alt_parts.append(attributes[0])
                for attr in attributes[1:]:
                    if '=' in attr:
                        key, value = attr.split('=', 1)
                        kv_attrs[key.strip()] = value.strip()
                    else:
                        alt_parts.append(attr)
                
                picture_info["alt"] = ",".join(alt_parts).strip()
                picture_info.update(kv_attrs)
```

Let's test this logic with `[A screenshot showing a dialog box, containing text fields, buttons, and validation errors, width=604, height=422]`.
`attributes` = `['A screenshot showing a dialog box', ' containing text fields', ' buttons', ' and validation errors', ' width=604', ' height=422']`
`alt_parts` = `['A screenshot showing a dialog box']`
`attr` = ` containing text fields` -> no `=`, `alt_parts` = `['A screenshot showing a dialog box', ' containing text fields']`
...
`attr` = ` width=604` -> has `=`, `kv_attrs` = `{'width': '604'}`
`attr` = ` height=422` -> has `=`, `kv_attrs` = `{'width': '604', 'height': '422'}`
`alt` = `"A screenshot showing a dialog box, containing text fields, buttons, and validation errors"`
`picture_info` = `{'type': 'picture', 'uri': '...', 'alt': '...', 'width': '604', 'height': '422'}`
This looks correct.

What about `[width=604, height=422]` where alt text is intended to be `width=604`?
In AsciiDoc, the first attribute is *always* treated as alt text. If you want it to be an attribute, you must provide a comma at the beginning.
Example: `[, width=604]` -> alt is `""`, width is `604`.
Example: `[width=604]` -> alt is `"width=604"`, no width attribute.

So my logic of `alt_parts.append(attributes[0])` is correct.

One more thing: `attr.split("=")` should be `attr.split("=", 1)` just in case the value contains an equals sign.

Let's refine the implementation:

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

Wait, if I update `picture_info[key.strip()]` inside the loop and then set `picture_info["alt"]` at the end, that's fine.

Let's double check the original code's handling of `attributes[0]`:
```python
                picture_info["alt"] = attributes[0].strip() if attributes[0] else ""
```
If `attributes` is `['', ' width=604']`, then `attributes[0]` is `''`, `alt` becomes `""`, then `attr` is ` width=604`, `key`='width', `value`='604'. Correct.

If `attributes` is `['Alt text']`, then `attributes[0]` is `'Alt text'`, `alt` becomes `'Alt text'`, loop doesn't run. Correct.

If `attributes` is `['Alt text, with comma']`, then `attributes` is `['Alt text', ' with comma']`.
`alt_parts` = `['Alt text']`
`attr` = `' with comma'` -> no `=`, `alt_parts` = `['Alt text', ' with comma']`
`alt` = `"Alt text, with comma"`
Correct.

One detail: the original code used `attributes[0].strip() if attributes[0] else ""`.
If `alt_parts = [attributes[0]]` and `attributes[0]` is `""`, then `",".join(alt_parts).strip()` will be `""`.

Wait, if `attributes` is `['']`, then `alt_parts` is `['']`, `alt` is `""`. Correct.

Is it possible that an attribute that contains `=` should actually be part of the alt text?
According to AsciiDoc image macro syntax, the attribute list is comma-separated. The first is alt text, others are `key=value`. If an attribute doesn't follow `key=value`, it's generally ignored or treated as part of the alt text if it's the first one. My proposed logic treats any non-KV pair as part of the alt text. This seems more robust than crashing.

Let's implement this fix.

Wait, I should also check if there are other places that might be affected or if there's a more standard way to parse this. But for a minimal fix, this seems to cover the reported bug.

Let's verify the fix with the reproduction script.

{
  "filepath": "docling/backend/asciidoc_backend.py",
  "new_string": "            if attributes:\n                alt_parts = [attributes[0]]\n                for attr in attributes[1:]:\n                    if \"=\" in attr:\n                        key, value = attr.split(\"=\", 1)\n                        picture_info[key.strip()] = value.strip()\n                    else:\n                        alt_parts.append(attr)\n                picture_info[\"alt\"] = \",\".join(alt_parts).strip()\n",
  "old_string": "            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,14 @@\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+                alt_parts = [attributes[0]]\n                 for attr in attributes[1:]:\n-                    key, value = attr.split(\"=\")\n-                    picture_info[key.strip()] = value.strip()\n+                    if \"=\" in attr:\n+                        key, value = attr.split(\"=\", 1)\n+                        picture_info[key.strip()] = value.strip()\n+                    else:\n+                        alt_parts.append(attr)\n+                picture_info[\"alt\"] = \",\".join(alt_parts).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\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}\")\nfinally:\n    tmp_path.unlink()\nPY\n"
}

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

The reproduction script now passes. Let me also test some edge cases.
1. Alt text without commas.
2. Alt text with commas but no other attributes.
3. No alt text, only attributes.
4. Empty brackets.
5. No brackets.

{
  "command": "python3 - <<'PY'\nfrom docling.document_converter import DocumentConverter\nfrom docling.datamodel.base_models import InputFormat\nfrom pathlib import Path\nimport tempfile\n\ntest_cases = [\n    (\"No commas\", \"= Test\\nimage::img.png[Alt text, width=100]\"),\n    (\"Commas in alt, with attrs\", \"= Test\\nimage::img.png[Alt, text with comma, width=100]\"),\n    (\"Commas in alt, no attrs\", \"= Test\\nimage::img.png[Alt, text with comma]\"),\n    (\"No alt, only attrs\", \"= Test\\nimage::img.png[, width=100]\"),\n    (\"Empty brackets\", \"= Test\\nimage::img.png[]\"),\n    (\"No brackets\", \"= Test\\nimage::img.png\"),\n]\n\nfor name, content in test_cases:\n    with tempfile.NamedTemporaryFile(suffix=\".adoc\", mode=\"w\", delete=False) as f:\n        f.write(content)\n        tmp_path = Path(f.name)\n    try:\n        converter = DocumentConverter(allowed_formats=[InputFormat.ASCIIDOC])\n        result = list(converter.convert_all(source=[tmp_path], raises_on_error=False))\n        print(f\"{name}: {'SUCCESS' if result[0].status == 'success' else 'FAILURE'} - Errors: {result[0].errors}\")\n    finally:\n        tmp_path.unlink()\nPY\n"
}

{
  "status": "ok",
  "stdout": "No commas: SUCCESS - Errors: []\nCommas in alt, with attrs: SUCCESS - Errors: []\nCommas in alt, no attrs: SUCCESS - Errors: []\nNo alt, only attrs: SUCCESS - Errors: []\nEmpty brackets: SUCCESS - Errors: []\nNo brackets: SUCCESS - Errors: []\n",
  "stderr": "",
  "exit_code": 0
}

All test cases passed.

Wait, I should also check if `_parse_picture` is called anywhere else or if there are other methods that might have similar issues.
Searching for `.split(",")` in `docling/backend/asciidoc_backend.py`.

{
  "command": "grep \"\\.split(\\\",\\\")\" docling/backend/asciidoc_backend.py"
}

{
  "status": "ok",
  "stdout": "            attributes = mtch.group(2).split(\",\")\n",
  "stderr": "",
  "exit_code": 0
}

It only appears in `_parse_picture`.

I'll do one more check on my implementation to make sure it's as clean as possible.

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

If `attributes` is `['', 'width=100']`:
`alt_parts = ['']`
`attr = 'width=100'` -> `picture_info['width'] = '100'`
`picture_info['alt'] = "".strip() = ""`
Correct.

If `attributes` is `['']`:
`alt_parts = ['']`
`picture_info['alt'] = "".strip() = ""`
Correct.

If `attributes` is `['Alt text']`:
`alt_parts = ['Alt text']`
`picture_info['alt'] = "Alt text".strip() = "Alt text"`
Correct.

If `attributes` is `['Alt, text']`:
`alt_parts = ['Alt', ' text']`
`picture_info['alt'] = "Alt, text".strip() = "Alt, text"`
Correct.

One minor thing: if `attributes` is `[' Alt text ']` (with spaces), `alt_parts` is `[' Alt text ']`, and `",".join(alt_parts).strip()` becomes `"Alt text"`.
Wait, the original code did `attributes[0].strip()`. My code does `.strip()` at the end of the join.

If `attributes` was `[' Alt ', ' text ']` (no `=`, so both are alt text), then:
`alt_parts = [' Alt ', ' text ']`
`",".join(alt_parts).strip()` = `" Alt , text ".strip()` = `"Alt , text"`.
The space after the comma is preserved, but the space before the first element and after the last element is stripped. This seems correct.

Wait, if the input is `[ Alt text, width=100]`, then `attributes[0]` is `" Alt text"`.
`alt_parts = [" Alt text"]`
`picture_info["alt"] = " Alt text".strip() = "Alt text"`.

Is it better to strip each part?
In AsciiDoc, usually people put a space after the comma.
If we have `[Alt text, width=100]`, `attributes` is `['Alt text', ' width=100']`.
`alt_parts = ['Alt text']`
`",".join(alt_parts).strip()` = `"Alt text".strip()` = `"Alt text"`.

If we have `[Alt text, with comma, width=100]`, `attributes` is `['Alt text', ' with comma', ' width=100']`.
`alt_parts = ['Alt text', ' with comma']`
`",".join(alt_parts).strip()` = `"Alt text, with comma".strip()` = `"Alt text, with comma"`.

This seems to beExactly what we want.

One last look at `_parse_picture` to see if there's any other issue.

```python
    @staticmethod
    def _parse_picture(line):
        """
        Parse an image macro, extracting its path and attributes.
        Syntax: image::path/to/image.png[Alt Text, width=200, height=150, align=center]
        """
        mtch = re.match(r"^image::(.+)\[(.*)\]$", line)
        if mtch:
            picture_path = mtch.group(1).strip()
            attributes = mtch.group(2).split(",")
            picture_info = {"type": "picture", "uri": picture_path}

            # Extract optional attributes (alt text, width, height, alignment)
            if attributes:
                alt_parts = [attributes[0]]
                for attr in attributes[1:]:
                    if "=" in attr:
                        key, value = attr.split("=", 1)
                        picture_info[key.strip()] = value.strip()
                    else:
                        alt_parts.append(attr)
                picture_info["alt"] = ",".join(alt_parts).strip()

            return picture_info

        return {"type": "picture", "uri": line}
```

Wait, I noticed something in the original code:
```python
        return {"type": "picture", "uri": line}
```
If `mtch` fails, it returns the whole line as the URI. This is probably for cases like `image::img.png` without brackets.

If `line` is `image::img.png`, then `re.match(r"^image::(.+)\[(.*)\]$", line)` fails because there are no `[` and `]`.
So it returns `{"type": "picture", "uri": "image::img.png"}`.
Wait, that's probably not right. If `line` is `image::img.png`, the URI should be `img.png`.
But this is outside the scope of the current bug fix. I should focus on the reported crash.

Let me double check if my change broke anything.
The crash was `ValueError: not enough values to unpack (expected 2, got 1)`.
My change avoids `split("=")` unless `"=" in attr`.

The original code for `image::img.png` would have:
`mtch = re.match(r"^image::(.+)\[(.*)\]$", line)` -> `None`
`return {"type": "picture", "uri": line}` -> `{"type": "picture", "uri": "image::img.png"}`.
That was the existing behavior, not introduced by me.

I'm confident with the fix.

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

One detail: the original code had `picture_info["alt"] = attributes[0].strip() if attributes[0] else ""`.
If `attributes` is `['']`, then `alt_parts = ['']`, and `",".join(alt_parts).strip()` is `"".strip() = ""`. Matches.

I'll do a final check on the diff.

{
  "command": "git diff\n"
}

{
  "status": "ok",
  "stdout": "diff --git a/docling/backend/asciidoc_backend.py b/docling/backend/asciidoc_backend.py\nindex c6a0d18..91c6b82 100644\n--- a/docling/backend/asciidoc_backend.py\n+++ b/docling/backend/asciidoc_backend.py\n@@ -414,10 +414,14 @@ 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+                alt_parts = [attributes[0]]\n                 for attr in attributes[1:]:\n-                    key, value = attr.split(\"=\")\n-                    picture_info[key.strip()] = value.strip()\n+                    if \"=\" in attr:\n+                        key, value = attr.split(\"=\", 1)\n+                        picture_info[key.strip()] = value.strip()\n+                    else:\n+                        alt_parts.append(attr)\n+                picture_info[\"alt\"] = \",\".join(alt_parts).strip()\n \n             return picture_info\n \n",
  "stderr": "",
  "exit_code": 0
}

The diff looks correct and minimal. I've verified it with the reproduction script and several edge cases.

Final check:
- File: `docling/backend/asciidoc_backend.py`
- Fixes `ValueError: not enough values to unpack` in `_parse_picture`
- Preserves functionality for standard AsciiDoc image macros
- Handles alt text containing commas correctly
- Handles empty alt text correctly
- No changes to tests (as per rules)
- No untracked files in workspace.

I'm ready to submit.

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

The patch has been submitted. I've ensured it's root-cause fixing and verified via tests.

The bug was caused by `AsciiDocBackend._parse_picture` splitting the image attribute list by commas and blindly unpacking every element after the first as a `key=value` pair. When the alt text contained commas, subsequent parts of the alt text were treated as attributes, leading to a `ValueError` when they lacked an equals sign.

I updated the parser to accumulate all non-`key=value` elements into the alt text and only treat elements containing an equals sign as attributes. This ensures that alt text with commas is preserved and doesn't crash the conversion process.