Method visit_copy

src/extraction/dockerfile_extractor.rs:564–631

Extract COPY instruction, looking for `--from=STAGE` references. `COPY --from=builder ...` creates a Uses edge from the current stage (or file) to the referenced stage.

(state: &mut ExtractionState, node: TsNode<'_>)

    /// `COPY --from=builder ...` creates a Uses edge from the current stage
    /// (or file) to the referenced stage.
    fn visit_copy(state: &mut ExtractionState, node: TsNode<'_>) {
        let start_line = node.start_position().row as u32;

        let mut cursor = node.walk();
        if cursor.goto_first_child() {
            loop {
                let child = cursor.node();
                if child.kind() == "param" {
                    let param_text = state.node_text(child);
                    if let Some(stage_name) = param_text.strip_prefix("--from=") {
                        let target = if let Some(target) = state.stage_target(stage_name) {
                            target
                        } else {
                            let id = generate_node_id(
                                &state.file_path,
                                &NodeKind::Use,
                                stage_name,
                                start_line,
                            );
                            let text = state.node_text(node);
                            state.nodes.push(Node {
                                id: id.clone(),
                                kind: NodeKind::Use,
                                name: stage_name.to_string(),
                                qualified_name: format!(
                                    "{}::{}",
                                    state.qualified_prefix(),
                                    stage_name
                                ),
                                file_path: state.file_path.clone(),
                                start_line,
                                attrs_start_line: start_line,
                                end_line: node.end_position().row as u32,
                                start_column: node.start_position().column as u32,
                                end_column: node.end_position().column as u32,
                                signature: Some(text.trim().to_string()),
                                docstring: None,
                                visibility: Visibility::Pub,
                                is_async: false,
                                branches: 0,
                                loops: 0,
                                returns: 0,
                                max_nesting: 0,
                                unsafe_blocks: 0,
                                unchecked_calls: 0,
                                assertions: 0,
                                updated_at: state.timestamp,
                                parent_id: None,
                            });
                            id
                        };

                        if let Some(parent_id) = state.parent_node_id() {
                            state.edges.push(Edge {
                                source: parent_id.to_string(),
                                target,
                                kind: EdgeKind::Uses,
                                line: Some(start_line),