@kujolang/paperclip 0.1.0

package/bundled/components/changebucket/src/classify.kujo

@@ -0,0 +1,221 @@
+# ChangeBucket :: classify
+#
+# Pragmatic path/extension rules that bucket a changed file into zero or more
+# categories. A file may belong to several (e.g. package.json is both `config`
+# and `dependency_manifests`). Rules are intentionally simple and documented in
+# the README; this is not a plugin system and should not become one.
+#
+# Helper predicates each use a single `for` loop so the module compiles cleanly
+# under the checker (which rejects >1 `for` loop per function scope).
+
+from src.util import basename
+
+# The canonical category order used everywhere (reports, JSON, counts).
+export func category_order() {
+    return ["source", "tests", "docs", "config", "dependency_manifests", "lockfiles", "generated", "ci", "scripts", "other"]
+}
+
+# --- tiny predicate helpers (one loop each) -----------------------------
+
+func ends_any(s, suffixes) {
+    for suf in suffixes {
+        if ends_with(s, suf) {
+            return true
+        }
+    }
+    return false
+}
+
+func starts_any(s, prefixes) {
+    for p in prefixes {
+        if starts_with(s, p) {
+            return true
+        }
+    }
+    return false
+}
+
+func contains_any(s, subs) {
+    for sub in subs {
+        if contains(s, sub) == 1 {
+            return true
+        }
+    }
+    return false
+}
+
+# True when one of `names` occurs as a complete slash-delimited path segment.
+# Appending/prepending slashes avoids false positives such as `rebuild/` for
+# the generated directory `build/` and `descripts/` for `scripts/`.
+func has_dir_segment(path, names) {
+    wrapped := "/" + path + "/"
+    for name in names {
+        if contains(wrapped, "/" + name + "/") == 1 {
+            return true
+        }
+    }
+    return false
+}
+
+func eq_any(s, vals) {
+    for v in vals {
+        if s == v {
+            return true
+        }
+    }
+    return false
+}
+
+# --- per-category predicates --------------------------------------------
+
+func is_test(pl, namel) {
+    if contains_any(pl, ["/test/", "/tests/", "/__tests__/", "/spec/"]) {
+        return true
+    }
+    if starts_any(pl, ["test/", "tests/", "spec/"]) {
+        return true
+    }
+    if contains(namel, ".test.") == 1 || contains(namel, ".spec.") == 1 {
+        return true
+    }
+    if starts_with(namel, "test_") {
+        return true
+    }
+    if ends_any(namel, ["_test.go", "_test.py", "_test.rs", "_spec.rb", ".test.ts", ".spec.ts"]) {
+        return true
+    }
+    return false
+}
+
+func is_docs(pl, namel) {
+    if ends_any(namel, [".md", ".mdx", ".rst", ".adoc"]) {
+        return true
+    }
+    if has_dir_segment(pl, ["docs", "doc"]) {
+        return true
+    }
+    if starts_any(namel, ["readme", "changelog", "license", "contributing", "authors", "code_of_conduct"]) {
+        return true
+    }
+    return false
+}
+
+func is_lockfile(namel) {
+    return eq_any(namel, ["package-lock.json", "pnpm-lock.yaml", "yarn.lock", "cargo.lock", "poetry.lock", "composer.lock", "go.sum", "gemfile.lock", "pdm.lock", "bun.lockb", "pipfile.lock"])
+}
+
+func is_dependency_manifest(namel) {
+    if eq_any(namel, ["package.json", "pyproject.toml", "cargo.toml", "composer.json", "go.mod", "gemfile", "setup.py", "pipfile", "build.gradle", "pom.xml", "setup.cfg"]) {
+        return true
+    }
+    # requirements.txt / requirements-dev.txt / requirements/foo.txt
+    if starts_with(namel, "requirements") && ends_with(namel, ".txt") {
+        return true
+    }
+    return false
+}
+
+func is_ci(pl, namel) {
+    if contains(pl, "/.github/workflows/") == 1 || starts_with(pl, ".github/workflows/") {
+        return true
+    }
+    if contains(pl, "/.gitea/workflows/") == 1 || starts_with(pl, ".gitea/workflows/") {
+        return true
+    }
+    if has_dir_segment(pl, [".circleci"]) {
+        return true
+    }
+    if eq_any(namel, ["jenkinsfile", ".gitlab-ci.yml", "circle.yml", ".travis.yml", "azure-pipelines.yml", "bitbucket-pipelines.yml", ".drone.yml"]) {
+        return true
+    }
+    return false
+}
+
+func is_generated(pl, namel) {
+    if has_dir_segment(pl, ["dist", "build", "target", "node_modules", ".next", ".nuxt", "out", "coverage", "__pycache__", "vendor", ".svelte-kit"]) {
+        return true
+    }
+    if ends_any(namel, [".min.js", ".min.css", ".map", ".g.dart", ".generated.ts", ".pb.go"]) {
+        return true
+    }
+    if ends_with(namel, "_pb2.py") {
+        return true
+    }
+    return false
+}
+
+func is_scripts(pl, namel) {
+    if has_dir_segment(pl, ["scripts", "bin"]) {
+        return true
+    }
+    if ends_any(namel, [".sh", ".bash", ".zsh", ".fish", ".ps1"]) {
+        return true
+    }
+    return false
+}
+
+func is_config(pl, namel) {
+    if eq_any(namel, ["package.json", "tsconfig.json", "pyproject.toml", "cargo.toml", "composer.json", "kujo.toml", "rustfmt.toml", ".editorconfig", ".eslintrc", ".eslintrc.js", ".eslintrc.json", ".eslintrc.cjs", ".prettierrc", ".prettierrc.json", "tslint.json", "dockerfile", "makefile", ".gitignore", ".dockerignore", ".npmrc", "go.work"]) {
+        return true
+    }
+    if contains_any(namel, [".config.", "eslint.config", "vite.config", "rollup.config", "webpack.config", "tailwind.config", "next.config", "svelte.config", "postcss.config", "jest.config", "babel.config", "vitest.config"]) {
+        return true
+    }
+    if ends_any(namel, [".toml", ".ini", ".cfg", ".conf", ".properties"]) {
+        return true
+    }
+    if starts_with(namel, ".env") {
+        return true
+    }
+    return false
+}
+
+func is_source(pl, namel, is_t, is_d) {
+    if is_t || is_d {
+        return false
+    }
+    return ends_any(namel, [".js", ".jsx", ".mjs", ".cjs", ".ts", ".tsx", ".py", ".rs", ".go", ".php", ".rb", ".java", ".c", ".cc", ".cpp", ".cxx", ".h", ".hh", ".hpp", ".cs", ".swift", ".kt", ".kts", ".scala", ".m", ".mm", ".vue", ".svelte", ".kujo", ".kujo", ".lua", ".dart", ".ex", ".exs", ".erl", ".clj", ".sql", ".html", ".css", ".scss"])
+}
+
+# Return the list of categories a path belongs to. Always non-empty: a file
+# matching nothing falls back to ["other"].
+export func classify(path) {
+    pl := to_lower(path)
+    namel := to_lower(basename(path))
+
+    matched_test := is_test(pl, namel)
+    matched_docs := is_docs(pl, namel)
+
+    mut cats := []
+    if is_source(pl, namel, matched_test, matched_docs) {
+        cats = push(cats, "source")
+    }
+    if matched_test {
+        cats = push(cats, "tests")
+    }
+    if matched_docs {
+        cats = push(cats, "docs")
+    }
+    if is_config(pl, namel) {
+        cats = push(cats, "config")
+    }
+    if is_dependency_manifest(namel) {
+        cats = push(cats, "dependency_manifests")
+    }
+    if is_lockfile(namel) {
+        cats = push(cats, "lockfiles")
+    }
+    if is_generated(pl, namel) {
+        cats = push(cats, "generated")
+    }
+    if is_ci(pl, namel) {
+        cats = push(cats, "ci")
+    }
+    if is_scripts(pl, namel) {
+        cats = push(cats, "scripts")
+    }
+    if len(cats) == 0 {
+        cats = push(cats, "other")
+    }
+    return cats
+}

