packlet 0.1.1

A high-performance tool that bundles local code dependencies into a single markdown file by following import statements from an entry point
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141

use crate::core::traverser::DependencyGraph;
use anyhow::Result;
use std::collections::HashMap;
use std::fmt::Write;
use std::path::{Path, PathBuf};

/// Convert absolute path to relative path from git root, or return display string if not in git repo
fn format_path(path: &Path, git_root: Option<&Path>) -> String {
    if let Some(root) = git_root {
        if let Ok(relative) = path.strip_prefix(root) {
            return relative.display().to_string();
        }
    }
    path.display().to_string()
}

pub trait OutputFormatter: Send + Sync {
    fn format(&self, graph: &DependencyGraph, files: &HashMap<PathBuf, String>) -> Result<String>;
    fn format_with_git_root(
        &self,
        graph: &DependencyGraph,
        files: &HashMap<PathBuf, String>,
        git_root: Option<&Path>,
    ) -> Result<String>;
}

pub struct MarkdownFormatter;

impl MarkdownFormatter {
    fn render_tree(&self, graph: &DependencyGraph, git_root: Option<&Path>) -> Result<String> {
        let mut output = String::new();
        let mut visited = HashMap::new();
        self.write_tree_recursive(
            &mut output,
            graph,
            &mut visited,
            &graph.entry_point,
            "",
            git_root,
        )?;
        Ok(output)
    }

    pub fn format_tree_only(&self, graph: &DependencyGraph) -> Result<String> {
        self.render_tree(graph, None)
    }

    pub fn format_tree_only_with_git_root(
        &self,
        graph: &DependencyGraph,
        git_root: Option<&Path>,
    ) -> Result<String> {
        self.render_tree(graph, git_root)
    }

    fn write_tree_recursive(
        &self,
        output: &mut String,
        graph: &DependencyGraph,
        visited: &mut HashMap<PathBuf, bool>,
        path: &Path,
        prefix: &str,
        git_root: Option<&Path>,
    ) -> Result<()> {
        if visited.get(path).is_some() {
            writeln!(
                output,
                "{} {} (circular)",
                prefix,
                format_path(path, git_root)
            )?;
            return Ok(());
        }
        writeln!(output, "{} {}", prefix, format_path(path, git_root))?;
        visited.insert(path.to_path_buf(), true);

        if let Some(deps) = graph.adj_list.get(path) {
            let mut sorted_deps = deps.clone();
            sorted_deps.sort_by(|a, b| a.0.cmp(&b.0));

            for (i, (dep_path, _)) in sorted_deps.iter().enumerate() {
                let (new_prefix, branch) = if i == sorted_deps.len() - 1 {
                    (format!("{}    ", prefix), "└──")
                } else {
                    (format!("{}│   ", prefix), "├──")
                };
                self.write_tree_recursive(
                    output,
                    graph,
                    visited,
                    dep_path,
                    &format!("{}{}", new_prefix, branch),
                    git_root,
                )?;
            }
        }
        Ok(())
    }
}

impl OutputFormatter for MarkdownFormatter {
    fn format(&self, graph: &DependencyGraph, files: &HashMap<PathBuf, String>) -> Result<String> {
        self.format_with_git_root(graph, files, None)
    }

    fn format_with_git_root(
        &self,
        graph: &DependencyGraph,
        files: &HashMap<PathBuf, String>,
        git_root: Option<&Path>,
    ) -> Result<String> {
        let mut output = String::new();

        writeln!(output, "# Packlet Dependency Bundle\n")?;
        writeln!(output, "**Generated:** {}", chrono::Utc::now().to_rfc2822())?;
        writeln!(
            output,
            "**Entry:** `{}`\n",
            format_path(&graph.entry_point, git_root)
        )?;

        writeln!(output, "## Dependency Tree\n")?;
        writeln!(output, "```")?;
        write!(output, "{}", self.render_tree(graph, git_root)?)?;
        writeln!(output, "```\n")?;

        writeln!(output, "## File Contents\n")?;
        let mut sorted_files: Vec<_> = files.iter().collect();
        sorted_files.sort_by(|a, b| a.0.cmp(b.0));

        for (path, content) in sorted_files {
            let lang = path.extension().and_then(|s| s.to_str()).unwrap_or("");
            writeln!(output, "### `{}`\n", format_path(path, git_root))?;
            writeln!(output, "```{}", lang)?;
            writeln!(output, "{}", content)?;
            writeln!(output, "```\n")?;
        }

        Ok(output)
    }
}