@sebastienrousseau/dotfiles 0.2.502 → 0.2.503

package/scripts/docs/check-manual.sh

@@ -1,213 +0,0 @@
-#!/usr/bin/env bash
-# Copyright (c) 2015-2026 Dotfiles. All rights reserved.
-# check-manual.sh — Quality gates for docs/manual/
-#
-# Runs:
-#   - Markdown lint (markdownlint-cli2 if available)
-#   - Internal link check (custom — validates all [text](path.md) refs)
-#   - Spell check (codespell if available)
-#   - Coverage: every `dot <command>` referenced must be documented
-#
-# Usage:
-#   bash scripts/docs/check-manual.sh
-#   bash scripts/docs/check-manual.sh --strict   # fail on warnings
-
-set -euo pipefail
-
-REPO_ROOT="$(cd "$(dirname "${BASH_SOURCE[0]}")/../.." && pwd)"
-MANUAL_DIR="$REPO_ROOT/docs/manual"
-STRICT=false
-FAILS=0
-
-for arg in "$@"; do
-  case "$arg" in
-    --strict) STRICT=true ;;
-  esac
-done
-
-log() { printf '[check] %s\n' "$*"; }
-warn() {
-  printf '[check] WARN: %s\n' "$*" >&2
-  if $STRICT; then
-    FAILS=$((FAILS + 1))
-  fi
-}
-fail() {
-  printf '[check] FAIL: %s\n' "$*" >&2
-  FAILS=$((FAILS + 1))
-}
-
-# -----------------------------------------------------------------------------
-# Internal link check
-# -----------------------------------------------------------------------------
-
-check_links() {
-  log "checking internal links"
-  local broken=0
-  local mdfile path abs_path link
-  while IFS= read -r mdfile; do
-    while IFS= read -r link; do
-      [[ -z "$link" ]] && continue
-      path="${link#*(}"
-      path="${path%)*}"
-      path="${path%%#*}"
-      [[ -z "$path" ]] && continue
-      if [[ "$path" =~ ^/ ]]; then
-        abs_path="$REPO_ROOT$path"
-      else
-        abs_path="$(dirname "$mdfile")/$path"
-      fi
-      if [[ ! -f "$abs_path" ]]; then
-        # Try resolving
-        local resolved
-        resolved="$(cd "$(dirname "$mdfile")" 2>/dev/null && cd "$(dirname "$path")" 2>/dev/null && pwd)/$(basename "$path")"
-        [[ -f "$resolved" ]] && continue
-        fail "broken link in $(basename "$mdfile"): $link"
-        broken=$((broken + 1))
-      fi
-    done < <(grep -oE '\[[^]]+\]\([^)]+\.md[^)]*\)' "$mdfile" 2>/dev/null)
-  done < <(find "$MANUAL_DIR" -name '*.md' -type f)
-  [[ $broken -eq 0 ]] && log "  ✓ all internal links resolve"
-}
-
-# -----------------------------------------------------------------------------
-# Markdown lint
-# -----------------------------------------------------------------------------
-
-check_markdown_lint() {
-  if ! command -v markdownlint-cli2 &>/dev/null && ! command -v markdownlint &>/dev/null; then
-    warn "skipping markdown lint (markdownlint not installed)"
-    return
-  fi
-  log "running markdownlint"
-  local linter
-  linter="$(command -v markdownlint-cli2 || command -v markdownlint)"
-  if ! "$linter" "$MANUAL_DIR/**/*.md" 2>&1 | head -20; then
-    warn "markdown lint reported issues"
-  else
-    log "  ✓ markdown clean"
-  fi
-}
-
-# -----------------------------------------------------------------------------
-# Spell check
-# -----------------------------------------------------------------------------
-
-check_spelling() {
-  if ! command -v codespell &>/dev/null; then
-    warn "skipping spell check (codespell not installed)"
-    return
-  fi
-  log "running codespell"
-  if codespell --skip='*.toml,*.json' "$MANUAL_DIR/" 2>&1 | head -10; then
-    log "  ✓ no typos detected"
-  else
-    warn "codespell found possible typos"
-  fi
-}
-
-# -----------------------------------------------------------------------------
-# Command coverage — every `dot <cmd>` in the repo must be in CLI reference
-# -----------------------------------------------------------------------------
-
-check_command_coverage() {
-  log "checking command coverage"
-  local cli_ref="$MANUAL_DIR/03-reference/01-dot-cli.md"
-  if [[ ! -f "$cli_ref" ]]; then
-    warn "CLI reference missing"
-    return
-  fi
-
-  # Extract commands referenced in manual (single quotes intentional for grep pattern)
-  local referenced
-  # shellcheck disable=SC2016
-  referenced="$(grep -rhoE '`dot [a-z][a-z-]+`' "$MANUAL_DIR"/*.md "$MANUAL_DIR"/**/*.md 2>/dev/null |
-    sort -u |
-    sed -E 's/`dot ([a-z-]+)`/\1/')"
-
-  # Extract commands documented in CLI reference (single quotes intentional for grep pattern)
-  local documented
-  # shellcheck disable=SC2016
-  documented="$(grep -oE '^### `dot [a-z][a-z-]+`' "$cli_ref" 2>/dev/null |
-    sed -E 's/### `dot ([a-z-]+)`/\1/' |
-    sort -u)"
-
-  # Diff
-  local missing
-  missing="$(comm -23 <(echo "$referenced") <(echo "$documented") 2>/dev/null)"
-
-  if [[ -n "$missing" ]]; then
-    warn "commands referenced but not documented in CLI reference:"
-    echo "$missing" | while read -r cmd; do
-      [[ -z "$cmd" ]] && continue
-      echo "    - dot $cmd"
-    done
-  else
-    log "  ✓ all referenced commands documented"
-  fi
-}
-
-# -----------------------------------------------------------------------------
-# File structure check
-# -----------------------------------------------------------------------------
-
-check_structure() {
-  log "checking directory structure"
-  local required=(
-    "00-introduction.md"
-    "01-concepts/01-architecture.md"
-    "01-concepts/02-trust-model.md"
-    "01-concepts/03-theme-engine.md"
-    "01-concepts/04-fleet.md"
-    "01-concepts/05-self-healing.md"
-    "02-tutorials/01-first-install.md"
-    "02-tutorials/02-add-wallpaper.md"
-    "02-tutorials/03-create-profile.md"
-    "02-tutorials/04-encrypt-secret.md"
-    "02-tutorials/05-deploy-fleet.md"
-    "03-reference/01-dot-cli.md"
-    "03-reference/02-config-files.md"
-    "03-reference/03-environment.md"
-    "03-reference/04-templates.md"
-    "03-reference/05-feature-flags.md"
-    "04-cookbook/01-recipes.md"
-    "04-cookbook/02-troubleshooting.md"
-    "04-cookbook/03-faq.md"
-    "05-appendices/A-platform-matrix.md"
-    "05-appendices/B-security-checklist.md"
-    "05-appendices/C-glossary.md"
-    "05-appendices/D-bibliography.md"
-    "05-appendices/E-license.md"
-  )
-  local missing=0
-  for f in "${required[@]}"; do
-    if [[ ! -f "$MANUAL_DIR/$f" ]]; then
-      fail "missing required file: $f"
-      missing=$((missing + 1))
-    fi
-  done
-  [[ $missing -eq 0 ]] && log "  ✓ all required files present"
-}
-
-# -----------------------------------------------------------------------------
-# Main
-# -----------------------------------------------------------------------------
-
-main() {
-  log "validating $MANUAL_DIR"
-  check_structure
-  check_links
-  check_command_coverage
-  check_markdown_lint
-  check_spelling
-
-  echo ""
-  if [[ $FAILS -gt 0 ]]; then
-    printf '[check] FAILED: %d issue(s)\n' "$FAILS" >&2
-    exit 1
-  else
-    log "all checks passed"
-  fi
-}
-
-main

