Rename project from Agent-Forge to Kash, updating all relevant files, commands, and documentation.

- Created main entry point in cmd/kash/main.go.
- Updated root command in cmd/root.go to reflect new project name and description.
- Modified serve command in cmd/serve.go to start Kash runtime server.
- Changed version command in cmd/version.go to print Kash version information.
- Revised Product Requirements Document (PRD) and README to reflect new branding and functionality.
- Updated configuration paths and environment variables to use Kash instead of Agent-Forge.
- Adjusted internal package imports to align with new module name.
- Ensured all references to Agent-Forge in comments and documentation are replaced with Kash.

Author: chinmay-sh

.github/workflows/ci.yml

@@ -76,15 +76,15 @@ jobs:
           GOARCH: ${{ matrix.goarch }}
           CGO_ENABLED: 0
         run: |
-          BINARY_NAME=agentforge
+          BINARY_NAME=kash
           if [ "${{ matrix.goos }}" = "windows" ]; then
-            BINARY_NAME=agentforge.exe
+            BINARY_NAME=kash.exe
           fi
           go build \
             -trimpath \
             -ldflags "-s -w \
-              -X github.com/agent-forge/agent-forge/cmd.version=dev \
-              -X github.com/agent-forge/agent-forge/cmd.commit=$(git rev-parse --short HEAD) \
-              -X github.com/agent-forge/agent-forge/cmd.buildDate=$(date -u +%Y-%m-%dT%H:%M:%SZ)" \
+              -X github.com/akashicode/kash/cmd.version=dev \
+              -X github.com/akashicode/kash/cmd.commit=$(git rev-parse --short HEAD) \
+              -X github.com/akashicode/kash/cmd.buildDate=$(date -u +%Y-%m-%dT%H:%M:%SZ)" \
             -o "bin/${BINARY_NAME}" \
-            ./cmd/agent-forge
+            ./cmd/kash

.github/workflows/release.yml

@@ -63,39 +63,39 @@ jobs:
           GOARCH: ${{ matrix.goarch }}
           CGO_ENABLED: 0
         run: |
-          BINARY_NAME=agentforge
+          BINARY_NAME=kash
           if [ "${{ matrix.goos }}" = "windows" ]; then
-            BINARY_NAME=agentforge.exe
+            BINARY_NAME=kash.exe
           fi
           go build \
             -trimpath \
             -ldflags "-s -w \
-              -X github.com/agent-forge/agent-forge/cmd.version=${VERSION} \
-              -X github.com/agent-forge/agent-forge/cmd.commit=${COMMIT} \
-              -X github.com/agent-forge/agent-forge/cmd.buildDate=${BUILD_DATE}" \
+              -X github.com/akashicode/kash/cmd.version=${VERSION} \
+              -X github.com/akashicode/kash/cmd.commit=${COMMIT} \
+              -X github.com/akashicode/kash/cmd.buildDate=${BUILD_DATE}" \
             -o "dist/${BINARY_NAME}" \
-            ./cmd/agent-forge
+            ./cmd/kash
 
       - name: Package archive (tar.gz)
         if: matrix.archive == 'tar.gz'
         run: |
           cd dist
-          tar -czf "agentforge_${{ matrix.suffix }}.tar.gz" agentforge
-          sha256sum "agentforge_${{ matrix.suffix }}.tar.gz" >> checksums.txt
+          tar -czf "kash_${{ matrix.suffix }}.tar.gz" kash
+          sha256sum "kash_${{ matrix.suffix }}.tar.gz" >> checksums.txt
 
       - name: Package archive (zip)
         if: matrix.archive == 'zip'
         run: |
           cd dist
-          zip "agentforge_${{ matrix.suffix }}.zip" agentforge.exe
-          sha256sum "agentforge_${{ matrix.suffix }}.zip" >> checksums.txt
+          zip "kash_${{ matrix.suffix }}.zip" kash.exe
+          sha256sum "kash_${{ matrix.suffix }}.zip" >> checksums.txt
 
       - name: Upload artifacts
         uses: actions/upload-artifact@v4
         with:
-          name: agentforge_${{ matrix.suffix }}
+          name: kash_${{ matrix.suffix }}
           path: |
-            dist/agentforge_${{ matrix.suffix }}.*
+            dist/kash_${{ matrix.suffix }}.*
             dist/checksums.txt
 
   release:
@@ -138,23 +138,23 @@ jobs:
           echo "" >> release_notes.md
           echo '```bash' >> release_notes.md
           echo "# Linux / macOS" >> release_notes.md
