geet-geet 0.1.0

package/lib/doctor.sh

@@ -0,0 +1,252 @@
+# doctor.sh — sanity checks for this repo + template layers
+# Usage:
+#   source doctor.sh
+#   doctor
+#
+# Read-only health checks to catch common setup issues
+
+doctor() {
+
+# Show help if requested
+if [[ "${1:-}" == "help" || "${1:-}" == "-h" || "${1:-}" == "--help" ]]; then
+  cat <<EOF
+$GEET_ALIAS doctor — run health checks on your geet setup
+
+Goal:
+  - Help you quickly answer: "Is this repo set up correctly?"
+  - Catch common foot-guns (especially committing dot-git/)
+
+What it checks:
+  ✅ App repo exists (.git)
+  ✅ Layer scripts present (git.sh, init.sh, etc.)
+  ✅ Template git repo exists (dot-git/)
+  ✅ Whitelist files exist (.geetinclude, .geetexclude)
+  ✅ dot-git/ is NOT tracked by app repo (critical!)
+  ✅ Detects other template layers
+
+This is READ-ONLY:
+  - Does not modify any files
+  - Does not run merges/resets/cleans
+  - Safe to run anytime
+
+Usage:
+  $GEET_ALIAS doctor
+
+Exit code:
+  0 - All checks passed
+  1 - One or more issues found
+
+Examples:
+  $GEET_ALIAS doctor  # Run all checks
+EOF
+  return 0
+fi
+
+# digest-and-locate.sh provides: APP_DIR, TEMPLATE_DIR, DOTGIT, TEMPLATE_NAME,
+# TEMPLATE_GEETINCLUDE, TEMPLATE_GEETEXCLUDE, GEET_LIB, die, log, debug
+
+# Additional paths
+APP_GIT="$APP_DIR/.git"
+
+# Pretty printing helpers
+ok()   { echo "[$TEMPLATE_NAME doctor] ✅ $*"; }
+warn() { echo "[$TEMPLATE_NAME doctor] ⚠️  $*" >&2; }
+bad()  { echo "[$TEMPLATE_NAME doctor] ❌ $*" >&2; }
+info() { echo "[$TEMPLATE_NAME doctor]    $*"; }
+
+# Track whether we should exit nonzero
+HAS_ERRORS=0
+fail() { bad "$*"; HAS_ERRORS=1; }
+
+###############################################################################
+# Helpers
+###############################################################################
+
+# Returns 0 if command exists
+have() { command -v "$1" >/dev/null 2>&1; }
+
+# Print a short list of dot-directories that look like layers
+# A "layer" is defined as: hidden dir at repo root containing git.sh
+detect_layers() {
+  # Only look one level deep, and only at hidden dirs.
+  # (We intentionally ignore .git and other common dotdirs.)
+  find "$APP_DIR" -maxdepth 1 -mindepth 1 -type d -name ".*" 2>/dev/null \
+    | while IFS= read -r d; do
+        base="$(basename "$d")"
+        case "$base" in
+          .|..|.git) continue ;;
+        esac
+        if [[ -f "$d/lib/git.sh" && -f "$d/lib/init.sh" ]]; then
+          echo "$d"
+        fi
+      done | sort
+}
+
+# Check whether a path is tracked by the APP repo (not ignored).
+# If it is tracked, that's a big red flag for dot-git.
+app_tracks_path() {
+  local path="$1"
+  git -C "$APP_DIR" ls-files --error-unmatch -- "$path" >/dev/null 2>&1
+}
+
+###############################################################################
+# Start
+###############################################################################
+
+info "repo root: $APP_DIR"
+info "this layer: $TEMPLATE_NAME"
+
+echo
+
+###############################################################################
+# 1) Basic file presence
+###############################################################################
+
+if [[ -d "$APP_GIT" && -f "$APP_GIT/HEAD" ]]; then
+  ok "app repo present (.git exists)"
+else
+  fail "app repo missing or invalid: $APP_GIT"
+fi
+
+if [[ -f "$GEET_LIB/git.sh" ]]; then
+  ok "layer git wrapper present: $GEET_LIB/git.sh"
+else
+  fail "missing layer git wrapper: $GEET_LIB/git.sh"
+fi
+
+if [[ -f "$GEET_LIB/init.sh" ]]; then
+  ok "layer init script present"
+else
+  fail "missing layer init script"
+fi
+
+# Check for post-init hook
+POST_INIT_SH="$LAYER_DIR/post-init.sh"
+if [[ -f "$POST_INIT_SH" ]]; then
+  if [[ -x "$POST_INIT_SH" ]]; then
+    ok "post-init hook present and executable: $POST_INIT_SH"
+  else
+    warn "post-init hook exists but is NOT executable: $POST_INIT_SH"
+    info "fix with: chmod +x $POST_INIT_SH"
+  fi
+fi
+
+
+echo
+
+###############################################################################
+# 2) Layer initialization state
+###############################################################################
+
+if [[ -d "$DOTGIT" && -f "$DOTGIT/HEAD" ]]; then
+  ok "layer initialized (dot-git exists)"
+else
+  warn "layer NOT initialized (missing $DOTGIT/HEAD)"
+  info "run: $LAYER_NAME init"
+fi
+
+# If dot-git exists, make sure compiled exclude exists (after git.sh runs at least once)
+if [[ -d "$DOTGIT" && -f "$DOTGIT/HEAD" ]]; then
+  if [[ -f "$TEMPLATE_DIR/.geetexclude" ]]; then
+    ok "compiled exclude present: $TEMPLATE_DIR/.geetexclude"
+  else
+    warn "compiled exclude missing: $TEMPLATE_DIR/.geetexclude"
+    info "run: $LAYER_NAME status   (this compiles include/exclude rules)"
+  fi
+fi
+
+echo
+
+###############################################################################
+# 3) Critical safety: dot-git must NOT be tracked by app repo
+###############################################################################
+
+# dot-git is a git database; committing it is disastrous.
+# We warn hard if it's tracked or if ignore rules look missing.
+if [[ -d "$DOTGIT" ]]; then
+  # If ANY files under dot-git are tracked, that's a serious problem.
+  # Check the exact path relative to root
+  rel_dotgit="${DOTGIT#"$ROOT/"}"
+
+  if app_tracks_path "$rel_dotgit" || git -C "$ROOT" ls-files -- "$rel_dotgit" | grep -q .; then
+    fail "SECURITY: app repo is tracking $rel_dotgit (must be ignored; remove from git history)"
+    info "fix (careful):"
+    info "  git rm -r --cached -- \"$rel_dotgit\""
+    info "  add to app .geetexclude: **/dot-git/"
+  else
+    ok "dot-git is not tracked by app repo"
+  fi
+
+  # Also check that app ignore rules contain something like dot-git
+  # This is a heuristic (gitignore can be split across files), so it's a warning not failure.
+  if [[ -f "$ROOT/.geetexclude" ]]; then
+    if grep -Eq '(^|\s)(\*\*/dot-git/|\.geet/dot-git/|dot-git/)\s*$' "$ROOT/.geetexclude"; then
+      ok "app .geetexclude appears to ignore dot-git/"
+    else
+      warn "app .geetexclude does not obviously ignore dot-git/ (recommended: **/dot-git/)"
+    fi
+  else
+    warn "app .geetexclude missing (recommended: ignore **/dot-git/)"
+  fi
+fi
+
+echo
+
+###############################################################################
+# 4) Light functional checks (read-only)
+###############################################################################
+# These checks make sure the layer git wrapper can talk to the layer repo
+# WITHOUT modifying anything.
+
+if [[ -d "$DOTGIT" && -f "$DOTGIT/HEAD" ]]; then
+  if "$GEET_LIB/git.sh" rev-parse --is-inside-work-tree >/dev/null 2>&1; then
+    ok "layer git wrapper can run git commands"
+  else
+    fail "layer git wrapper failed to run git (check permissions, env, or dot-git validity)"
+  fi
+
+  # Check that HEAD resolves
+  if "$GEET_LIB/git.sh" rev-parse HEAD >/dev/null 2>&1; then
+    ok "layer HEAD resolves"
+  else
+    warn "layer HEAD does not resolve yet (maybe no commits in layer repo)"
+    info "after defining whitelist and committing, this will become OK"
+  fi
+fi
+
+echo
+
+###############################################################################
+# 5) Report other detected layers (informational)
+###############################################################################
+info "detected layers at repo root:"
+layers="$(detect_layers || true)"
+if [[ -z "$layers" ]]; then
+  info "  (none found)"
+else
+  while IFS= read -r d; do
+    base="$(basename "$d")"
+    name="${base#.}"
+    dotgit="$d/dot-git"
+    if [[ -f "$dotgit/HEAD" ]]; then
+      info "  .$name  (initialized)"
+    else
+      info "  .$name  (not initialized)"
+    fi
+  done <<< "$layers"
+fi
+
+echo
+
+###############################################################################
+# Exit status
+###############################################################################
+if [[ "$HAS_ERRORS" -eq 1 ]]; then
+  bad "doctor found errors"
+  return 1
+fi
+
+ok "doctor looks good"
+return 0
+
+}  # end of doctor()