package/bundled/components/changebucket/src/cli.kujo

@@ -0,0 +1,324 @@
+# ChangeBucket :: cli
+#
+# Argument parsing and command dispatch. This is the only module that prints
+# user-facing output and chooses the process exit code. It wires together
+# analyze / budget / render.
+#
+# Exit code convention:
+#   0  success, or analysis printed (default command always exits 0)
+#   1  operational failure (not a git repo), OR a `check` whose budget failed
+#   2  usage error (unknown command)
+
+from src.analyze import analyze
+from src.budget import empty_config, has_constraints, evaluate
+from src.render import render_text, render_markdown
+from src.util import includes
+
+VERSION := "1.0.0"
+
+# --- argument parsing ---------------------------------------------------
+
+func split_flag_token(token) {
+    raw := substring(token, 2, len(token))
+    eq := index_of(raw, "=")
+    if eq >= 0 {
+        return {"name": substring(raw, 0, eq), "value": substring(raw, eq + 1, len(raw)), "has_value": true}
+    }
+    return {"name": raw, "value": "", "has_value": false}
+}
+
+# Split tokens into positionals and flags. Names in `bool_flags` are valueless
+# switches; names in `value_flags` consume the next token as their value.
+func parse_args(tokens, bool_flags) {
+    mut flags := {}
+    mut positionals := []
+    mut i := 0
+    while i < len(tokens) {
+        token := tokens[i]
+        if starts_with(token, "--") {
+            split_flag := split_flag_token(token)
+            name := split_flag["name"]
+            if known_flag(name, bool_flags) == false {
+                return {"positionals": [], "flags": {}, "error": "unknown option --" + name}
+            }
+            if includes(bool_flags, name) {
+                if split_flag["has_value"] == true {
+                    return {"positionals": [], "flags": {}, "error": "option --" + name + " does not take a value"}
+                }
+                flags[name] := "true"
+            } else if split_flag["has_value"] == true {
+                if split_flag["value"] == "" {
+                    return {"positionals": [], "flags": {}, "error": "missing value for --" + name}
+                }
+                flags[name] := split_flag["value"]
+            } else {
+                if i + 1 >= len(tokens) || starts_with(tokens[i + 1], "-") {
+                    return {"positionals": [], "flags": {}, "error": "missing value for --" + name}
+                }
+                flags[name] := tokens[i + 1]
+                i = i + 1
+            }
+        } else {
+            positionals = append(positionals, token)
+        }
+        i = i + 1
+    }
+    return {"positionals": positionals, "flags": flags}
+}
+
+func flag(parsed, name) {
+    if has_key(parsed["flags"], name) == 1 {
+        return parsed["flags"][name]
+    }
+    return null
+}
+
+func flag_or(parsed, name, fallback) {
+    v := flag(parsed, name)
+    if type(v) == "null" {
+        return fallback
+    }
+    return v
+}
+
+func has_flag(parsed, name) {
+    return has_key(parsed["flags"], name) == 1
+}
+
+# The set of valueless boolean flags ChangeBucket understands.
+func bool_flags() {
+    return ["json", "markdown", "no-deletes", "no-dependency-changes", "no-lockfile-changes", "no-config-changes", "no-generated-changes"]
+}
+
+func value_flags() {
+    return ["base", "head", "repo", "output", "max-files", "max-churn", "max-additions", "max-deletions"]
+}
+
+func numeric_flags() {
+    return ["max-files", "max-churn", "max-additions", "max-deletions"]
+}
+
+func known_flag(name, bools) {
+    return includes(bools, name) || includes(value_flags(), name)
+}
+
+func is_digits(text) {
+    if text == "" {
+        return false
+    }
+    mut i := 0
+    while i < len(text) {
+        ch := substring(text, i, i + 1)
+        if contains("0123456789", ch) == 0 {
+            return false
+        }
+        i = i + 1
+    }
+    return true
+}
+
+func trim_leading_zeroes(text) {
+    mut i := 0
+    while i + 1 < len(text) && substring(text, i, i + 1) == "0" {
+        i = i + 1
+    }
+    return substring(text, i, len(text))
+}
+
+func fits_int(text) {
+    normalized := trim_leading_zeroes(text)
+    max_int := "9223372036854775807"
+    if len(normalized) < len(max_int) {
+        return true
+    }
+    if len(normalized) > len(max_int) {
+        return false
+    }
+    return normalized <= max_int
+}
+
+func validate_numeric_flags(parsed) {
+    for name in numeric_flags() {
+        v := flag(parsed, name)
+        if type(v) != "null" {
+            if is_digits(v) == false {
+                return "invalid numeric value for --" + name + ": " + v
+            }
+            if fits_int(v) == false {
+                return "numeric value out of range for --" + name + ": " + v
+            }
+        }
+    }
+    return ""
+}
+
+# Read an integer flag (null when absent or empty).
+func int_flag(parsed, name) {
+    v := flag(parsed, name)
+    if type(v) == "null" || v == "" {
+        return null
+    }
+    return parse_int(v)
+}
+
+# Build a budget config from parsed flags.
+func build_config(parsed) {
+    cfg := empty_config()
+    cfg["max_files"] := int_flag(parsed, "max-files")
+    cfg["max_churn"] := int_flag(parsed, "max-churn")
+    cfg["max_additions"] := int_flag(parsed, "max-additions")
+    cfg["max_deletions"] := int_flag(parsed, "max-deletions")
+    cfg["no_deletes"] := has_flag(parsed, "no-deletes")
+    cfg["no_dependency_changes"] := has_flag(parsed, "no-dependency-changes")
+    cfg["no_lockfile_changes"] := has_flag(parsed, "no-lockfile-changes")
+    cfg["no_config_changes"] := has_flag(parsed, "no-config-changes")
+    cfg["no_generated_changes"] := has_flag(parsed, "no-generated-changes")
+    return cfg
+}
+
+# --- the one real command ----------------------------------------------
+
+# Run analysis and emit output. `is_check` decides whether a failed budget
+# turns into a non-zero exit code.
+func run(parsed, is_check) {
+    if has_key(parsed, "error") == 1 {
+        print("error: " + parsed["error"])
+        return 2
+    }
+    if len(parsed["positionals"]) > 0 {
+        print("error: unexpected argument '" + parsed["positionals"][0] + "'")
+        return 2
+    }
+    numeric_error := validate_numeric_flags(parsed)
+    if numeric_error != "" {
+        print("error: " + numeric_error)
+        return 2
+    }
+
+    repo := flag_or(parsed, "repo", ".")
+    base := flag(parsed, "base")
+    head := flag(parsed, "head")
+
+    model := analyze(repo, base, head)
+    if type(model) == "dict" && has_key(model, "error") == 1 {
+        print("error: " + model["error"])
+        return 1
+    }
+
+    cfg := build_config(parsed)
+    show_budget := is_check || has_constraints(cfg)
+    mut m := model
+    if show_budget {
+        m = evaluate(m, cfg)
+    }
+
+    mut code := 0
+    if is_check && has_key(m, "budget") == 1 && m["budget"]["checked"] == true && m["budget"]["passed"] == false {
+        code = 1
+    }
+
+    if has_flag(parsed, "json") {
+        print(to_json_pretty(m))
+        return code
+    }
+
+    output := flag(parsed, "output")
+    wants_md := has_flag(parsed, "markdown") || (type(output) != "null" && output != "")
+    if wants_md {
+        md := render_markdown(m, cfg, show_budget)
+        if type(output) != "null" && output != "" {
+            try {
+                if path_is_dir(output) {
+                    print("error: output path is a directory: " + output)
+                    return 1
+                }
+                write_file(output, md, true)
+            } except write_error {
+                print("error: could not write report to " + output + ": " + to_string(write_error))
+                return 1
+            }
+            print("Wrote report to " + output)
+            return code
+        }
+        print(md)
+        return code
+    }
+
+    print(render_text(m, cfg, show_budget))
+    return code
+}
+
+# --- help / dispatch ----------------------------------------------------
+
+func print_lines(lines) {
+    mut i := 0
+    while i < len(lines) {
+        print(lines[i])
+        i = i + 1
+    }
+}
+
+func print_help() {
+    print_lines([
+        "changebucket " + VERSION + " — measure the footprint of a code change",
+        "",
+        "Usage:",
+        "  changebucket [options]            Analyze the working tree against HEAD",
+        "  changebucket check [budget opts]  Analyze and enforce a budget (non-zero exit on fail)",
+        "",
+        "Range options:",
+        "  --base <ref>      Compare against this ref (default HEAD)",
+        "  --head <ref>      Compare a commit range base..head (no working tree)",
+        "  --repo <path>     Repository to analyze (default current directory)",
+        "",
+        "Output options:",
+        "  --json            Emit machine-readable JSON only",
+        "  --markdown        Emit a markdown report",
+        "  --output <file>   Write a markdown report to a file",
+        "",
+        "Budget options (informational on the default command; enforced under `check`):",
+        "  --max-files <n>",
+        "  --max-churn <n>",
+        "  --max-additions <n>",
+        "  --max-deletions <n>",
+        "  --no-deletes",
+        "  --no-dependency-changes",
+        "  --no-lockfile-changes",
+        "  --no-config-changes",
+        "  --no-generated-changes",
+        "",
+        "  help, --help      Show this help",
+        "  version           Show version",
+        "",
+        "ChangeBucket uses read-only git commands and never modifies your repo."
+    ])
+}
+
+# Entry point. `argv` is the user argument list (args()).
+export func main(argv) {
+    if len(argv) == 0 {
+        return run(parse_args([], bool_flags()), false)
+    }
+
+    cmd := argv[0]
+
+    if cmd == "help" || cmd == "--help" || cmd == "-h" {
+        print_help()
+        return 0
+    }
+    if cmd == "version" || cmd == "--version" || cmd == "-V" {
+        print("changebucket " + VERSION)
+        return 0
+    }
+    if cmd == "check" {
+        rest := slice(argv, 1, len(argv))
+        return run(parse_args(rest, bool_flags()), true)
+    }
+    if starts_with(cmd, "-") {
+        return run(parse_args(argv, bool_flags()), false)
+    }
+
+    print("error: unknown command '" + cmd + "'")
+    print("Run 'changebucket help' for usage.")
+    return 2
+}