-          echo "curl -L https://github.com/${{ github.repository }}/releases/download/${VERSION}/agentforge_linux_amd64.tar.gz | tar -xz" >> release_notes.md
-          echo "sudo mv agentforge /usr/local/bin/" >> release_notes.md
+          echo "curl -L https://github.com/${{ github.repository }}/releases/download/${VERSION}/kash_linux_amd64.tar.gz | tar -xz" >> release_notes.md
+          echo "sudo mv kash /usr/local/bin/" >> release_notes.md
           echo '```' >> release_notes.md
 
       - name: Create GitHub Release
         uses: softprops/action-gh-release@v2
         with:
-          name: "agentforge ${{ github.ref_name }}"
+          name: "kash ${{ github.ref_name }}"
           body_path: release_notes.md
           draft: false
           prerelease: ${{ contains(github.ref_name, '-') }}
           files: |
-            dist/agentforge_linux_amd64.tar.gz
-            dist/agentforge_linux_arm64.tar.gz
-            dist/agentforge_darwin_amd64.tar.gz
-            dist/agentforge_darwin_arm64.tar.gz
-            dist/agentforge_windows_amd64.zip
+            dist/kash_linux_amd64.tar.gz
+            dist/kash_linux_arm64.tar.gz
+            dist/kash_darwin_amd64.tar.gz
+            dist/kash_darwin_arm64.tar.gz
+            dist/kash_windows_amd64.zip
             dist/checksums.txt
 
   docker-publish:
@@ -183,7 +183,7 @@ jobs:
         id: meta
         uses: docker/metadata-action@v5
         with:
-          images: ghcr.io/${{ github.repository_owner }}/agentforge
+          images: ghcr.io/${{ github.repository_owner }}/kash
           tags: |
             type=semver,pattern={{version}}
             type=semver,pattern={{major}}.{{minor}}

.gitignore

@@ -24,7 +24,7 @@ coverage.html
 .env.local
 .env.*.local
 
-# Agent-Forge compiled databases (project-specific, not source code)
+# Kash compiled databases (project-specific, not source code)
 data/memory.chromem/
 data/knowledge.cayley/
 

.golangci.yml

@@ -1,4 +1,4 @@
-# GolangCI-Lint configuration for Agent-Forge
+# GolangCI-Lint configuration for Kash
 # Install: go install github.com/golangci/golangci-lint/cmd/golangci-lint@latest
 
 run:
@@ -29,7 +29,7 @@ linters:
 
 linters-settings:
   goimports:
-    local-prefixes: github.com/agent-forge/agent-forge
+    local-prefixes: github.com/akashicode/kash
 
   revive:
     rules:

AGENTS.md

@@ -1,18 +1,18 @@
-# Agent-Forge: Coding Guidelines for AI Agents
+# Kash: Coding Guidelines for AI Agents
 
-> **Project Overview**: Agent-Forge is a Go-based CLI framework that compiles raw documents into embedded, pure-Go GraphRAG databases, packaged into ultra-lightweight Docker containers.
+> **Project Overview**: Kash is a Go-based CLI framework that compiles raw documents into embedded, pure-Go GraphRAG databases, packaged into ultra-lightweight Docker containers.
 
 ## 1. Build, Lint, and Test Commands
 
 ### Build
 ```bash
 # Build the CLI binary
-go build -o bin/agentforge ./cmd/agent-forge
+go build -o bin/kash ./cmd/Kash
 
 # Build for multiple platforms
-GOOS=linux GOARCH=amd64 go build -o bin/agentforge-linux ./cmd/agent-forge
-GOOS=darwin GOARCH=amd64 go build -o bin/agentforge-darwin ./cmd/agent-forge
-GOOS=windows GOARCH=amd64 go build -o bin/agentforge.exe ./cmd/agent-forge
+GOOS=linux GOARCH=amd64 go build -o bin/kash-linux ./cmd/Kash
+GOOS=darwin GOARCH=amd64 go build -o bin/kash-darwin ./cmd/Kash
+GOOS=windows GOARCH=amd64 go build -o bin/kash.exe ./cmd/Kash
 ```
 
 ### Lint
@@ -58,10 +58,10 @@ go test -bench=. ./...
 ### Docker
 ```bash
 # Build Docker image
-docker build -t agent-forge:latest .
+docker build -t Kash:latest .
 
 # Run container
-docker run -p 8000:8000 agent-forge:latest
+docker run -p 8000:8000 Kash:latest
 ```
 
 ---
