@erclx/aitk 3.9.0 → 3.10.0

package/claude/.claude-plugin/plugin.json

@@ -1,7 +1,7 @@
 {
   "name": "aitk",
   "description": "Automated governance, versioning, and discovery tools for Claude Code.",
-  "version": "3.9.0",
+  "version": "3.10.0",
   "author": {
     "name": "Eric Le",
     "url": "https://github.com/erclx"

package/claude/skills/toolkit-cli/SKILL.md

@@ -52,8 +52,6 @@ Run `aitk tooling sync <stack> <target> --check` for the list resolved against a
 - `.vscode/extensions.json`
 - `.vscode/settings.json`
 - `commitlint.config.js`
-- `scripts/clean.sh`
-- `scripts/update.sh`
 - `scripts/verify.sh`
 
 ### python

package/docs/agents/audits.md

@@ -22,11 +22,11 @@ aitk audits list --json
 
 ## What it runs
 
-Seventeen verbs, listed by `aitk audits list`. Each runs once in its fullest form, and the aggregate reads that verb's own record rather than imposing a shared envelope on it. Every one of those records already has consumers naming its keys, so a common shape would be a breaking change bought for tidiness.
+Eighteen verbs, listed by `aitk audits list`. Each runs once in its fullest form, and the aggregate reads that verb's own record rather than imposing a shared envelope on it. Every one of those records already has consumers naming its keys, so a common shape would be a breaking change bought for tidiness.
 
 The verbs walk separate trees and share no state, so they run together. Measured on the authoring machine at twelve verbs, a run finished in 0.8 seconds of wall clock against 4.4 seconds of processor, which is under every other stage in `bun run check`. `aitk deps audit` is the one that changes that reading, since it reaches a network rather than a tree and its latency is the index's rather than this machine's.
 
-Fourteen of the seventeen read a tree on this disk, the one added by `restated.md` among them, since it reads three such trees against each other. The two added by `state-scoped-risk.md` read committed state rather than an arriving change, which is the gap every review surface here leaves by construction, and the one added by `label-coverage.md` reads a branch range against a map the project declares.
+Fifteen of the eighteen read a tree on this disk, the one added by `restated.md` and the one added by `census.md` among them, since the first reads three such trees against each other and the second counts every file in one. The two added by `state-scoped-risk.md` read committed state rather than an arriving change, which is the gap every review surface here leaves by construction, and the one added by `label-coverage.md` reads a branch range against a map the project declares.
 
 Each is invoked as the CLI the caller is running rather than as a global `aitk`. A globally installed binary resolves to the main checkout no matter which worktree is executing, so the aggregate would measure a tree the branch never touched and report a pass over it.
 

package/docs/agents/census.md

@@ -0,0 +1,23 @@
+---
+title: Census
+description: Tracked-plus-untracked file count, a breakdown by extension, and a line total that skips whatever reads as binary
+---
+
+# Census
+
+`aitk census [path]` reports how large a tree is: the tracked-plus-untracked file count, a breakdown by extension, and a line total. It reads `listRepositoryFiles`, the same corpus the citation check, the markdown corpus, and the secret scan already read, so this is not a fourth definition of what counts.
+
+```bash
+aitk census
+aitk census src --json
+```
+
+| Option   | Behavior                                                   |
+| -------- | ---------------------------------------------------------- |
+| `--json` | Add a machine-readable record on stdout, keeping the frame |
+
+Grouping is by extension rather than by a named language category. A config file and a source file land in separate buckets and two source files sharing an extension land in one, and a file with no extension, such as `Dockerfile`, lands under `no-extension`.
+
+Line counts are text-only. A file that reads as binary, and a file git lists that will not open, such as a symlink leaving the tree, are counted toward the file total and their extension's file count, and left out of every line count. The record's `skipped` field states that gap rather than leaving a reader to infer it from the difference between the file count and the summed extension line counts. It carries both causes as one number: on a healthy tree the two are indistinguishable, so a `skipped` count above what the tree's own binary files explain is itself the signal that something in the corpus will not open.
+
+The command reports a snapshot rather than a delta. It registers in the audit catalog with an empty gating set, so `aitk audits run --record` is what turns two snapshots into the growth series a hand count used to approximate: 481 files on one date and 965 five weeks later, with nothing between them because nobody had counted again.

package/docs/agents/commands.md

@@ -54,6 +54,7 @@ Full help: `aitk <command> --help`. Behavior notes for the install and sync verb
 | `aitk secrets scan`        | Report credential-shaped values in the tree the package ships, keyed on issued values rather than on words (`--json`)                          |
 | `aitk deps audit`          | Report published advisories against the resolved dependency set, refusing rather than reporting clean when the index is unreachable (`--json`) |
 | `aitk labels audit`        | Report the labels a changed set earns from the pull request label map and the paths no row reaches (`--json`)                                  |
+| `aitk census [path]`       | Report tracked file count, a breakdown by extension, and a line total that skips whatever reads as binary (`--json`)                           |
 | `aitk audits run`          | Run every audit as one set, report per check under one verdict, and compare each count to the recorded baseline (`--json`, `--record`)         |
 | `aitk audits list`         | List every audit the set runs, with the corpus each reads and whether it gates (`--json`)                                                      |
 | `aitk capture [source]`    | Render HTML capture sources to PNG, toolkit-only and absent from an installed package                                                          |

package/docs/agents/index.md

@@ -10,6 +10,7 @@ CLI catalog and invocation rules for agents, split by command domain. Start with
 
 - [Audits](audits.md): Running every health check as one set, what the single verdict means, the exit code each outcome takes, the retained baseline and the delta it reports, and which corpora are kept out of the record
 - [Capture](capture.md): Rendering committed HTML sources to PNG, what the command asserts about fonts, and why it is toolkit-only
+- [Census](census.md): Tracked-plus-untracked file count, a breakdown by extension, and a line total that skips whatever reads as binary
 - [Command catalog](commands.md): Every project-level command and every domain subcommand, plus the shape each domain exposes
 - [Comments](comments.md): Comment density by language and kind, the two structural exclusions, and how the degradation sweep finds its vocabulary
 - [Context audit checks](context-audit-checks.md): What each non-gating check reports, the unit each checkpoint is measured in, the architecture record's length gate and claim coverage, which folders each check reaches, and what moved to the attribute tier

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@erclx/aitk",
   "type": "module",
-  "version": "3.9.0",
+  "version": "3.10.0",
   "description": "Infrastructure and quality tooling for developer workflows",
   "license": "MIT",
   "bin": {

package/src/audits/catalog.ts

@@ -405,6 +405,23 @@ function commentCounts(record: unknown): Record<string, number> | undefined {
   return { degradationHits }
 }
 
+/**
+ * Reads the census's three headline totals, leaving the extension breakdown
+ * out. The breakdown is what a caller reads for its own sake, and folding
+ * every extension into the retained baseline would grow the recorded key set
+ * with every language the tree ever picks up.
+ */
+function censusCounts(record: unknown): Record<string, number> | undefined {
+  const root = asObject(record)
+  if (root === undefined || !Array.isArray(root.byExtension)) return undefined
+
+  return allOf({
+    files: typeof root.files === 'number' ? root.files : undefined,
+    skipped: typeof root.skipped === 'number' ? root.skipped : undefined,
+    lines: typeof root.lines === 'number' ? root.lines : undefined,
+  })
+}
+
 function testOrderCounts(record: unknown): Record<string, number> | undefined {
   const root = asObject(record)
   if (root === undefined) return undefined
@@ -597,6 +614,17 @@ export const AUDITS: readonly AuditSpec[] = [
     ] satisfies RestatedRefusal[],
     counts: restatedCounts,
   },
+  {
+    id: 'census',
+    label: 'Codebase census',
+    argv: ['census', '--json'],
+    // Reports rather than gates. A file count is a measure, not a judgment, so
+    // registering it here exists to retain growth against the baseline rather
+    // than to fail a push on a number moving.
+    gatingExits: [],
+    corpus: 'tracked',
+    counts: censusCounts,
+  },
   {
     id: 'deps',
     label: 'Dependency advisories',

package/src/census/count.ts

@@ -0,0 +1,113 @@
+import { readFile } from 'node:fs/promises'
+import { extname, join } from 'node:path'
+import { isBinary } from '@/binary'
+import { listRepositoryFiles } from '@/git-files'
+
+export type CensusRefusal = 'no-git'
+
+export interface ExtensionCount {
+  readonly extension: string
+  readonly files: number
+  readonly lines: number
+}
+
+export interface CensusResult {
+  readonly kind: 'measured'
+  readonly files: number
+  /** Binary or unreadable, counted toward `files` and excluded from `lines`. */
+  readonly skipped: number
+  readonly lines: number
+  readonly byExtension: readonly ExtensionCount[]
+}
+
+export interface CensusFailure {
+  readonly kind: 'refused'
+  readonly reason: CensusRefusal
+}
+
+/**
+ * Open descriptors allowed at once while reading the tree, matching
+ * `src/comments/scan.ts`. A single `Promise.all` over every path opens one
+ * descriptor per file, which exhausts a default 1024 limit on a large
+ * repository and fails the whole census with EMFILE.
+ */
+const CONCURRENT_READS = 64
+
+interface ReadOutcome {
+  readonly path: string
+  /** Absent when the read failed: a symlink leaving the tree, or a file git
+   * listed and the working tree no longer holds. */
+  readonly text?: string
+}
+
+async function readOne(root: string, path: string): Promise<ReadOutcome> {
+  try {
+    return { path, text: await readFile(join(root, path), 'utf8') }
+  } catch {
+    return { path }
+  }
+}
+
+function extensionFor(path: string): string {
+  const ext = extname(path)
+  return ext === '' ? 'no-extension' : ext.slice(1).toLowerCase()
+}
+
+/**
+ * A trailing newline is the file's terminator rather than an empty final line,
+ * which is what keeps a file ending `a\nb\n` at two lines rather than three.
+ */
+function countLines(text: string): number {
+  if (text === '') return 0
+  const lines = text.split('\n')
+  return text.endsWith('\n') ? lines.length - 1 : lines.length
+}
+
+/**
+ * Censuses the tracked-plus-untracked tree under `root`: a file count, a
+ * breakdown by extension, and a line total that skips whatever reads as
+ * binary.
+ *
+ * Reads `listRepositoryFiles`, the same corpus the citation check, the
+ * markdown corpus, and the secret scan already share, so this is not a
+ * fourth definition of what counts.
+ */
+export async function census(
+  root: string,
+): Promise<CensusResult | CensusFailure> {
+  const listed = await listRepositoryFiles(root)
+  if (listed === undefined) return { kind: 'refused', reason: 'no-git' }
+
+  const totals = new Map<string, { files: number; lines: number }>()
+  let skipped = 0
+  let lines = 0
+
+  for (let start = 0; start < listed.length; start += CONCURRENT_READS) {
+    const batch = listed.slice(start, start + CONCURRENT_READS)
+    const outcomes = await Promise.all(batch.map((path) => readOne(root, path)))
+
+    for (const outcome of outcomes) {
+      const extension = extensionFor(outcome.path)
+      const entry = totals.get(extension) ?? { files: 0, lines: 0 }
+      entry.files += 1
+
+      // A read that failed and a file that read as binary are counted the
+      // same way: toward `files`, excluded from every line count.
+      if (outcome.text === undefined || isBinary(outcome.text)) {
+        skipped += 1
+      } else {
+        const counted = countLines(outcome.text)
+        entry.lines += counted
+        lines += counted
+      }
+
+      totals.set(extension, entry)
+    }
+  }
+
+  const byExtension = [...totals.entries()]
+    .map(([extension, counts]) => ({ extension, ...counts }))
+    .sort((a, b) => b.files - a.files || a.extension.localeCompare(b.extension))
+
+  return { kind: 'measured', files: listed.length, skipped, lines, byExtension }
+}

package/src/cli.ts

@@ -30,6 +30,7 @@ import { register as audits } from '@/commands/audits'
 import { register as secrets } from '@/commands/secrets'
 import { register as deps } from '@/commands/deps'
 import { register as labels } from '@/commands/labels'
+import { register as census } from '@/commands/census'
 import { register as upgrade } from '@/commands/upgrade'
 import { readInstalled, UNKNOWN_LABEL } from '@/version/installed'
 import { palette } from '@/ui'
@@ -71,6 +72,7 @@ function showHelp(): void {
     `${GREY}│${NC}    secrets [cmd]      ${GREY}# Read the shipped tree for credential-shaped values (scan)${NC}`,
     `${GREY}│${NC}    deps [cmd]         ${GREY}# Read the resolved dependency set for advisories (audit)${NC}`,
     `${GREY}│${NC}    labels [cmd]       ${GREY}# Read a changed set against the pull request label map (audit)${NC}`,
+    `${GREY}│${NC}    census [path]      ${GREY}# Report tracked file count, extension breakdown, and line totals${NC}`,
     `${GREY}│${NC}    audits [cmd]       ${GREY}# Run every health check as one set (run, list)${NC}`,
     `${GREY}│${NC}    upgrade            ${GREY}# Reinstall the CLI globally with the manager that installed it${NC}`,
     `${GREY}│${NC}`,
@@ -116,6 +118,7 @@ function showHelp(): void {
     `${GREY}│${NC}    aitk secrets scan --json`,
     `${GREY}│${NC}    aitk deps audit --json`,
     `${GREY}│${NC}    aitk labels audit --json`,
+    `${GREY}│${NC}    aitk census --json`,
     `${GREY}│${NC}    aitk audits run --json`,
     `${GREY}│${NC}    aitk upgrade --json`,
     `${GREY}└${NC}`,
@@ -164,6 +167,7 @@ sessions(program)
 secrets(program)
 deps(program)
 labels(program)
+census(program)
 audits(program)
 upgrade(program)
 

package/src/commands/census.ts

@@ -0,0 +1,105 @@
+import { resolve } from 'node:path'
+import type { Command } from 'commander'
+import { census, type CensusRefusal } from '@/census/count'
+import { intro, logInfo, logStep, logWarn, outro, plural } from '@/ui'
+
+interface CensusCommandOptions {
+  readonly json?: boolean
+}
+
+const REFUSALS: Record<CensusRefusal, string> = {
+  'no-git': 'git could not list this tree, so the corpus is unknown.',
+}
+
+export function register(program: Command): void {
+  program
+    .command('census')
+    .description(
+      'Report tracked file count, a breakdown by extension, and line totals',
+    )
+    .argument('[path]', 'Tree to census, defaulting to the current directory')
+    .helpOption('-h, --help', 'Show this help message')
+    .option('--json', 'Add a machine-readable record on stdout')
+    .addHelpText(
+      'after',
+      [
+        '',
+        'Scope:',
+        '  Tracked files plus untracked files git does not ignore, the same',
+        '  corpus the citation check, the markdown corpus, and the secret',
+        '  scan already read. A line total skips whatever reads as binary.',
+        '',
+        'Exit codes:',
+        '  0  the census completed',
+        '  1  refused, with the reason on stderr',
+        '',
+        'Examples:',
+        '  aitk census',
+        '  aitk census src --json',
+        '',
+      ].join('\n'),
+    )
+    .action(async (path: string | undefined, opts: CensusCommandOptions) => {
+      process.exitCode = await runCensus(path, opts)
+    })
+}
+
+async function runCensus(
+  path: string | undefined,
+  opts: CensusCommandOptions,
+): Promise<number> {
+  const root = resolve(path ?? process.cwd())
+  const emitJson = opts.json ?? false
+
+  intro('aitk census')
+
+  const result = await census(root)
+
+  if (result.kind === 'refused') {
+    logStep('Refused')
+    logWarn(REFUSALS[result.reason])
+    outro()
+
+    if (emitJson) {
+      process.stdout.write(
+        `${JSON.stringify({
+          root,
+          reason: result.reason,
+          message: REFUSALS[result.reason],
+        })}\n`,
+      )
+    }
+    return 1
+  }
+
+  logStep('Files')
+  logInfo(
+    `${plural(result.files, 'file')}, ${result.skipped} skipped as binary or unreadable`,
+  )
+
+  logStep('By extension')
+  for (const entry of result.byExtension) {
+    logInfo(
+      `${entry.extension}: ${plural(entry.files, 'file')}, ${entry.lines} lines`,
+    )
+  }
+
+  logStep('Lines')
+  logInfo(`${result.lines} counted, skipping binary or unreadable files`)
+
+  outro()
+
+  if (emitJson) {
+    process.stdout.write(
+      `${JSON.stringify({
+        root,
+        files: result.files,
+        skipped: result.skipped,
+        lines: result.lines,
+        byExtension: result.byExtension,
+      })}\n`,
+    )
+  }
+
+  return 0
+}

package/tooling/base/manifest.toml

@@ -23,8 +23,6 @@ packages = [
 "format" = "prettier --write --log-level warn --ignore-path .gitignore --ignore-path .prettierignore . && shfmt --write --indent 2 scripts/"
 "prepare" = "husky"
 "check" = "./scripts/verify.sh"
-"clean" = "./scripts/clean.sh"
-"update" = "./scripts/update.sh"
 
 [gitignore]
 "# System" = [".DS_Store"]

package/tooling/base/reference.md

@@ -2,7 +2,7 @@
 
 ## Overview
 
-The base layer covers every project the toolkit scaffolds, whatever language sits on top. It ships formatting, spelling, shell linting, conventional commits, git hooks, CI, and three maintenance scripts. Every other stack extends it, so a decision made here is one every stack inherits.
+The base layer covers every project the toolkit scaffolds, whatever language sits on top. It ships formatting, spelling, shell linting, conventional commits, git hooks, CI, and one maintenance script. Every other stack extends it, so a decision made here is one every stack inherits.
 
 A repository with several language roots layers this stack once at the root and skips it per subtree, since git honors only one `core.hooksPath` and a re-dropped husky silently breaks. `docs/target-projects.md` carries the recipe.
 
@@ -18,7 +18,7 @@ Golden config files live in `tooling/base/configs/` and are copied into the targ
 - `.github/workflows/verify.yml`: runs on pull requests targeting `main` and on `workflow_dispatch`.
 - `.github/pull_request_template.md`: `## Summary`, `## Key Changes`, `## Technical Context`, `## Testing`.
 - `.vscode/extensions.json` and `.vscode/settings.json`: editor wiring for Prettier, cspell, shfmt, and shellcheck.
-- `scripts/verify.sh`, `scripts/clean.sh`, `scripts/update.sh`: the maintenance entry points behind `check`, `clean`, and `update`.
+- `scripts/verify.sh`: the maintenance entry point behind `check`.
 
 ## What ships as user-owned seeds
 
@@ -86,13 +86,13 @@ Sticky negative knowledge. Do not relearn.
 
 ## CLI
 
-| Script                 | What it does                                                                                                                                                                                           |
-| ---------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
-| `bun run check`        | Full verification suite via `scripts/verify.sh`. Runs `format` first to auto-fix drifted code, then asserts. Honors `VERIFY_NESTED=true` to suppress timeline boundaries when another script calls it. |
-| `bun run check:format` | Asserts prettier and shfmt formatting without writing                                                                                                                                                  |
-| `bun run check:spell`  | Runs cspell across every file, with context on failures                                                                                                                                                |
-| `bun run check:shell`  | Runs shellcheck at warning severity                                                                                                                                                                    |
-| `bun run format`       | Writes prettier and shfmt formatting in place                                                                                                                                                          |
-| `bun run prepare`      | Initializes husky hooks, run automatically on `bun install`                                                                                                                                            |
-| `bun run clean`        | Removes `node_modules/`, clears the bun cache, reinstalls fresh                                                                                                                                        |
-| `bun run update`       | Runs `bun update --interactive`, then `verify.sh` with `VERIFY_NESTED=true`                                                                                                                            |
+| Script                 | What it does                                                                                                                          |
+| ---------------------- | ------------------------------------------------------------------------------------------------------------------------------------- |
+| `bun run check`        | Repairs a checkout via `scripts/verify.sh`. Honors `VERIFY_NESTED=true` to suppress timeline boundaries when another script calls it. |
+| `bun run check:format` | Asserts prettier and shfmt formatting without writing                                                                                 |
+| `bun run check:spell`  | Runs cspell across every file, with context on failures                                                                               |
+| `bun run check:shell`  | Runs shellcheck at warning severity                                                                                                   |
+| `bun run format`       | Writes prettier and shfmt formatting in place                                                                                         |
+| `bun run prepare`      | Initializes husky hooks, run automatically on `bun install`                                                                           |
+
+`bun run check` repairs a checkout rather than gating one. It runs `format` first to auto-fix drifted code, then asserts only what the formatters could not fix. The pull request workflow calls `check:format`, `check:spell`, and `check:shell` directly, and those three are the gate.

package/tooling/base/seeds/.claude/context/development.md

@@ -21,12 +21,10 @@ Owns how the project runs on a developer machine: installing the toolchain, the
 
 ## Scripts
 
-| Command          | Purpose                                              |
-| ---------------- | ---------------------------------------------------- |
-| `bun run check`  | Full verification. Auto-formats, then asserts clean. |
-| `bun run format` | Auto-fix prettier and shfmt formatting.              |
-| `bun run clean`  | Wipe `node_modules/`, clear bun cache, reinstall.    |
-| `bun run update` | Interactive `bun update` followed by verification.   |
+| Command          | Purpose                                                                        |
+| ---------------- | ------------------------------------------------------------------------------ |
+| `bun run check`  | Repairs locally. Auto-formats, then asserts what the formatters could not fix. |
+| `bun run format` | Auto-fix prettier and shfmt formatting.                                        |
 
 ## Shell scripts
 

package/tooling/base/configs/scripts/clean.sh

@@ -1,45 +0,0 @@
-#!/bin/bash
-set -e
-set -o pipefail
-
-GREEN='\033[0;32m'
-RED='\033[0;31m'
-WHITE='\033[1;37m'
-GREY='\033[0;90m'
-NC='\033[0m'
-
-log_info() { echo -e "${GREY}│${NC} ${GREEN}✓${NC} $1"; }
-log_error() {
-  echo -e "${GREY}│${NC} ${RED}✗${NC} $1"
-  exit 1
-}
-log_step() { echo -e "${GREY}│${NC}\n${GREY}├${NC} ${WHITE}$1${NC}"; }
-log_rem() { echo -e "${GREY}│${NC} ${RED}-${NC} $1"; }
-
-check_dependencies() {
-  command -v bun >/dev/null 2>&1 || log_error "bun is not installed"
-}
-
-main() {
-  check_dependencies
-
-  echo -e "${GREY}┌${NC}"
-
-  echo -e "${GREY}├${NC} ${WHITE}Cleaning artifacts${NC}"
-  rm -rf node_modules
-
-  log_rem "node_modules/"
-
-  log_step "Cleaning cache"
-  bun pm cache rm
-  log_info "Package manager cache cleared"
-
-  log_step "Rehydrating project"
-  bun install
-  log_info "Dependencies installed"
-
-  echo -e "${GREY}└${NC}\n"
-  echo -e "${GREEN}✓ Clean complete${NC}"
-}
-
-main "$@"

package/tooling/base/configs/scripts/update.sh

@@ -1,49 +0,0 @@
-#!/bin/bash
-set -e
-set -o pipefail
-
-GREEN='\033[0;32m'
-YELLOW='\033[0;33m'
-RED='\033[0;31m'
-WHITE='\033[1;37m'
-GREY='\033[0;90m'
-NC='\033[0m'
-
-log_info() { echo -e "${GREY}│${NC} ${GREEN}✓${NC} $1"; }
-log_warn() { echo -e "${GREY}│${NC} ${YELLOW}!${NC} $1"; }
-log_error() {
-  echo -e "${GREY}│${NC} ${RED}✗${NC} $1"
-  exit 1
-}
-log_step() { echo -e "${GREY}│${NC}\n${GREY}├${NC} ${WHITE}$1${NC}"; }
-
-pipe_output() { while IFS= read -r line; do echo -e "${GREY}│${NC}  $line"; done; }
-
-check_dependencies() {
-  command -v bun >/dev/null 2>&1 || log_error "bun is not installed"
-}
-
-main() {
-  SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
-
-  check_dependencies
-
-  echo -e "${GREY}┌${NC}"
-
-  echo -e "${GREY}├${NC} ${WHITE}Interactive dependency update${NC}"
-  echo -e "${GREY}│${NC}"
-  bun update --interactive
-
-  log_step "Verifying project health"
-  if [ -f "$SCRIPT_DIR/verify.sh" ]; then
-    VERIFY_NESTED=true "$SCRIPT_DIR/verify.sh"
-    log_info "All checks passed"
-  else
-    log_warn "Verification script not found, skipping."
-  fi
-
-  echo -e "${GREY}└${NC}\n"
-  echo -e "${GREEN}✓ Update complete${NC}"
-}
-
-main "$@"