package/scripts/dot/lib/bento.sh

@@ -1,50 +0,0 @@
-#!/usr/bin/env bash
-# Copyright (c) 2015-2026 Dotfiles. All rights reserved.
-# Sourced by scripts/dot/commands/*.sh and dot_local/bin/executable_dot; inherits set -euo pipefail.
-# Dotfiles 2026: Atomic Intelligence Surface
-# High-fidelity, perfectly aligned, and professional.
-
-_dotfiles_bento_render() {
-  # Catppuccin Mocha palette — consistent with the project's terminal theme
-  # so the bento card matches the user's configured color scheme.
-  local c_cyan='\x1b[38;2;0;255;255m'    # Accent: header + bullet markers
-  local c_gray='\x1b[38;2;147;153;178m'  # Overlay1: metric labels (subdued)
-  local c_blue='\x1b[38;2;116;199;236m'  # Sapphire: metric values (readable)
-  local c_slate='\x1b[38;2;49;50;68m'    # Surface0: dividers (near-invisible)
-  local c_green='\x1b[38;2;166;227;161m' # Green: status confirmations
-  local c_reset='\x1b[0m'
-  local c_bold='\x1b[1m'
-
-  # Detect OS to show platform-specific icon in the bento card
-  local os_name="Linux"
-  local os_icon=""
-  case "$(uname)" in
-    Darwin)
-      os_name="macOS"
-      os_icon=""
-      ;;
-    *)
-      [[ -f /proc/sys/kernel/osrelease ]] && grep -qiE '(microsoft|wsl)' /proc/sys/kernel/osrelease && os_name="WSL"
-      os_icon=""
-      ;;
-  esac
-
-  # Render a fixed-width card (42 cols) so output aligns in any terminal width
-  printf "\n"
-  printf "  ${c_cyan}${c_bold}💎  D O T F I L E S${c_reset}  ${c_slate}[v0.2.502]${c_reset}\n"
-  printf "  ${c_slate}──────────────────────────────────────────${c_reset}\n"
-
-  # Key system properties at a glance — answers "is my env healthy?" in 1 second
-  printf "  ${c_cyan}•${c_reset} ${c_gray}%-12s${c_reset}  ${c_blue}rousseau @ %s (%s)${c_reset}\n" "Platform" "$os_name" "$os_icon"
-  printf "  ${c_cyan}•${c_reset} ${c_gray}%-12s${c_reset}  ${c_blue}Hardened (GPG/SOPS/Enclave)${c_reset}\n" "Security"
-  printf "  ${c_cyan}•${c_reset} ${c_gray}%-12s${c_reset}  ${c_blue}Idempotent • Deterministic${c_reset}\n" "Strategy"
-  printf "  ${c_cyan}•${c_reset} ${c_gray}%-12s${c_reset}  ${c_blue}Active (Vault Synced)${c_reset}\n" "Cloud"
-  printf "  ${c_cyan}•${c_reset} ${c_gray}%-12s${c_reset}  ${c_blue}60fps UI • <45ms Initial${c_reset}\n" "Latency"
-
-  # Footer confirms shell startup strategy — reassures user the env is optimized
-  printf "  ${c_slate}──────────────────────────────────────────${c_reset}\n"
-  printf "  ${c_green}✓ Hydrated${c_reset}  ${c_slate}•${c_reset}  ${c_green}Zero-Jank Async${c_reset}  ${c_slate}•${c_reset}  ${c_cyan}Atomic${c_reset}\n"
-  printf "\n"
-}
-
-_dotfiles_bento_render

