geet-geet 0.1.0 → 0.3.0

package/README.md

@@ -9,7 +9,7 @@ Only Git's *view* of the filesystem changes.
 
 ## Why?
 >   “I built something useful, and I think that **SOME but not all of my code is re-usable**.
-    I want to publish some of my code for other's to use (or to re-use myself)...
+    I want to publish some of my code for others to use (or to re-use myself)...
     but **I don't want to spend weeks refactoring** to split apart the reusable code from the implementation-specific code.
     In fact, it may not even be possible to move around all my files without breaking things. 
     Plus, supporting this template is my **secondary task** which I want to do in tandem with my **primary development**, using my main repository's working directory and publishing some pieces to the template repo.”
@@ -25,6 +25,9 @@ Only Git's *view* of the filesystem changes.
 - submodules don't support interleaving files and folders of template code with custom app code
 - I want to simultaneously develop many apps with a similar architecture
 
+## Why Not?
+> If you can super cleanly separate your template from your app or make your sourcecode fully modular, you don't need geet, use a normal repo or maybe submodules.
+
 ---
 ## PreReqs
 1. `git` - for pretty much everything

package/bin/geet.sh

@@ -15,7 +15,22 @@ shift || true
 case "$cmd" in
   help|-h|--help)
     source "$GEET_LIB/help.sh"
-    help
+    help "${GEET_ARGS[@]:1}"
+    ;;
+
+  version|-v|--version)
+    source "$GEET_LIB/version.sh"
+    version
+    ;;
+
+  why)
+    source "$GEET_LIB/why.sh"
+    why
+    ;;
+
+  whynot)
+    source "$GEET_LIB/why.sh"
+    whynot
     ;;
 
   sync)

package/lib/help.sh