package/lib/flags.sh

@@ -0,0 +1,52 @@
+# has-flag.sh
+
+has_flag() {
+  local flag="$1"
+  local outvar="$2"
+
+  local -a cleaned=()
+  local found=""
+
+  for arg in "${GEET_ARGS[@]}"; do
+    if [[ $arg == "$flag" ]]; then
+      found="true"
+    else
+      cleaned+=("$arg")
+    fi
+  done
+
+  GEET_ARGS=("${cleaned[@]}")
+  local -n out="$outvar"
+  out="$found"
+}
+
+extract_flag() {
+  local flag="$1"
+  local outvar="$2"
+
+  local -a cleaned=()
+  local value=""
+  local i=0
+
+  while (( i < ${#GEET_ARGS[@]} )); do
+    local arg="${GEET_ARGS[i]}"
+
+    if [[ $arg == "$flag" ]]; then
+      # consume optional value
+      if (( i+1 < ${#GEET_ARGS[@]} )); then
+        value="${GEET_ARGS[i+1]}"
+        i=$((i+2))
+      else
+        i=$((i+1))
+      fi
+      continue
+    fi
+
+    cleaned+=("$arg")
+    i=$((i+1))
+  done
+
+  GEET_ARGS=("${cleaned[@]}")
+  local -n out="$outvar"
+  out="$value"
+}

package/lib/ghcli.sh

@@ -0,0 +1,386 @@
+# ghcli.sh — GitHub CLI integration for geet
+# Usage:
+#   source ghcli.sh
+#   ghcli <subcommand> [args...]
+
+
+# digest-and-locate.sh provides: APP_DIR, TEMPLATE_NAME, TEMPLATE_GH_USER,
+# TEMPLATE_GH_NAME, TEMPLATE_GH_URL, GEET_ALIAS, die, log
+
+info() { echo "[$TEMPLATE_NAME gh] $*" >&2; }
+
+###############################################################################
+# CHECKS
+###############################################################################
+
+# Check if gh is installed
+check_gh_installed() {
+  command -v gh >/dev/null 2>&1
+}
+
+# Check if gh is authenticated
+check_gh_authenticated() {
+  gh auth status >/dev/null 2>&1
+}
+
+# Ensure gh is installed and authenticated (auto-setup if needed)
+ensure_gh_ready() {
+  local needs_setup=0
+
+  if ! check_gh_installed; then
+    needs_setup=1
+  elif ! check_gh_authenticated; then
+    needs_setup=1
+  fi
+
+  if [[ "$needs_setup" -eq 1 ]]; then
+    log "gh CLI not ready, running setup..."
+    setup_cmd
+  fi
+}
+
+###############################################################################
+# COMMANDS
+###############################################################################
+
+setup_cmd() {
+  log "checking GitHub CLI setup..."
+
+  # Check if gh is installed
+  if ! check_gh_installed; then
+    log "gh CLI not found"
+    log "installing gh CLI..."
+
+    # Detect package manager
+    if command -v apt >/dev/null 2>&1; then
+      log "using apt package manager"
+      sudo apt update
+      sudo apt install -y gh
+    elif command -v brew >/dev/null 2>&1; then
+      log "using homebrew package manager"
+      brew install gh
+    elif command -v dnf >/dev/null 2>&1; then
+      log "using dnf package manager"
+      sudo dnf install -y gh
+    elif command -v yum >/dev/null 2>&1; then
+      log "using yum package manager"
+      sudo yum install -y gh
+    else
+      die "could not detect package manager (apt, brew, dnf, yum). Please install gh manually: https://cli.github.com/"
+    fi
+
+    # Verify installation
+    if ! check_gh_installed; then
+      die "gh installation failed"
+    fi
+
+    log "gh CLI installed successfully"
+  else
+    log "gh CLI already installed: $(gh --version | head -1)"
+  fi
+
+  # Check authentication
+  if ! check_gh_authenticated; then
+    log "gh CLI not authenticated"
+    log "starting authentication flow..."
+    gh auth login
+
+    # Verify authentication
+    if ! check_gh_authenticated; then
+      die "gh authentication failed"
+    fi
+
+    log "gh CLI authenticated successfully"
+  else
+    log "gh CLI already authenticated"
+    gh auth status
+  fi
+
+  log "GitHub CLI setup complete!"
+}
+
+publish_app() {
+  GEET_ARGS=("$@")
+
+  log "here in publish app with $APP_DIR and $APP_NAME"
+  # Auto-setup if needed
+  ensure_gh_ready
+
+  # Get GitHub username
+  get_gh_user
+
+  log "publishing app repository to GitHub..."
+  log "  source: $APP_NAME"
+  log "  name: $APP_NAME"
+  log "  owner: $GH_USER"
+
+  local APP_HOMEPAGE=${APP_HOMEPAGE:-};
+  local APP_DESC=${APP_DESC:-};
+  extract_flag --homepage _HOMEPAGE
+  extract_flag --desc _DESC
+
+  local PUB_APP=""
+  local PRI_APP=""
+  local INT_APP=""
+
+  has_flag --public PUB_APP
+  has_flag --private PRI_APP
+  has_flag --internal INT_APP
+
+  # Determine publish visibility
+  local publish_visibility="public"
+  if [[ -n "$PUB_APP" ]]; then
+    publish_visibility="public"
+  elif [[ -n "$PRI_APP" ]]; then
+    publish_visibility="private"
+  elif [[ -n "$INT_APP" ]]; then
+    publish_visibility="internal"
+  fi
+
+  [[ -n "$_DESC" ]] && APP_DESC="$_DESC";
+  [[ -n "$_HOMEPAGE" ]] && APP_HOMEPAGE="$_HOMEPAGE";
+
+  # Build args for gh repo create
+  local -a gh_args=(
+    repo
+    create
+    "$APP_NAME"
+    --source
+    .
+    --description
+    "$APP_DESC"
+    "--$publish_visibility"
+    --push
+  )
+
+  # Add any extra args passed by user
+  if [[ $# -gt 0 ]]; then
+    gh_args+=("${GEET_ARGS[@]}")
+  fi
+
+  if [[ -n "$APP_HOMEPAGE" ]]; then
+    gh_args+=("--homepage")
+    gh_args+=("$APP_HOMEPAGE")
+  fi
+
+  log "calling \`${gh_args[@]}\`"
+
+  # Run gh repo create from APP_DIR
+  (
+    cd "$APP_DIR"
+    gh "${gh_args[@]}"
+  )
+
+  log "app repository published successfully"
+}
+
+publish_template() {
+  GEET_ARGS=("$@")
+  # Auto-setup if needed
+  ensure_gh_ready
+
+  [[ -z "$TEMPLATE_DIR" ]] && die "TEMPLATE_DIR not set - cannot publish template"
+
+  # Get GitHub username
+  get_gh_user
+
+  # Get the repo name - use TEMPLATE_GH_NAME if set, otherwise derive from TEMPLATE_NAME
+  local template_repo_name
+  if [[ -n "$TEMPLATE_GH_NAME" ]]; then
+    template_repo_name="$TEMPLATE_GH_NAME"
+  elif [[ -n "$TEMPLATE_NAME" ]]; then
+    template_repo_name="$TEMPLATE_NAME"
+  else
+    template_repo_name="$(basename "$TEMPLATE_DIR")"
+  fi
+
+  # Remove leading period if present
+  template_repo_name="${template_repo_name#.}"
+
+  log "publishing template repository to GitHub..."
+  log "  source: $TEMPLATE_DIR"
+  log "  name: $template_repo_name"
+  log "  owner: $GH_USER"
+
+  TEMPLATE_HOMEPAGE=${TEMPLATE_HOMEPAGE:-};
+  TEMPLATE_DESC=${TEMPLATE_DESC:-};
+  TEMPLATE_TOPICS=${TEMPLATE_TOPICS:-"geet,template"};
+  extract_flag --topics _TOPICS
+  extract_flag --homepage _HOMEPAGE
+  extract_flag --desc _DESC
+
+  local PUB_APP=""
+  local PRI_APP=""
+  local INT_APP=""
+
+  has_flag --public PUB_APP
+  has_flag --private PRI_APP
+  has_flag --internal INT_APP
+
+  # Determine publish visibility
+  local publish_visibility="public"
+  if [[ -n "$PUB_APP" ]]; then
+    publish_visibility="public"
+  elif [[ -n "$PRI_APP" ]]; then
+    publish_visibility="private"
+  elif [[ -n "$INT_APP" ]]; then
+    publish_visibility="internal"
+  fi
+
+  [[ -n "$_DESC" ]] && TEMPLATE_DESC="$_DESC";
+  [[ -n "$_HOMEPAGE" ]] && TEMPLATE_HOMEPAGE="$_HOMEPAGE";
+  [[ -n "$_TOPICS" ]] && TEMPLATE_TOPICS="$_TOPICS";
+
+  # Clean up topics: remove trailing commas, trim whitespace
+  TEMPLATE_TOPICS="${TEMPLATE_TOPICS%,}"  # Remove trailing comma
+  TEMPLATE_TOPICS="${TEMPLATE_TOPICS#,}"  # Remove leading comma
+  TEMPLATE_TOPICS="${TEMPLATE_TOPICS// /}" # Remove spaces
+
+  # Set default if empty
+  [[ -z "$TEMPLATE_TOPICS" ]] && TEMPLATE_TOPICS="geet,template"
+
+  # Build args for gh repo create (without --source and --push, we'll handle that manually)
+  local -a gh_args=(
+    repo
+    create
+    "$template_repo_name"
+    --description
+    "$TEMPLATE_DESC"
+    "--$publish_visibility"
+  )
+
+  # Add any extra args passed by user
+  if [[ $# -gt 0 ]]; then
+    gh_args+=("$@")
+  fi
+
+  if [[ -n "$TEMPLATE_HOMEPAGE" ]]; then
+    gh_args+=("--homepage")
+    gh_args+=("$TEMPLATE_HOMEPAGE")
+  fi
+
+  log "calling \`${gh_args[@]}\`"
+
+  # Create the remote repo
+  gh "${gh_args[@]}"
+
+  log "configuring template settings..."
+  gh repo edit "$GH_USER/$template_repo_name" --template
+  gh repo edit "$GH_USER/$template_repo_name" --add-topic "$TEMPLATE_TOPICS"
+
+  log "adding remote and pushing using geet_git..."
+
+  # Get the remote URL
+  local remote_url
+  remote_url="$(gh repo view "$GH_USER/$template_repo_name" --json sshUrl -q .sshUrl)"
+
+  log "remote URL: $remote_url"
+
+  # Add remote and push using geet_git (which handles custom git setup)
+  geet_git remote add origin "$remote_url" 2>/dev/null || geet_git remote set-url origin "$remote_url"
+  geet_git push -u origin HEAD
+
+  log "template repository published successfully"
+}
+
+publish_cmd() {
+  local subcommand="${1:-}"
+
+  case "$subcommand" in
+    app)
+      shift
+      publish_app "$@"
+      ;;
+    template)
+      shift
+      publish_template "$@"
+      ;;
+    -h|--help|help)
+      cat <<EOF
+[$TEMPLATE_NAME gh] Publish command
+
+Usage:
+  $GEET_ALIAS publish <type> [options...]
+
+Types:
+  app        Publish as a regular repository
+  template   Publish as a template repository (with --template flag and topics)
+
+Options:
+  --public       Create as public repository (default)
+  --private      Create as private repository
+  --internal     Create as internal repository
+  --desc         Repository description
+  --homepage     Repository homepage URL
+  --topics       Comma-separated topics (template only, default: "geet,template")
+
+Examples:
+  $GEET_ALIAS publish app
+  $GEET_ALIAS publish template --private --desc "My template"
+  $GEET_ALIAS publish app --desc "My app" --homepage "https://example.com"
+EOF
+      ;;
+    "")
+      die "publish command requires a type argument: 'app' or 'template'. Use '$GEET_ALIAS publish help' for more info."
+      ;;
+    *)
+      die "unknown publish type: '$subcommand'. Use 'app' or 'template'. Use '$GEET_ALIAS publish help' for more info."
+      ;;
+  esac
+}
+
+usage() {
+  cat <<EOF
+[$TEMPLATE_NAME gh] GitHub CLI integration
+
+Usage:
+  $GEET_ALIAS gh <command> [args...]
+
+Commands:
+  setup          Install and authenticate GitHub CLI (runs automatically if needed)
+  publish <type> Create and push repo to GitHub (type: 'app' or 'template')
+  <any>          Pass through to gh CLI (e.g., 'gh pr list' -> '$GEET_ALIAS gh pr list')
+  help           Show this help
+
+Examples:
+  $GEET_ALIAS publish app                       # Publish as regular repository
+  $GEET_ALIAS publish template                  # Publish as template repository
+  $GEET_ALIAS publish app --private --desc "My cool project"
+  $GEET_ALIAS gh pr list                        # Auto-setup if needed, then list PRs
+  $GEET_ALIAS gh repo view
+
+Note:
+  All commands automatically run 'setup' if gh is not installed or authenticated.
+  You rarely need to run 'setup' manually.
+  Use '$GEET_ALIAS publish help' for detailed publish options.
+EOF
+}
+
+
+handle(){
+###############################################################################
+  # COMMAND DISPATCH
+  ###############################################################################
+  cmd="${1:-help}"
+  shift || true
+
+  case "$cmd" in
+    help|-h|--help)
+      usage
+      ;;
+
+    setup)
+      setup_cmd "$@"
+      ;;
+
+    pub|publish)
+      publish_cmd "$@"
+      ;;
+
+    *)
+      # Pass through to gh CLI (auto-setup if needed)
+      ensure_gh_ready
+      gh "$cmd" "$@"
+      ;;
+  esac
+}