Modify whatsdirty/publish.sh

.kiro/steering/product.md

@@ -0,0 +1,23 @@
+# Product Overview
+
+This repository contains **getpkg** - a command-line package manager for the dropshell ecosystem, along with a collection of developer tools.
+
+## Core Product
+- **getpkg**: Package manager that installs tools to `~/.getpkg/` with symlinks in `~/.local/bin/getpkg/`
+- Supports multiple architectures (x86_64, aarch64, universal)
+- Tools are published to and downloaded from `getpkg.xyz`
+
+## Tool Collection
+The repository includes several utility tools:
+- **bb64**: Bash-compatible base64 encoder/decoder with custom character set
+- **dehydrate**: Converts files/directories to C++ source code for embedding
+- **whatsdirty**: Git repository status checker
+- **sos**: Simple object storage client
+- **gp**: Git push utility
+
+## Key Features
+- Cross-platform tool distribution
+- Automated installation with PATH setup
+- Bash completion support
+- Architecture-aware downloads with fallbacks
+- Publishing system with authentication tokens

.kiro/steering/structure.md

@@ -0,0 +1,72 @@
+# Project Structure
+
+## Repository Layout
+```
+├── buildtestpublish_all.sh    # Master build script for all projects
+├── clean.sh                   # Global cleanup script
+├── README.md                  # Main project documentation
+└── <tool-name>/               # Individual tool directories
+```
+
+## Tool Directory Structure
+
+### C++ Projects (CMake-based)
+```
+<tool-name>/
+├── CMakeLists.txt             # CMake configuration
+├── build.sh                   # Build script
+├── test.sh                    # Test script  
+├── clean.sh                   # Cleanup script
+├── publish.sh                 # Publishing script
+├── install.sh                 # Installation script
+├── README.md                  # Tool documentation
+├── Dockerfile.dropshell-build # Docker build configuration
+├── src/                       # Source code
+│   ├── <tool>.cpp            # Main source file
+│   ├── version.hpp.in        # Version template
+│   └── ...                   # Additional sources
+├── build/                     # Build artifacts (generated)
+├── output/                    # Final executables (generated)
+└── .vscode/                   # VS Code configuration
+```
+
+### Shell Script Projects
+```
+<tool-name>/
+├── <tool-name>               # Executable shell script
+├── build.sh                  # Build script (may be no-op)
+├── test.sh                   # Test script
+├── clean.sh                  # Cleanup script
+├── publish.sh                # Publishing script
+└── setup_script.sh           # Post-install setup (optional)
+```
+
+## Standard Files
+
+### Required Scripts
+- **build.sh**: Builds the project (Docker for C++, no-op for shell)
+- **test.sh**: Runs project tests
+- **clean.sh**: Removes build artifacts
+- **publish.sh**: Publishes to getpkg.xyz registry
+
+### Optional Files
+- **install.sh**: System-wide installation script
+- **setup_script.sh**: Post-install setup for getpkg
+- **cmake_prebuild.sh**: Pre-build setup for CMake projects
+
+### Generated Directories
+- **build/**: CMake build artifacts (C++ projects)
+- **output/**: Final executables ready for distribution
+- **test_*/**: Test-specific directories
+
+## Naming Conventions
+- Tool directories match executable names
+- C++ source files typically match project name
+- Version templates use `.hpp.in` extension
+- Docker files use `Dockerfile.dropshell-build` pattern
+- Test directories prefixed with `test_`
+
+## Configuration Files
+- **.gitignore**: Standard ignore patterns for build artifacts
+- **.vscode/**: VS Code workspace settings
+- **CMakeLists.txt**: Follows standard template with PROJECT_NAME parameter

.kiro/steering/tech.md

@@ -0,0 +1,70 @@
+# Technology Stack
+
+## Build System
+- **CMake 3.16+** with Ninja generator for C++ projects
+- **Docker** containerized builds using `gitea.jde.nz/public/dropshell-build-base:latest`
+- **Static linking** for all C++ executables (`-static` flag)
+
+## Languages & Standards
+- **C++23** standard for all C++ projects
+- **Bash** for shell scripts and simple tools
+- **Shell scripts** follow `set -euo pipefail` pattern
+
+## Dependencies
+- **nlohmann_json** for JSON handling in C++ projects
+- **CPR (static)** for HTTP requests in getpkg
+- Custom modules in `/usr/local/share/cmake/Modules`
+
+## Common Build Patterns
+
+### C++ Projects (CMake)
+```bash
+# Standard build command
+cmake -G Ninja -S . -B ./build -DCMAKE_BUILD_TYPE=Debug -DPROJECT_NAME=<project>
+cmake --build ./build
+```
+
+### Docker Build (for C++ tools)
+```bash
+# Uses Dockerfile.dropshell-build pattern
+docker build -t <project>-build -f Dockerfile.dropshell-build --build-arg PROJECT=<project> --output ./output .
+```
+
+### Shell Tools
+- No build step required
+- Executable shell scripts with proper shebang
+- Use `chmod +x` for permissions
+
+## Common Commands
+
+### Build
+```bash
+./build.sh          # Build individual project
+./buildtestpublish_all.sh  # Build all projects
+```
+
+### Test
+```bash
+./test.sh           # Run tests for individual project
+```
+
+### Clean
+```bash
+./clean.sh          # Clean build artifacts
+```
+
+### Publish
+```bash
+./publish.sh        # Publish to getpkg.xyz (requires SOS_WRITE_TOKEN)
+```
+
+## Version Management
+- Automatic timestamp-based versioning: `YYYY.MMDD.HHMM`
+- Version configured via `version.hpp.in` template files
+- Pre-build scripts (`cmake_prebuild.sh`) for additional setup
+
+## Environment Variables
+- `CMAKE_BUILD_TYPE`: Debug/Release (default: Debug)
+- `SOS_WRITE_TOKEN`: Authentication for publishing
+- `NO_CACHE`: Skip Docker cache when set to "true"
+- `PROJECT`: Project name for build scripts

dehydrate/build.sh

@@ -3,7 +3,7 @@ set -euo pipefail
 
 # Get script directory - handle different execution contexts
 SCRIPT_DIR="$( cd "$( dirname "${BASH_SOURCE[0]}" )" &> /dev/null && pwd )"
-PROJECT="$(basename "$(dirname "${SCRIPT_DIR}")")"
+PROJECT="$(basename "${SCRIPT_DIR}")"
 
 # Debug output for CI
 echo "${PROJECT} build script running from: ${SCRIPT_DIR}"

getpkg/build.sh

@@ -3,7 +3,7 @@ set -euo pipefail
 
 # Get script directory - handle different execution contexts
 SCRIPT_DIR="$( cd "$( dirname "${BASH_SOURCE[0]}" )" &> /dev/null && pwd )"
-PROJECT="$(basename "$(dirname "${SCRIPT_DIR}")")"
+PROJECT="$(basename "${SCRIPT_DIR}")"
 
 # Debug output for CI
 echo "${PROJECT} build script running from: ${SCRIPT_DIR}"

getpkg/src/main.cpp

@@ -1150,6 +1150,85 @@ void show_help() {
     std::cout << "  ~/.local/bin/getpkg/                  Installed tool binaries" << std::endl;
 }
 
+int autocomplete_command(int argc, char* argv[]) {
+    std::vector<std::string> args(argv + 2, argv + argc);
+    
+    // If no arguments, return all commands
+    if (args.empty()) {
+        std::cout << "install\n";
+        std::cout << "uninstall\n";
+        std::cout << "publish\n";
+        std::cout << "unpublish\n";
+        std::cout << "update\n";
+        std::cout << "version\n";
+        std::cout << "create\n";
+        std::cout << "hash\n";
+        std::cout << "list\n";
+        std::cout << "clean\n";
+        std::cout << "help\n";
+        return 0;
+    }
+    
+    const std::string& subcommand = args[0];
+    
+    // Handle autocompletion for specific commands
+    if (subcommand == "install") {
+        // For install, we could suggest popular packages or recently published ones
+        // For now, just return empty (no specific completions)
+        return 0;
+    } else if (subcommand == "uninstall") {
+        // For uninstall, list installed tools
+        std::filesystem::path configDir = std::filesystem::path(std::getenv("HOME")) / ".config" / "getpkg";
+        if (std::filesystem::exists(configDir)) {
+            for (const auto& entry : std::filesystem::directory_iterator(configDir)) {
+                if (entry.path().extension() == ".json") {
+                    std::string toolName = entry.path().stem().string();
+                    std::cout << toolName << "\n";
+                }
+            }
+        }
+        return 0;
+    } else if (subcommand == "publish") {
+        // For publish, suggest architecture suffixes after tool name
+        if (args.size() >= 2) {
+            // If we have tool_name already, suggest architectures
+            std::cout << "x86_64\n";
+            std::cout << "aarch64\n";
+            std::cout << "universal\n";
+        }
+        return 0;
+    } else if (subcommand == "unpublish") {
+        // For unpublish, list installed tools (similar to uninstall)
+        std::filesystem::path configDir = std::filesystem::path(std::getenv("HOME")) / ".config" / "getpkg";
+        if (std::filesystem::exists(configDir)) {
+            for (const auto& entry : std::filesystem::directory_iterator(configDir)) {
+                if (entry.path().extension() == ".json") {
+                    std::string toolName = entry.path().stem().string();
+                    std::cout << toolName << "\n";
+                    // Also suggest with architecture suffixes
+                    std::cout << toolName << ":x86_64\n";
+                    std::cout << toolName << ":aarch64\n";
+                    std::cout << toolName << ":universal\n";
+                }
+            }
+        }
+        return 0;
+    } else if (subcommand == "create") {
+        // For create, no specific completions (tool name and directory are user-defined)
+        return 0;
+    } else if (subcommand == "hash") {
+        // For hash, suggest file extensions
+        if (args.size() >= 2) {
+            std::cout << "*.tgz\n";
+            std::cout << "*.tar.gz\n";
+        }
+        return 0;
+    }
+    
+    // No specific completions for other commands
+    return 0;
+}
+
 } // end anonymous namespace
 
 int main(int argc, char* argv[]) {
@@ -1169,19 +1248,7 @@ int main(int argc, char* argv[]) {
     } else if (command == "update") {
         return update_tool(argc, argv);
     } else if (command == "autocomplete") {
-        std::vector<std::string> args(argv + 2, argv + argc);
-        if (args.empty()) std::cout << R"(install
-uninstall
-publish
-unpublish
-update
-version
-create
-hash
-list
-clean
-help
-)";
+        return autocomplete_command(argc, argv);
     } else if (command == "version") {
         std::cout << dropshell::VERSION << std::endl;
     } else if (command == "create") {

whatsdirty/publish.sh

@@ -25,6 +25,7 @@ GETPKG="${SCRIPT_DIR}/../getpkg/output/getpkg"
 TOOLDIR="${SCRIPT_DIR}/tool"
 mkdir -p "${TOOLDIR}"
 cp "${SCRIPT_DIR}/whatsdirty" "${TOOLDIR}/whatsdirty"   
+cp "${SCRIPT_DIR}/setup_script.sh" "${TOOLDIR}/"
 
 # publish universal tool.
 "${GETPKG}" publish "whatsdirty" "${TOOLDIR}"