@@ -7,47 +7,68 @@ help() {
 
 # digest-and-locate.sh provides: GEET_ALIAS, TEMPLATE_NAME, die, log
 
+if [[ "${1:-}" == "--all" ]]; then
 cat <<EOF
-$GEET_ALIAS — Git-based template layering system
-
-Usage: $GEET_ALIAS <command> [args...]
+$GEET_ALIAS — Git-based template layering system (see https://github.com/modularizer/geet)
 
 TEMPLATE MANAGEMENT:
-  template <name> [desc]    Create a new template layer from current app
-  init                      Initialize a freshly-cloned template repo as your app
-  install <repo>            Clone a template repo and initialize it (clone + init)
-  clone <repo>              Clone a git repository (standard git clone)
+  template <name> [desc] [--public|--private|--internal] Create a new template layer from current app
+  init                                                   Initialize a freshly-cloned template repo as your app
+  install <repo> <dir> [--public|--private|--internal]  Clone a template repo and initialize it
 
 FILE MANAGEMENT:
-  tree [list|tracked|all]   Show what files the template includes
-  split <dest> [mode]       Export template files to external folder
-  sync                      Compile .geetinclude whitelist into .geetexclude
-  detach                    "Detach" a file, folder, or glob to always use "keep-ours" to resolve merge conflicts, essentially allowing you to overwrite a file's template
-  retach                    undo a detach command
-  detached                  list files that have been detached
+  tree [list|tracked|all]                                Show what files the template includes
+  split <dest> [mode]                                    Export template files to external folder
+  sync                                                   Compile .geetinclude whitelist into .geetexclude
+  include <path>                                         Manage included files
+  ignored|included|excluded <path>                       Check if a path is ignored/included/excluded
+
+DETACHMENT (CONFLICT RESOLUTION):
+  detach|hard-detach <path>                              Detach a file to always use "keep-ours" on merge conflicts
+  soft-detach|soft_detach|slide <path>                   Soft detach (lighter alternative)
+  detached                                               List hard-detached files
+  soft-detached|soft_detached|slid                       List soft-detached files
+  retach <path>                                          Undo a detach command
 
 OPERATIONS:
-  session run [opts] -- cmd Run command in isolated template snapshot
-  publish [opts]            Publish template to GitHub (auto-detects repo name)
-  gh <subcommand> [...]     GitHub CLI integration (pr, issue, etc.)
-  doctor                    Run health checks on your geet setup
+  session <subcommand>                                   Run commands in isolated template snapshot
+  publish|pub [opts]                                     Publish template to GitHub
+  gh <subcommand>                                        GitHub CLI integration (pr, issue, etc.)
+  doctor                                                 Run health checks on your geet setup
+  prework                                                See what we know
+  precommit|pc                                           Run pre-commit hook
+
+UTILITIES:
+  version|--version|-v                                   Show geet version
+  why                                                    Reasons to use geet
+  whynot                                                 Reasons not to use geet
+  bug|feature|issue|whoops|suggest                       Open an issue on GitHub
+  remove|rm                                              Remove template tracking (requires confirmation)
+  destroy                                                Remove template tracking (no confirmation)
 
 GIT ACCESS:
-  git <command> [...]       Direct git access to template repo
-  <git-command> [...]       Any git command (auto-forwarded to template repo)
+  git <command> [...]                                    Direct git access to template repo
+  <git-command> [...]                                    Any git command (auto-forwarded to template repo)
 
-Get help on any command:
-  $GEET_ALIAS <command> --help
+Current layer: ${TEMPLATE_NAME:-none}
+EOF
+else
+cat <<EOF
+$GEET_ALIAS — Git-based template layering system (see https://github.com/modularizer/geet)
 
-Examples:
-  $GEET_ALIAS template my-stack "A modern web stack"
-  $GEET_ALIAS install https://github.com/user/template-repo
-  $GEET_ALIAS tree list
-  $GEET_ALIAS publish --public
-  $GEET_ALIAS status
-  $GEET_ALIAS commit -m "Update template"
+USAGE:
+  template <name> [desc] [--public|--private|--internal] Create a new template layer from current app
+  install  <repo> <dir>  [--public|--private|--internal] Do a git clone of a repo and convert it into a repo of your own
+  tree [list|tracked|all]                                Show what files the template includes
+  split <dest> [mode]                                    Export template files to external folder
+  prework                                                See what we know
+  why / whynot                                           Reasons to (or not to) use geet
+  version / --version                                    Show geet version
+  help --all                                             Show all available commands
+  <git-command> [...]                                    Any git command (auto-forwarded to template repo)
 
 Current layer: ${TEMPLATE_NAME:-none}
 EOF
+fi
 
 }  # end of help()

package/lib/version.sh

@@ -0,0 +1,14 @@
+# version.sh — display geet version
+# Usage:
+#   source version.sh
+#   version
+
+version() {
+  local pkg_json="$GEET_LIB/../package.json"
+  if [[ -f "$pkg_json" ]]; then
+    local ver=$(grep '"version"' "$pkg_json" | head -1 | sed 's/.*"version": *"\([^"]*\)".*/\1/')
+    echo "geet version $ver"
+  else
+    echo "geet version unknown (package.json not found)"
+  fi
+}

package/lib/why.sh

@@ -0,0 +1,37 @@
+# why.sh — explain when to use (or not use) geet
+# Usage:
+#   source why.sh
+#   why
+#   whynot
+
+why() {
+printf '%b' "$(cat <<'EOF'
+Use geet if this resonates with you...
+\033[3m
+   "I built something useful, and I think that SOME but not all of my code is re-usable.
+    I want to publish some of my code for others to use (or to re-use myself)...
+    but I don't want to spend weeks refactoring to split apart the reusable code from the implementation-specific code.
+    In fact, it may not even be possible to move around all my files without breaking things.
+    Plus, supporting this template is my secondary task which I want to do in tandem with my primary development,
+    using my main repository's working directory and publishing some pieces to the template repo."
+
+\033[0m
+
+EOF
+)"
+
+}
+
+whynot() {
+printf '%b' "$(cat <<'EOF'
+As much as I love this package, it is not for every use case...
+\033[3m
+    You probably do not need geet if you can super cleanly separate your template from your app or make your source code fully modular.
+    If you can use a package distribution like pypi or npm that is probably best. If git submodules work for you, that is good too.
+    If those solutions are not working for you, then check back here.
+
+\033[0m
+
+EOF
+)"
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "geet-geet",
-  "version": "0.1.0",
+  "version": "0.3.0",
   "private": false,
   "bin": {
     "geet": "bin/geet.sh",