@@ -71,14 +71,14 @@ docker run -p 8000:8000 agent-forge:latest
 Follow standard Go CLI project layout:
 
 ```
-agent-forge/
+Kash/
 ├── cmd/
-│   └── agent-forge/          # Main application entry point
+│   └── Kash/          # Main application entry point
 │       └── main.go           # Imports and invokes cmd/root.go
 ├── cmd/                      # Cobra command definitions
 │   ├── root.go               # Root command (Execute(), initConfig)
-│   ├── init.go               # `agentforge init` subcommand
-│   └── build.go              # `agentforge build` subcommand
+│   ├── init.go               # `kash init` subcommand
+│   └── build.go              # `kash build` subcommand
 ├── internal/                 # Private application code
 │   ├── config/               # Configuration handling (Viper)
 │   ├── vector/               # chromem-go vector store operations
@@ -117,8 +117,8 @@ import (
     "go.uber.org/zap"
 
     // 3. Local packages
-    "github.com/agent-forge/internal/config"
-    "github.com/agent-forge/internal/vector"
+    "github.com/Kash/internal/config"
+    "github.com/Kash/internal/vector"
 )
 ```
 
@@ -308,7 +308,7 @@ type Embedder interface {
 ## 5. Configuration (Viper + YAML)
 
 ### Global Config Path
-`~/.agent-forge/config.yaml`
+`~/.Kash/config.yaml`
 
 ### Config Structure
 ```go
@@ -336,7 +336,7 @@ func initConfig() {
         viper.SetConfigFile(cfgFile)
     } else {
         home, _ := os.UserHomeDir()
-        viper.AddConfigPath(filepath.Join(home, ".agent-forge"))
+        viper.AddConfigPath(filepath.Join(home, ".Kash"))
         viper.SetConfigType("yaml")
         viper.SetConfigName("config")
     }
@@ -411,4 +411,4 @@ RERANK_MODEL=      # Optional
 3. **Docker-First Distribution**: Single ~50MB container with baked databases.
 4. **Three Interfaces**: REST (`/v1/chat/completions`), MCP (`/mcp`), A2A (`/rpc/agent`).
 5. **Build vs Runtime**: Data ingestion happens at `build` time. Runtime only serves queries.
-6. **Single Binary**: One `agentforge` binary acts as both CLI (`init`, `build`) and server (`serve`). A multi-arch base image (`ghcr.io/agent-forge/agentforge`) is published to GHCR. Agent Dockerfiles use `FROM ghcr.io/agent-forge/agentforge:latest` so users can build cross-platform images (amd64 + arm64) with `docker buildx`.
+6. **Single Binary**: One `kash` binary acts as both CLI (`init`, `build`) and server (`serve`). A multi-arch base image (`ghcr.io/akashicode/kash`) is published to GHCR. Agent Dockerfiles use `FROM ghcr.io/akashicode/kash:latest` so users can build cross-platform images (amd64 + arm64) with `docker buildx`.

CLAUDE.md

@@ -4,20 +4,20 @@ This file provides guidance to Claude Code (claude.ai/code) when working with co
 
 ## Project Overview
 
-Agent-Forge is a Go-based CLI framework that compiles raw documents into embedded, pure-Go GraphRAG databases, packaged into ultra-lightweight Docker containers (~50MB).
+Kash is a Go-based CLI framework that compiles raw documents into embedded, pure-Go GraphRAG databases, packaged into ultra-lightweight Docker containers (~50MB).
 
 The "compiler" approach: data ingestion happens at build time, runtime only serves queries. This allows sharing expert AI agents as Docker images without complex infrastructure.
 
 ## Build, Lint, and Test Commands
 
 ### Build
 ```bash
-go build -o bin/agentforge ./cmd/agent-forge
+go build -o bin/kash ./cmd/Kash
 
 # Cross-platform builds
-GOOS=linux GOARCH=amd64 go build -o bin/agentforge-linux ./cmd/agent-forge
-GOOS=darwin GOARCH=amd64 go build -o bin/agentforge-darwin ./cmd/agent-forge
-GOOS=windows GOARCH=amd64 go build -o bin/agentforge.exe ./cmd/agent-forge
+GOOS=linux GOARCH=amd64 go build -o bin/kash-linux ./cmd/Kash
+GOOS=darwin GOARCH=amd64 go build -o bin/kash-darwin ./cmd/Kash
+GOOS=windows GOARCH=amd64 go build -o bin/kash.exe ./cmd/Kash
 ```
 
 ### Lint
@@ -40,8 +40,8 @@ go test -bench=. ./...               # benchmarks
 
 ### Docker
 ```bash
-docker build -t agent-forge:latest .
-docker run -p 8000:8000 agent-forge:latest
+docker build -t Kash:latest .
+docker run -p 8000:8000 Kash:latest
 ```
 
 ## Architecture
@@ -71,12 +71,12 @@ The Go runtime multiplexes on port 8000:
 3. **Docker-First Distribution**: Single ~50MB container with baked databases.
 4. **Build vs Runtime**: Data ingestion at `build` time; runtime only serves queries.
 5. **BYOM (Bring Your Own Model)**: Runtime requires user-provided API keys; no bundled inference.
-6. **Single Binary**: One `agentforge` binary handles CLI (`init`, `build`) and server (`serve`). A multi-arch base image (`ghcr.io/agent-forge/agentforge`) is published to GHCR. Agent Dockerfiles use it as base so users can build cross-platform images with `docker buildx`.
+6. **Single Binary**: One `kash` binary handles CLI (`init`, `build`) and server (`serve`). A multi-arch base image (`ghcr.io/akashicode/kash`) is published to GHCR. Agent Dockerfiles use it as base so users can build cross-platform images with `docker buildx`.
 
 ## Configuration
 
 ### Global CLI Config (Build-Time)
-Location: `~/.agent-forge/config.yaml`
+Location: `~/.Kash/config.yaml`
 
 ```yaml
 build_providers:
@@ -99,22 +99,22 @@ RERANK_BASE_URL, RERANK_API_KEY, RERANK_MODEL  # optional
 
 ## Developer Workflow
 
-1. **`agentforge init <name>`** - Scaffold project with `data/`, `agent.yaml`, `Dockerfile`
+1. **`kash init <name>`** - Scaffold project with `data/`, `agent.yaml`, `Dockerfile`
 2. **Add documents** to `data/` directory (PDFs, Markdown, etc.)
-3. **`agentforge build`** - Chunk documents, call embedder API, extract graph triples via LLM, generate MCP tool descriptions
+3. **`kash build`** - Chunk documents, call embedder API, extract graph triples via LLM, generate MCP tool descriptions
 4. **`docker build`** - Package into ~50MB container with baked databases
 5. **`docker run`** with user's runtime API keys
 
 ## Project Structure
 
 ```
-agent-forge/
+Kash/
 ├── cmd/                    # Cobra commands
 │   ├── root.go            # Root command, Viper config
-│   ├── init.go            # `agentforge init`
-│   ├── build.go           # `agentforge build`
-│   ├── serve.go           # `agentforge serve` (runtime server)
-│   └── version.go         # `agentforge version`
+│   ├── init.go            # `kash init`
+│   ├── build.go           # `kash build`
+│   ├── serve.go           # `kash serve` (runtime server)
+│   └── version.go         # `kash version`
 ├── internal/              # Private application code
 │   ├── config/            # Viper configuration
 │   ├── vector/            # chromem-go operations

Dockerfile

@@ -1,7 +1,7 @@
-# Agent-Forge Base Image
-# Builds the single agentforge binary (used for both CLI and server).
-# Published as a multi-arch image (amd64 + arm64) to ghcr.io/agent-forge/agentforge.
-# Agent Dockerfiles (generated by `agentforge init`) use this as their base image.
+# Kash Base Image
+# Builds the single kash binary (used for both CLI and server).
+# Published as a multi-arch image (amd64 + arm64) to ghcr.io/akashicode/kash.
+# Agent Dockerfiles (generated by `kash init`) use this as their base image.
 
 FROM golang:1.25-alpine AS builder
 
@@ -16,7 +16,7 @@ COPY . .
 
 # Build the binary (CGO disabled for static linking)
 RUN CGO_ENABLED=0 go build -trimpath -ldflags="-s -w" \
-    -o /agentforge ./cmd/agent-forge
+    -o /kash ./cmd/kash
 
 # --- Minimal runtime stage ---
 FROM alpine:3.19
@@ -25,6 +25,6 @@ RUN apk add --no-cache ca-certificates tzdata
 
 WORKDIR /app
 
-COPY --from=builder /agentforge /app/agentforge
+COPY --from=builder /kash /app/kash
 
-ENTRYPOINT ["/app/agentforge"]
+ENTRYPOINT ["/app/kash"]