package/scripts/dot/lib/log.sh

@@ -1,200 +0,0 @@
-#!/usr/bin/env bash
-# Copyright (c) 2015-2026 Dotfiles. All rights reserved.
-# Sourced by scripts/dot/commands/*.sh and scripts/diagnostics/*; inherits set -euo pipefail.
-# Structured JSON logging and metrics library.
-# Source this file to emit machine-readable logs and performance metrics.
-#
-# Usage:
-#   source "$(dirname "${BASH_SOURCE[0]}")/log.sh"
-#   dot_log info "apply_start" "source=chezmoi"
-#   dot_metric "shell_startup" 142 ms
-
-# Re-source guard: re-sourcing would mint a new DOT_TRACE_ID and break
-# correlation across modules that already captured the original.
-[[ "${_DOT_LIB_LOG_LOADED:-0}" == "1" ]] && return 0
-_DOT_LIB_LOG_LOADED=1
-
-# Correlation ID for tracing across commands in a single invocation
-DOT_TRACE_ID="${DOT_TRACE_ID:-$(date +%s%N 2>/dev/null | tail -c 12 || date +%s)}"
-export DOT_TRACE_ID
-
-_DOT_LOG_STATE_DIR="${XDG_STATE_HOME:-$HOME/.local/state}/dotfiles"
-
-dot_agent_checkpoint_dir() {
-  printf '%s\n' "$_DOT_LOG_STATE_DIR/checkpoints"
-}
-
-dot_jsonl_append() {
-  local file="$1" payload="$2"
-  mkdir -p "$_DOT_LOG_STATE_DIR" 2>/dev/null || return 0
-  printf '%s\n' "$payload" >>"$_DOT_LOG_STATE_DIR/$file" 2>/dev/null || true
-}
-
-# Always-on file logging (appends to dot.log, rotates at 1MB)
-dot_log_file() {
-  local level="$1" event="$2"
-  shift 2
-  local log_file="$_DOT_LOG_STATE_DIR/dot.log"
-  mkdir -p "$_DOT_LOG_STATE_DIR" 2>/dev/null || return 0
-  # Rotate at 1MB
-  if [[ -f "$log_file" ]]; then
-    local size
-    size=$(stat -c '%s' "$log_file" 2>/dev/null || stat -f '%z' "$log_file" 2>/dev/null || echo 0)
-    if [[ "$size" -gt 1048576 ]]; then
-      mv "$log_file" "${log_file}.1" 2>/dev/null || true
-    fi
-  fi
-  printf '[%s] [%s] [%s] %s' \
-    "$(date -u +%Y-%m-%dT%H:%M:%SZ)" "$level" "$DOT_TRACE_ID" "$event" >>"$log_file" 2>/dev/null || return 0
-  while [[ $# -gt 0 ]]; do
-    printf ' %s' "$1" >>"$log_file" 2>/dev/null || return 0
-    shift
-  done
-  printf '\n' >>"$log_file" 2>/dev/null || true
-}
-
-# Structured log entry (JSON when DOTFILES_JSON_LOG=1, silent otherwise)
-# Always writes to file log
-dot_log() {
-  local level="$1" event="$2"
-  shift 2
-  local ts
-  ts="$(date -u +%Y-%m-%dT%H:%M:%SZ)"
-  # Always-on file logging
-  dot_log_file "$level" "$event" "$@"
-  # JSON stdout logging when enabled
-  if [[ "${DOTFILES_JSON_LOG:-0}" = "1" ]]; then
-    printf '{"time":"%s","level":"%s","event":"%s","command":"%s","trace_id":"%s"' \
-      "$ts" "$level" "$event" "${DOT_COMMAND:-unknown}" "$DOT_TRACE_ID"
-    while [[ $# -gt 0 ]]; do
-      printf ',"%s":"%s"' "${1%%=*}" "${1#*=}"
-      shift
-    done
-    printf '}\n'
-  fi
-}
-
-# Metrics emission (append to JSONL metrics file)
-dot_metric() {
-  local name="$1" value="$2" unit="${3:-ms}"
-  local ts
-  ts="$(date -u +%Y-%m-%dT%H:%M:%SZ)"
-  local metrics_file="$_DOT_LOG_STATE_DIR/metrics.jsonl"
-  mkdir -p "$_DOT_LOG_STATE_DIR" 2>/dev/null || return 0
-  printf '{"time":"%s","metric":"%s","value":%s,"unit":"%s","trace_id":"%s"}\n' \
-    "$ts" "$name" "$value" "$unit" "$DOT_TRACE_ID" >>"$metrics_file" 2>/dev/null || true
-}
-
-# Print recent metrics (for `dot metrics` command)
-dot_metrics_summary() {
-  local metrics_file="$_DOT_LOG_STATE_DIR/metrics.jsonl"
-  local count="${1:-20}"
-  if [[ ! -f "$metrics_file" ]]; then
-    echo "No metrics collected yet."
-    echo "Metrics are recorded at: $metrics_file"
-    return 0
-  fi
-  tail -n "$count" "$metrics_file"
-}
-
-dot_agent_session_log() {
-  local event="$1" profile="$2" status="${3:-ok}"
-  shift 3 || true
-  local ts payload
-  ts="$(date -u +%Y-%m-%dT%H:%M:%SZ)"
-  payload=$(printf '{"time":"%s","event":"%s","profile":"%s","status":"%s","trace_id":"%s","command":"%s"' \
-    "$ts" "$event" "$profile" "$status" "$DOT_TRACE_ID" "${DOT_COMMAND:-unknown}")
-  while [[ $# -gt 0 ]]; do
-    payload+=$(printf ',"%s":"%s"' "${1%%=*}" "${1#*=}")
-    shift
-  done
-  payload+='}'
-  dot_jsonl_append "agent-sessions.jsonl" "$payload"
-}
-
-dot_agent_session_tail() {
-  local count="${1:-20}"
-  local sessions_file="$_DOT_LOG_STATE_DIR/agent-sessions.jsonl"
-  if [[ ! -f "$sessions_file" ]]; then
-    echo "No agent sessions recorded yet."
-    echo "Agent sessions are recorded at: $sessions_file"
-    return 0
-  fi
-  tail -n "$count" "$sessions_file"
-}
-
-dot_agent_checkpoint_create() {
-  local profile="$1" status="${2:-ready}"
-  shift 2 || true
-
-  local checkpoint_dir checkpoint_id checkpoint_file created_at
-  local argv_json='[]'
-  checkpoint_dir="$(dot_agent_checkpoint_dir)"
-  checkpoint_id="${DOT_AGENT_CHECKPOINT_ID:-$(date -u +%Y%m%dT%H%M%SZ)-${DOT_TRACE_ID}}"
-  checkpoint_file="$checkpoint_dir/${checkpoint_id}.json"
-  created_at="$(date -u +%Y-%m-%dT%H:%M:%SZ)"
-
-  mkdir -p "$checkpoint_dir" 2>/dev/null || return 0
-
-  if [[ "$#" -gt 0 ]] && command -v jq >/dev/null 2>&1; then
-    argv_json="$(printf '%s\n' "$@" | jq -R . | jq -s .)"
-  fi
-
-  if command -v jq >/dev/null 2>&1; then
-    jq -n \
-      --arg id "$checkpoint_id" \
-      --arg time "$created_at" \
-      --arg profile "$profile" \
-      --arg status "$status" \
-      --arg trace_id "$DOT_TRACE_ID" \
-      --arg command "${DOT_COMMAND:-unknown}" \
-      --arg cwd "$(pwd)" \
-      --arg approval "${DOT_AGENT_APPROVAL:-}" \
-      --arg filesystem "${DOT_AGENT_FILESYSTEM:-}" \
-      --arg network "${DOT_AGENT_NETWORK:-}" \
-      --arg mcp_profile "${DOT_AGENT_MCP_PROFILE:-}" \
-      --arg max_steps "${DOT_AGENT_MAX_STEPS:-}" \
-      --argjson argv "$argv_json" \
-      '{
-        id: $id,
-        created_at: $time,
-        profile: $profile,
-        status: $status,
-        trace_id: $trace_id,
-        command: $command,
-        cwd: $cwd,
-        argv: $argv,
-        env: {
-          approval: $approval,
-          filesystem: $filesystem,
-          network: $network,
-          mcp_profile: $mcp_profile,
-          max_steps: $max_steps
-        }
-      }' >"$checkpoint_file"
-  else
-    printf '{"id":"%s","created_at":"%s","profile":"%s","status":"%s","trace_id":"%s","command":"%s"}\n' \
-      "$checkpoint_id" "$created_at" "$profile" "$status" "$DOT_TRACE_ID" "${DOT_COMMAND:-unknown}" >"$checkpoint_file"
-  fi
-
-  printf '%s\n' "$checkpoint_file"
-}
-
-# Convenience wrappers for human-readable log output.
-# Source this file and call log_info/log_warn/log_error/log_success instead of
-# ui_info/ui_warn/ui_err/ui_ok when the caller prefers semantic log names.
-log_info() { ui_info "$*"; }
-log_warn() { ui_warn "$*"; }
-log_error() { ui_err "$*"; }
-log_success() { ui_ok "$*"; }
-
-dot_agent_checkpoint_tail() {
-  local count="${1:-20}"
-  local checkpoint_dir file
-  checkpoint_dir="$(dot_agent_checkpoint_dir)"
-  [[ -d "$checkpoint_dir" ]] || return 0
-  find "$checkpoint_dir" -maxdepth 1 -type f -name '*.json' | sort | tail -n "$count" | while IFS= read -r file; do
-    [[ -n "$file" ]] || continue
-    cat "$file"
-  done
-}

package/scripts/dot/lib/platform.sh

@@ -1,112 +0,0 @@
-#!/usr/bin/env bash
-# Copyright (c) 2015-2026 Dotfiles. All rights reserved.
-# Sourced by scripts/dot/commands/*.sh; inherits set -euo pipefail.
-# Dotfiles CLI Platform Abstraction
-# Unified helpers for macOS, Linux, and WSL parity.
-
-set -euo pipefail
-
-if ! declare -F dot_is_wsl >/dev/null; then
-  dot_is_wsl() {
-    [[ -f /proc/sys/kernel/osrelease ]] && grep -qiE '(microsoft|wsl)' /proc/sys/kernel/osrelease
-  }
-fi
-
-dot_platform_id() {
-  case "$(uname -s)" in
-    Darwin) printf "%s\n" "macos" ;;
-    Linux)
-      if dot_is_wsl; then
-        printf "%s\n" "wsl"
-      else
-        printf "%s\n" "linux"
-      fi
-      ;;
-    *) printf "%s\n" "unknown" ;;
-  esac
-}
-
-dot_host_os() {
-  if dot_is_wsl; then
-    printf "%s\n" "windows"
-    return
-  fi
-  case "$(uname -s)" in
-    Darwin) printf "%s\n" "macos" ;;
-    Linux) printf "%s\n" "linux" ;;
-    *) printf "%s\n" "unknown" ;;
-  esac
-}
-
-# Convert host-native path into Linux path when inside WSL.
-#
-# Contract:
-#   - In WSL: requires `wslpath`. Returns 2 (with a stderr error) if
-#     missing — callers must not silently treat a Windows-style path
-#     as Linux-safe.
-#   - Outside WSL: paths are already Linux/macOS paths; echoes the
-#     input unchanged and returns 0.
-#   - Empty input returns 1 (usage error).
-dot_path_to_unix() {
-  local p="${1:-}"
-  [[ -n "$p" ]] || return 1
-  if dot_is_wsl; then
-    if ! command -v wslpath >/dev/null 2>&1; then
-      printf "dot_path_to_unix: wslpath required in WSL but not found\n" >&2
-      return 2
-    fi
-    wslpath -u "$p"
-    return
-  fi
-  printf "%s\n" "$p"
-}
-
-# Convert Linux path into host-native path when inside WSL.
-# Same contract as dot_path_to_unix (see above).
-dot_path_to_native() {
-  local p="${1:-}"
-  [[ -n "$p" ]] || return 1
-  if dot_is_wsl; then
-    if ! command -v wslpath >/dev/null 2>&1; then
-      printf "dot_path_to_native: wslpath required in WSL but not found\n" >&2
-      return 2
-    fi
-    wslpath -w "$p"
-    return
-  fi
-  printf "%s\n" "$p"
-}
-
-dot_open_path() {
-  local target="${1:-}"
-  [[ -n "$target" ]] || return 1
-
-  case "$(dot_platform_id)" in
-    macos)
-      command open "$target"
-      ;;
-    wsl)
-      if command -v wslview >/dev/null 2>&1; then
-        wslview "$target"
-      else
-        explorer.exe "$(dot_path_to_native "$target")"
-      fi
-      ;;
-    linux)
-      xdg-open "$target"
-      ;;
-    *)
-      return 1
-      ;;
-  esac
-}
-
-dot_require_platform() {
-  local current
-  current="$(dot_platform_id)"
-  for allowed in "$@"; do
-    [[ "$current" == "$allowed" ]] && return 0
-  done
-  echo "  ! This command requires $* (detected: $current)" >&2
-  exit 2
-}