code.oscarkilo.com/okg #2f5e75b1a362ee4a7479e4ee80c93a16f23e7ea4

Hash:

2f5e75b1a362ee4a7479e4ee80c93a16f23e7ea4

Author:

Date:

Thu Jun 4 19:01:12 2026 -0400

Message:

okg auth login: --key flag + stdin; drop KLEX_API_KEY env; drop --user Make the agent-friendly path the only path: - New --key KEY flag for a flat, scripted call. - Piped stdin works as the ps-safe alternative. - Interactive prompt remains as the human fallback. Remove the KLEX_API_KEY env-var override from loadConfig. The config at ~/.config/okg/config.json is now the one way to provide a key, populated via `okg auth login`. OKG_HOST stays because TestMain uses it to keep the suite away from prod. Remove --user and the /login/profile/edit it triggered. The API key is bound to a username by //who; no need for okg to claim or rename it. Avoids the stale-config drift if a user renames themselves later. Tests: - TestAuthLoginKeyFlag pins the --key path. - TestAuthLoginStdin pins the piped-stdin path. - TestConfigEnvOverrides → TestConfigOKGHostOverride (the KLEX_API_KEY half of the old test went away with the env var). - New writeTestKey helper writes an isolated config file in t.TempDir(); the repo-create tests use it instead of the old os.Setenv("KLEX_API_KEY", ...) pattern.

diff --git a/README.md b/README.md
index d05ef29..6fa9ead 100644
--- a/README.md
+++ b/README.md
@@ -25,19 +25,20 @@ cd okg && go build .
## Setup

By default okg talks to the production klee host
-(`https://code.oscarkilo.com`); the only setup you need is to give it
-your API key. Either:
+(`https://code.oscarkilo.com`); the only setup you need is your
+API key. `okg auth login` saves it to
+`~/.config/okg/config.json`.

```bash
-# Interactive login — saves host + key to ~/.config/okg/config.json.
-okg auth login
+# Non-interactive (for agents and scripts).
+okg auth login --key sk-...
+cat ~/.klex.key | okg auth login # equivalent, ps-safe

-# Or non-interactive: just set the API key.
-export KLEX_API_KEY=your-api-key
+# Interactive (prompts for host then key).
+okg auth login
```

-Override the host for dev/local work with `--host` on `auth login`,
-or with the `OKG_HOST` env var.
+Override the host for dev/local work with `--host` on `auth login`.

## Commands

@@ -53,7 +54,7 @@ okg pr merge NUMBER
okg pr close NUMBER
okg pr reopen NUMBER

-okg auth login [--host HOST] [--user USERNAME]
+okg auth login [--key KEY] [--host HOST]

okg embed [--model NAME] [--dims N] [--full-path]
(reads stdin → vectors on stdout)
diff --git a/auth.go b/auth.go
index 4a8880b..6d17a89 100644
--- a/auth.go
+++ b/auth.go
@@ -2,6 +2,7 @@ package main

import "bufio"
import "fmt"
+import "io"
import "os"
import "strings"

@@ -18,9 +19,14 @@ func runAuth(args []string) error {
}
}

+// runAuthLogin saves a host + API key to ~/.config/okg/config.json.
+// The key can come from --key, from stdin (pipe), or — when stdin
+// is a TTY — from an interactive prompt. Host defaults to
+// production unless --host is given (and, in interactive mode, the
+// prompt offers an override).
func runAuthLogin(args []string) error {
host := ""
- user := ""
+ key := ""
for i := 0; i < len(args); i++ {
switch args[i] {
case "--host":
@@ -30,59 +36,69 @@ func runAuthLogin(args []string) error {
"--host requires a value")
}
host = args[i]
- case "--user":
+ case "--key":
i++
if i >= len(args) {
return fmt.Errorf(
- "--user requires a value")
+ "--key requires a value")
}
- user = args[i]
+ key = args[i]
default:
return fmt.Errorf(
"unknown flag: %s", args[i])
}
}

- reader := bufio.NewReader(os.Stdin)
-
- if host == "" {
- fmt.Printf("Host (default %s): ", DefaultHost)
- line, _ := reader.ReadString('\n')
- host = strings.TrimSpace(line)
+ // Resolve API key: --key wins; otherwise read from stdin
+ // (piped) or prompt interactively.
+ switch {
+ case key != "":
+ // Use as-is.
+ case stdinIsPiped():
+ line, err := bufio.NewReader(os.Stdin).
+ ReadString('\n')
+ if err != nil && err != io.EOF {
+ return fmt.Errorf("reading stdin: %v", err)
+ }
+ key = strings.TrimSpace(line)
+ default:
+ // Interactive: optionally prompt for host, then key.
+ reader := bufio.NewReader(os.Stdin)
if host == "" {
- host = DefaultHost
+ fmt.Printf("Host (default %s): ", DefaultHost)
+ line, _ := reader.ReadString('\n')
+ host = strings.TrimSpace(line)
}
+ fmt.Print("API key: ")
+ line, _ := reader.ReadString('\n')
+ key = strings.TrimSpace(line)
}

- fmt.Print("API key: ")
- api_key, _ := reader.ReadString('\n')
- api_key = strings.TrimSpace(api_key)
- if api_key == "" {
- return fmt.Errorf("API key is required")
+ if host == "" {
+ host = DefaultHost
+ }
+ if key == "" {
+ return fmt.Errorf(
+ "API key required " +
+ "(pass --key, pipe via stdin, or " +
+ "enter at the prompt)")
}

- cfg := &Config{Host: host, ApiKey: api_key}
+ cfg := &Config{Host: host, ApiKey: key}
if err := saveConfig(cfg); err != nil {
return fmt.Errorf("saving config: %v", err)
}
fmt.Printf("Saved config to %s\n", configPath())
+ return nil
+}

- // If --user given, call profile edit to map
- // the API key to this username in mock who.
- if user != "" {
- cl := newKleeClient(cfg)
- payload := map[string]string{
- "username": user,
- "name": user,
- }
- err := cl.PostJSON(
- "/login/profile/edit", payload, nil)
- if err != nil {
- return fmt.Errorf(
- "setting username: %v", err)
- }
- fmt.Printf("Authenticated as %s\n", user)
+// stdinIsPiped reports whether stdin is not a terminal — i.e.
+// a pipe or a redirected file. Used to decide between reading
+// stdin directly and prompting interactively.
+func stdinIsPiped() bool {
+ fi, err := os.Stdin.Stat()
+ if err != nil {
+ return false
}
-
- return nil
+ return (fi.Mode() & os.ModeCharDevice) == 0
}
diff --git a/config.go b/config.go
index 8285075..bb18fbd 100644
--- a/config.go
+++ b/config.go
@@ -35,13 +35,12 @@ func loadConfig() (*Config, error) {
}
}

- // Env overrides.
+ // OKG_HOST env override exists for tests (TestMain points it at
+ // localhost so accidental hits to prod fail fast). It is NOT a
+ // user-facing config knob; `okg auth login --host` is.
if v := os.Getenv("OKG_HOST"); v != "" {
c.Host = v
}
- if v := os.Getenv("KLEX_API_KEY"); v != "" {
- c.ApiKey = v
- }

// Default to prod. Tests set OKG_HOST in TestMain to a localhost
// URL so they can't accidentally reach it.
diff --git a/embed.go b/embed.go
index 347708e..0fc86ce 100644
--- a/embed.go
+++ b/embed.go
@@ -30,7 +30,7 @@ func runEmbed(args []string) error {
}
if cfg.ApiKey == "" {
return fmt.Errorf(
- "no API key — run `okg auth login`")
+ "no API key — run `okg auth login --key sk-...`")
}
client := newKlexClient(cfg)

diff --git a/main.go b/main.go
index f4b325f..61a4605 100644
--- a/main.go
+++ b/main.go
@@ -41,8 +41,8 @@ func printUsage() {

SETUP
okg auth login
+ --key KEY API key (also accepted via stdin)
--host HOST klee host (default: production)
- --user USERNAME login as USERNAME

GIT REPOS
okg repo list
@@ -96,7 +96,8 @@ GLOBAL FLAGS

EXAMPLES
Setup
- okg auth login
+ okg auth login --key sk-...
+ cat ~/.klex.key | okg auth login

Git repos
okg repo list
diff --git a/okg_test.go b/okg_test.go
index e03fb07..adae69b 100644
--- a/okg_test.go
+++ b/okg_test.go
@@ -139,12 +139,8 @@ func TestAge(t *testing.T) {
check(48*time.Hour, "2d")
}

-func TestConfigEnvOverrides(t *testing.T) {
- os.Setenv("OKG_HOST", "http://test:1234")
- os.Setenv("KLEX_API_KEY", "env-key")
- defer os.Unsetenv("OKG_HOST")
- defer os.Unsetenv("KLEX_API_KEY")
-
+func TestConfigOKGHostOverride(t *testing.T) {
+ t.Setenv("OKG_HOST", "http://test:1234")
cfg, err := loadConfig()
if err != nil {
t.Fatal(err)
@@ -154,11 +150,6 @@ func TestConfigEnvOverrides(t *testing.T) {
"Host: want http://test:1234, got %q",
cfg.Host)
}
- if cfg.ApiKey != "env-key" {
- t.Errorf(
- "ApiKey: want env-key, got %q",
- cfg.ApiKey)
- }
}

func TestConfigDefaultHost(t *testing.T) {
@@ -166,7 +157,6 @@ func TestConfigDefaultHost(t *testing.T) {
// ~/.config/okg/config.json so we can verify the prod default.
t.Setenv("HOME", t.TempDir())
t.Setenv("OKG_HOST", "")
- t.Setenv("KLEX_API_KEY", "")
cfg, err := loadConfig()
if err != nil {
t.Fatal(err)
@@ -178,14 +168,69 @@ func TestConfigDefaultHost(t *testing.T) {
}
}

+// writeTestKey creates an isolated ~/.config/okg/config.json
+// in a temp dir with the given API key. Used by tests that need
+// loadConfig to return a key without touching the user's real
+// config.
+func writeTestKey(t *testing.T, key string) {
+ t.Helper()
+ t.Setenv("HOME", t.TempDir())
+ if err := saveConfig(&Config{ApiKey: key}); err != nil {
+ t.Fatal(err)
+ }
+}
+
+func TestAuthLoginKeyFlag(t *testing.T) {
+ t.Setenv("HOME", t.TempDir())
+ if err := runAuthLogin(
+ []string{"--key", "sk-flag"},
+ ); err != nil {
+ t.Fatal(err)
+ }
+ cfg, err := loadConfig()
+ if err != nil {
+ t.Fatal(err)
+ }
+ if cfg.ApiKey != "sk-flag" {
+ t.Errorf(
+ "ApiKey: want sk-flag, got %q", cfg.ApiKey)
+ }
+}
+
+func TestAuthLoginStdin(t *testing.T) {
+ t.Setenv("HOME", t.TempDir())
+
+ r, w, err := os.Pipe()
+ if err != nil {
+ t.Fatal(err)
+ }
+ orig := os.Stdin
+ os.Stdin = r
+ defer func() { os.Stdin = orig }()
+ go func() {
+ w.Write([]byte("sk-piped\n"))
+ w.Close()
+ }()
+
+ if err := runAuthLogin(nil); err != nil {
+ t.Fatal(err)
+ }
+ cfg, err := loadConfig()
+ if err != nil {
+ t.Fatal(err)
+ }
+ if cfg.ApiKey != "sk-piped" {
+ t.Errorf(
+ "ApiKey: want sk-piped, got %q", cfg.ApiKey)
+ }
+}
+
func TestRunRepoCreateArgs(t *testing.T) {
mock := newMockKleeRepo(t, 204, "")
defer mock.Close()

- os.Setenv("OKG_HOST", mock.URL)
- os.Setenv("KLEX_API_KEY", "test-key")
- defer os.Unsetenv("OKG_HOST")
- defer os.Unsetenv("KLEX_API_KEY")
+ writeTestKey(t, "test-key")
+ t.Setenv("OKG_HOST", mock.URL)

err := runRepoCreate([]string{
"my-repo", "--reader", "igor.agents",
@@ -209,10 +254,8 @@ func TestRunRepoCreateNoReader(t *testing.T) {
mock := newMockKleeRepo(t, 204, "")
defer mock.Close()

- os.Setenv("OKG_HOST", mock.URL)
- os.Setenv("KLEX_API_KEY", "test-key")
- defer os.Unsetenv("OKG_HOST")
- defer os.Unsetenv("KLEX_API_KEY")
+ writeTestKey(t, "test-key")
+ t.Setenv("OKG_HOST", mock.URL)

err := runRepoCreate([]string{"my-repo"})
if err != nil {
@@ -271,10 +314,8 @@ func TestRunRepoCreateServerError(t *testing.T) {
"klee://code.oscarkilo.com/.new-repo")
defer mock.Close()

- os.Setenv("OKG_HOST", mock.URL)
- os.Setenv("KLEX_API_KEY", "test-key")
- defer os.Unsetenv("OKG_HOST")
- defer os.Unsetenv("KLEX_API_KEY")
+ writeTestKey(t, "test-key")
+ t.Setenv("OKG_HOST", mock.URL)

err := runRepoCreate([]string{"my-repo"})
if err == nil {

# okg — Oscar Kilo Goodness

A command-line tool that bundles Oscar Kilo's externally usable

services into one binary. Today: git ops against

[klee](https://code.oscarkilo.com), and LLM embeddings against

[klex](https://oscarkilo.com/klex). More LLM utilities (`one`,

`exemplary`) coming as the legacy `klex-git` binaries fold in.

Designed for both humans and AI agents (Claude, OpenClaw) to

use directly from the command line.

## Install

```bash

go install oscarkilo.com/okg@latest

```

Or build from source:

```bash

git clone https://code.oscarkilo.com/okg

cd okg && go build .

```

## Setup

By default okg talks to the production klee host

(`https://code.oscarkilo.com`); the only setup you need is to give it

(`https://code.oscarkilo.com`); the only setup you need is your

your API key. Either:

API key. `okg auth login` saves it to

`~/.config/okg/config.json`.

```bash

# Interactive login — saves host + key to ~/.config/okg/config.json.

# Non-interactive (for agents and scripts).

okg auth login

okg auth login --key sk-...

cat ~/.klex.key | okg auth login # equivalent, ps-safe

# Or non-interactive: just set the API key.

# Interactive (prompts for host then key).

export KLEX_API_KEY=your-api-key

okg auth login

```

Override the host for dev/local work with `--host` on `auth login`,

Override the host for dev/local work with `--host` on `auth login`.

or with the `OKG_HOST` env var.

## Commands

```

okg repo list

okg pr list [--state open|closed]

okg pr create --head BRANCH [--base master] --title TITLE [--body BODY]

okg pr view NUMBER

okg pr diff NUMBER

okg pr comment NUMBER --body BODY [--approve | --request-changes]

okg pr merge NUMBER

okg pr close NUMBER

okg pr reopen NUMBER

okg auth login [--host HOST] [--user USERNAME]

okg auth login [--key KEY] [--host HOST]

okg embed [--model NAME] [--dims N] [--full-path]

(reads stdin → vectors on stdout)

```

### Coming next

- `okg one` — one LLM inference on one input (from

`klex-git/one`).

- `okg exemplary` — few-shot batch runner (from

`klex-git/exemplary`).

Once those land, the standalone `klex-git` binaries are

deprecated.

### Flags

- `--repo REPO` overrides auto-detected repo name

(normally parsed from `git remote get-url origin`)

- `--json` outputs raw JSON for any command

- `OKG_REPO` env var also overrides repo detection

## Repo Detection

Like `gh`, okg detects the repo from the current directory's

git remote:

```

git remote get-url origin

→ https://code.oscarkilo.com/widget.git

→ repo = "widget"

```

## Dependencies

- `oscarkilo.com/klex-git` for the LLM API client (transitional;

to be folded in once all `klex-git` binaries have moved here).

- Otherwise Go standard library only.

package main

import "bufio"

import "fmt"

import "io"

import "os"

import "strings"

func runAuth(args []string) error {

if len(args) == 0 {

return fmt.Errorf("usage: okg auth login")

}

switch args[0] {

case "login":

return runAuthLogin(args[1:])

default:

return fmt.Errorf(

"unknown auth command: %s", args[0])

}

// runAuthLogin saves a host + API key to ~/.config/okg/config.json.

// The key can come from --key, from stdin (pipe), or — when stdin

// is a TTY — from an interactive prompt. Host defaults to

// production unless --host is given (and, in interactive mode, the

// prompt offers an override).

func runAuthLogin(args []string) error {

host := ""

user := ""

key := ""

for i := 0; i < len(args); i++ {

switch args[i] {

case "--host":

i++

if i >= len(args) {

return fmt.Errorf(

"--host requires a value")

}

host = args[i]

case "--user":

case "--key":

i++

if i >= len(args) {

return fmt.Errorf(

"--user requires a value")

"--key requires a value")

}

user = args[i]

key = args[i]

default:

return fmt.Errorf(

"unknown flag: %s", args[i])

}

reader := bufio.NewReader(os.Stdin)

// Resolve API key: --key wins; otherwise read from stdin

// (piped) or prompt interactively.

if host == "" {

switch {

fmt.Printf("Host (default %s): ", DefaultHost)

case key != "":

line, _ := reader.ReadString('\n')

// Use as-is.

host = strings.TrimSpace(line)

case stdinIsPiped():

line, err := bufio.NewReader(os.Stdin).

ReadString('\n')

if err != nil && err != io.EOF {

return fmt.Errorf("reading stdin: %v", err)

}

key = strings.TrimSpace(line)

default:

// Interactive: optionally prompt for host, then key.

reader := bufio.NewReader(os.Stdin)

if host == "" {

host = DefaultHost

fmt.Printf("Host (default %s): ", DefaultHost)

line, _ := reader.ReadString('\n')

host = strings.TrimSpace(line)

}

fmt.Print("API key: ")

line, _ := reader.ReadString('\n')

key = strings.TrimSpace(line)

}

fmt.Print("API key: ")

if host == "" {

api_key, _ := reader.ReadString('\n')

host = DefaultHost

api_key = strings.TrimSpace(api_key)

}

if api_key == "" {

if key == "" {

return fmt.Errorf("API key is required")

return fmt.Errorf(

"API key required " +

"(pass --key, pipe via stdin, or " +

"enter at the prompt)")

}

cfg := &Config{Host: host, ApiKey: api_key}

cfg := &Config{Host: host, ApiKey: key}

if err := saveConfig(cfg); err != nil {

return fmt.Errorf("saving config: %v", err)

}

fmt.Printf("Saved config to %s\n", configPath())

return nil

}

// If --user given, call profile edit to map

// stdinIsPiped reports whether stdin is not a terminal — i.e.

// the API key to this username in mock who.

// a pipe or a redirected file. Used to decide between reading

if user != "" {

// stdin directly and prompting interactively.

cl := newKleeClient(cfg)

func stdinIsPiped() bool {

payload := map[string]string{

fi, err := os.Stdin.Stat()

"username": user,

100

if err != nil {

"name": user,

101

return false

}

err := cl.PostJSON(

"/login/profile/edit", payload, nil)

if err != nil {

return fmt.Errorf(

"setting username: %v", err)

}

fmt.Printf("Authenticated as %s\n", user)

}

102

}

103

return (fi.Mode() & os.ModeCharDevice) == 0

return nil

}

104

}

package main

import "encoding/json"

import "fmt"

import "os"

import "path/filepath"

// DefaultHost is the production klee host. There is exactly one for

// the foreseeable future. It's used by loadConfig (as the host

// fallback) and by `okg auth login` (as the interactive default).

const DefaultHost = "https://code.oscarkilo.com"

type Config struct {

Host string `json:"host"`

ApiKey string `json:"api_key"`

}

func configPath() string {

home, err := os.UserHomeDir()

if err != nil {

return ""

}

return filepath.Join(home, ".config", "okg", "config.json")

}

func loadConfig() (*Config, error) {

c := &Config{}

// Load from file.

path := configPath()

if path != "" {

data, err := os.ReadFile(path)

if err == nil {

json.Unmarshal(data, c)

}

// Env overrides.

// OKG_HOST env override exists for tests (TestMain points it at

// localhost so accidental hits to prod fail fast). It is NOT a

// user-facing config knob; `okg auth login --host` is.

if v := os.Getenv("OKG_HOST"); v != "" {

c.Host = v

}

if v := os.Getenv("KLEX_API_KEY"); v != "" {

c.ApiKey = v

}

// Default to prod. Tests set OKG_HOST in TestMain to a localhost

// URL so they can't accidentally reach it.

if c.Host == "" {

c.Host = DefaultHost

}

return c, nil

}

func saveConfig(c *Config) error {

path := configPath()

if path == "" {

return fmt.Errorf("cannot determine home directory")

}

dir := filepath.Dir(path)

if err := os.MkdirAll(dir, 0700); err != nil {

return fmt.Errorf("mkdir %s: %v", dir, err)

}

data, err := json.MarshalIndent(c, "", " ")

if err != nil {

return err

}

return os.WriteFile(path, data, 0600)

}

package main

import "flag"

import "fmt"

import "io"

import "os"

import "oscarkilo.com/klex-git/api"

// runEmbed converts stdin text into embedding vectors, written to

// stdout one vector per line, space-separated floats. Mirrors the

// (now-deprecated) `klex-git/embed` binary.

func runEmbed(args []string) error {

fs := flag.NewFlagSet("embed", flag.ContinueOnError)

model := fs.String("model",

"openai:text-embedding-3-small",

"embedding model name")

dims := fs.Int("dims", 1536,

"number of vector dimensions to return")

fullPath := fs.Bool("full-path", false,

"return one vector per prefix of input "+

"(otherwise just the final vector)")

if err := fs.Parse(args); err != nil {

return err

}

cfg, err := loadConfig()

if err != nil {

return err

}

if cfg.ApiKey == "" {

return fmt.Errorf(

"no API key — run `okg auth login`")

"no API key — run `okg auth login --key sk-...`")

}

client := newKlexClient(cfg)

text, err := io.ReadAll(os.Stdin)

if err != nil {

return fmt.Errorf("read stdin: %v", err)

}

vectors, err := client.Embed(api.EmbedRequest{

Text: string(text),

Model: *model,

Dims: *dims,

FullPath: *fullPath,

})

if err != nil {

return fmt.Errorf("embed: %v", err)

}

for _, vector := range vectors {

for i, w := range vector {

if i > 0 {

fmt.Print(" ")

}

fmt.Printf("%g", w)

}

fmt.Println()

}

return nil

}

package main

import "fmt"

import "os"

func main() {

args := os.Args[1:]

if len(args) == 0 {

printUsage()

os.Exit(1)

}

var err error

switch args[0] {

case "pr":

err = runPR(args[1:])

case "repo":

err = runRepo(args[1:])

case "auth":

err = runAuth(args[1:])

case "embed":

err = runEmbed(args[1:])

case "help", "--help", "-h":

printUsage()

return

default:

fmt.Fprintf(os.Stderr, "unknown command: %s\n", args[0])

printUsage()

os.Exit(1)

}

if err != nil {

fmt.Fprintf(os.Stderr, "error: %v\n", err)

os.Exit(1)

}

func printUsage() {

fmt.Fprintf(os.Stderr, `NAME

okg — Oscar Kilo Goodness

SETUP

okg auth login

--key KEY API key (also accepted via stdin)

--host HOST klee host (default: production)

--user USERNAME login as USERNAME

GIT REPOS

okg repo list

--json output raw JSON

okg repo create NAME

--reader USER grant read to USER (default: anyone)

PULL REQUESTS

okg pr list

--state STATE open or closed (default: open)

--json output raw JSON

okg pr create

--head BRANCH source branch

--base BRANCH target branch (default: master)

--title TITLE PR title

--body BODY PR body (optional)

--json output raw JSON

okg pr view NUMBER

--json output raw JSON

okg pr diff NUMBER

okg pr comment NUMBER

--body BODY comment body

--approve also approve the PR

--request-changes also request changes

okg pr merge NUMBER

--json output raw JSON

okg pr close NUMBER

--json output raw JSON

okg pr reopen NUMBER

--json output raw JSON

ARTIFICIAL INTELLIGENCE

okg embed

--model NAME embedding model

(default: openai:text-embedding-3-small)

--dims N number of dimensions (default: 1536)

--full-path one vector per prefix of input

(reads stdin; writes vectors to stdout, one per line)

GLOBAL FLAGS

--repo REPO override auto-detected repo name

--json output raw JSON (where applicable)

EXAMPLES

Setup

okg auth login

okg auth login --key sk-...

100

cat ~/.klex.key | okg auth login

100

101

Git repos

102

Git repos

102

okg repo list

103

okg repo list

103

okg repo create my-new-repo

104

okg repo create my-new-repo

104

105

Pull requests

106

Pull requests

106

okg pr list --state open

107

okg pr list --state open

107

okg pr view 42

108

okg pr view 42

108

okg pr comment 42 --body 'LGTM' --approve

109

okg pr comment 42 --body 'LGTM' --approve

109

110

Artificial intelligence

111

Artificial intelligence

111

echo 'hello world' | okg embed --dims 384

112

echo 'hello world' | okg embed --dims 384

112

113

}

114

}

package main

import "encoding/json"

import "net/http"

import "net/http/httptest"

import "os"

import "strings"

import "testing"

import "time"

import "oscarkilo.com/okg/klee"

// TestMain prevents the entire test binary from accidentally reaching

// the production klee host (which is the default in loadConfig). Set

// it once here; individual tests that need a specific URL (e.g. a

// mock httptest server) still set OKG_HOST themselves.

func TestMain(m *testing.M) {

os.Setenv("OKG_HOST", "http://localhost:42069")

os.Exit(m.Run())

}

func TestRepoRegex(t *testing.T) {

check := func(url, want string) {

t.Helper()

m := repoRegex.FindStringSubmatch(url)

if want == "" {

if m != nil {

t.Errorf(

"%q: want no match, got %q", url, m[1])

}

return

}

if m == nil {

t.Errorf(

"%q: want %q, got no match", url, want)

return

}

if m[1] != want {

t.Errorf(

"%q: want %q, got %q", url, want, m[1])

}

check(

"https://code.oscarkilo.com/widget.git",

"widget")

check(

"https://code.oscarkilo.com/klee.git",

"klee")

check(

"https://code.oscarkilo.com/my-repo.git",

"my-repo")

check(

"https://code.oscarkilo.com/a123.git",

"a123")

check(

"https://github.com/foo/bar.git",

"")

check("not-a-url", "")

}

func TestResolveRepo(t *testing.T) {

// Flag takes priority.

repo, err := resolveRepo("from-flag")

if err != nil {

t.Fatal(err)

}

if repo != "from-flag" {

t.Errorf("want from-flag, got %q", repo)

}

// Env var takes priority over detection.

os.Setenv("OKG_REPO", "from-env")

defer os.Unsetenv("OKG_REPO")

repo, err = resolveRepo("")

if err != nil {

t.Fatal(err)

}

if repo != "from-env" {

t.Errorf("want from-env, got %q", repo)

}

func TestParsePRFlags(t *testing.T) {

f, rest, err := parsePRFlags([]string{

"--repo", "widget", "--json", "42",

})

if err != nil {

t.Fatal(err)

}

if f.repo != "widget" {

t.Errorf(

"repo: want widget, got %q", f.repo)

}

if !f.asJSON {

t.Error("asJSON: want true")

}

if len(rest) != 1 || rest[0] != "42" {

t.Errorf("rest: want [42], got %v", rest)

}

100

}

100

}

101

102

func TestParsePRFlagsEmpty(t *testing.T) {

102

func TestParsePRFlagsEmpty(t *testing.T) {

103

f, rest, err := parsePRFlags(nil)

103

f, rest, err := parsePRFlags(nil)

104

if err != nil {

104

if err != nil {

105

t.Fatal(err)

105

t.Fatal(err)

106

}

106

}

107

if f.repo != "" {

107

if f.repo != "" {

108

t.Errorf(

108

t.Errorf(

109

"repo: want empty, got %q", f.repo)

109

"repo: want empty, got %q", f.repo)

110

}

110

}

111

if f.asJSON {

111

if f.asJSON {

112

t.Error("asJSON: want false")

112

t.Error("asJSON: want false")

113

}

113

}

114

if len(rest) != 0 {

114

if len(rest) != 0 {

115

t.Errorf("rest: want empty, got %v", rest)

115

t.Errorf("rest: want empty, got %v", rest)

116

}

116

}

117

}

117

}

118

119

func TestParsePRFlagsMissingValue(t *testing.T) {

119

func TestParsePRFlagsMissingValue(t *testing.T) {

120

_, _, err := parsePRFlags([]string{"--repo"})

120

_, _, err := parsePRFlags([]string{"--repo"})

121

if err == nil {

121

if err == nil {

122

t.Error("want error for --repo without value")

122

t.Error("want error for --repo without value")

123

}

123

}

124

}

124

}

125

126

func TestAge(t *testing.T) {

126

func TestAge(t *testing.T) {

127

check := func(d time.Duration, want string) {

127

check := func(d time.Duration, want string) {

128

t.Helper()

128

t.Helper()

129

got := age(time.Now().Add(-d))

129

got := age(time.Now().Add(-d))

130

if got != want {

130

if got != want {

131

t.Errorf(

131

t.Errorf(

132

"age(-%v): want %q, got %q",

132

"age(-%v): want %q, got %q",

133

d, want, got)

133

d, want, got)

134

}

134

}

135

}

135

}

136

check(30*time.Second, "just now")

136

check(30*time.Second, "just now")

137

check(5*time.Minute, "5m")

137

check(5*time.Minute, "5m")

138

check(3*time.Hour, "3h")

138

check(3*time.Hour, "3h")

139

check(48*time.Hour, "2d")

139

check(48*time.Hour, "2d")

140

}

140

}

141

142

func TestConfigEnvOverrides(t *testing.T) {

142

func TestConfigOKGHostOverride(t *testing.T) {

143

os.Setenv("OKG_HOST", "http://test:1234")

143

t.Setenv("OKG_HOST", "http://test:1234")

144

os.Setenv("KLEX_API_KEY", "env-key")

145

defer os.Unsetenv("OKG_HOST")

146

defer os.Unsetenv("KLEX_API_KEY")

147

148

cfg, err := loadConfig()

144

cfg, err := loadConfig()

149

if err != nil {

145

if err != nil {

150

t.Fatal(err)

146

t.Fatal(err)

151

}

147

}

152

if cfg.Host != "http://test:1234" {

148

if cfg.Host != "http://test:1234" {

153

t.Errorf(

149

t.Errorf(

154

"Host: want http://test:1234, got %q",

150

"Host: want http://test:1234, got %q",

155

cfg.Host)

151

cfg.Host)

156

}

152

}

157

if cfg.ApiKey != "env-key" {

158

t.Errorf(

159

"ApiKey: want env-key, got %q",

160

cfg.ApiKey)

161

}

162

}

153

}

163

154

164

func TestConfigDefaultHost(t *testing.T) {

155

func TestConfigDefaultHost(t *testing.T) {

165

// Bypass the TestMain guardrail and isolate from any real

156

// Bypass the TestMain guardrail and isolate from any real

166

// ~/.config/okg/config.json so we can verify the prod default.

157

// ~/.config/okg/config.json so we can verify the prod default.

167

t.Setenv("HOME", t.TempDir())

158

t.Setenv("HOME", t.TempDir())

168

t.Setenv("OKG_HOST", "")

159

t.Setenv("OKG_HOST", "")

169

t.Setenv("KLEX_API_KEY", "")

170

cfg, err := loadConfig()

160

cfg, err := loadConfig()

171

if err != nil {

161

if err != nil {

172

t.Fatal(err)

162

t.Fatal(err)

173

}

163

}

174

if cfg.Host != "https://code.oscarkilo.com" {

164

if cfg.Host != "https://code.oscarkilo.com" {

175

t.Errorf(

165

t.Errorf(

176

"Host: want https://code.oscarkilo.com, got %q",

166

"Host: want https://code.oscarkilo.com, got %q",

177

cfg.Host)

167

cfg.Host)

178

}

168

}

179

}

169

}

180

170

171

// writeTestKey creates an isolated ~/.config/okg/config.json

172

// in a temp dir with the given API key. Used by tests that need

173

// loadConfig to return a key without touching the user's real

174

// config.

175

func writeTestKey(t *testing.T, key string) {

176

t.Helper()

177

t.Setenv("HOME", t.TempDir())

178

if err := saveConfig(&Config{ApiKey: key}); err != nil {

179

t.Fatal(err)

180

}

181

}

182

183

func TestAuthLoginKeyFlag(t *testing.T) {

184

t.Setenv("HOME", t.TempDir())

185

if err := runAuthLogin(

186

[]string{"--key", "sk-flag"},

187

); err != nil {

188

t.Fatal(err)

189

}

190

cfg, err := loadConfig()

191

if err != nil {

192

t.Fatal(err)

193

}

194

if cfg.ApiKey != "sk-flag" {

195

t.Errorf(

196

"ApiKey: want sk-flag, got %q", cfg.ApiKey)

197

}

198

}

199

200

func TestAuthLoginStdin(t *testing.T) {

201

t.Setenv("HOME", t.TempDir())

202

203

r, w, err := os.Pipe()

204

if err != nil {

205

t.Fatal(err)

206

}

207

orig := os.Stdin

208

os.Stdin = r

209

defer func() { os.Stdin = orig }()

210

go func() {

211

w.Write([]byte("sk-piped\n"))

212

w.Close()

213

}()

214

215

if err := runAuthLogin(nil); err != nil {

216

t.Fatal(err)

217

}

218

cfg, err := loadConfig()

219

if err != nil {

220

t.Fatal(err)

221

}

222

if cfg.ApiKey != "sk-piped" {

223

t.Errorf(

224

"ApiKey: want sk-piped, got %q", cfg.ApiKey)

225

}

226

}

227

181

func TestRunRepoCreateArgs(t *testing.T) {

228

func TestRunRepoCreateArgs(t *testing.T) {

182

mock := newMockKleeRepo(t, 204, "")

229

mock := newMockKleeRepo(t, 204, "")

183

defer mock.Close()

230

defer mock.Close()

184

231

185

os.Setenv("OKG_HOST", mock.URL)

232

writeTestKey(t, "test-key")

186

os.Setenv("KLEX_API_KEY", "test-key")

233

t.Setenv("OKG_HOST", mock.URL)

187

defer os.Unsetenv("OKG_HOST")

188

defer os.Unsetenv("KLEX_API_KEY")

189

234

190

err := runRepoCreate([]string{

235

err := runRepoCreate([]string{

191

"my-repo", "--reader", "igor.agents",

236

"my-repo", "--reader", "igor.agents",

192

})

237

})

193

if err != nil {

238

if err != nil {

194

t.Fatal(err)

239

t.Fatal(err)

195

}

240

}

196

if mock.req.RepoName != "my-repo" {

241

if mock.req.RepoName != "my-repo" {

197

t.Errorf(

242

t.Errorf(

198

"repo_name: want my-repo, got %q",

243

"repo_name: want my-repo, got %q",

199

mock.req.RepoName)

244

mock.req.RepoName)

200

}

245

}

201

if mock.req.ReaderUsername != "igor.agents" {

246

if mock.req.ReaderUsername != "igor.agents" {

202

t.Errorf(

247

t.Errorf(

203

"reader: want igor.agents, got %q",

248

"reader: want igor.agents, got %q",

204

mock.req.ReaderUsername)

249

mock.req.ReaderUsername)

205

}

250

}

206

}

251

}

207

252

208

func TestRunRepoCreateNoReader(t *testing.T) {

253

func TestRunRepoCreateNoReader(t *testing.T) {

209

mock := newMockKleeRepo(t, 204, "")

254

mock := newMockKleeRepo(t, 204, "")

210

defer mock.Close()

255

defer mock.Close()

211

256

212

os.Setenv("OKG_HOST", mock.URL)

257

writeTestKey(t, "test-key")

213

os.Setenv("KLEX_API_KEY", "test-key")

258

t.Setenv("OKG_HOST", mock.URL)

214

defer os.Unsetenv("OKG_HOST")

215

defer os.Unsetenv("KLEX_API_KEY")

216

259

217

err := runRepoCreate([]string{"my-repo"})

260

err := runRepoCreate([]string{"my-repo"})

218

if err != nil {

261

if err != nil {

219

t.Fatal(err)

262

t.Fatal(err)

220

}

263

}

221

if mock.req.ReaderUsername != "" {

264

if mock.req.ReaderUsername != "" {

222

t.Errorf(

265

t.Errorf(

223

"reader: want empty, got %q",

266

"reader: want empty, got %q",

224

mock.req.ReaderUsername)

267

mock.req.ReaderUsername)

225

}

268

}

226

}

269

}

227

270

228

func TestRunRepoCreateMissingName(t *testing.T) {

271

func TestRunRepoCreateMissingName(t *testing.T) {

229

err := runRepoCreate(nil)

272

err := runRepoCreate(nil)

230

if err == nil {

273

if err == nil {

231

t.Fatal("want error for missing name")

274

t.Fatal("want error for missing name")

232

}

275

}

233

}

276

}

234

277

235

func TestRunRepoCreateReaderMissingValue(

278

func TestRunRepoCreateReaderMissingValue(

236

t *testing.T,

279

t *testing.T,

237

) {

280

) {

238

err := runRepoCreate([]string{

281

err := runRepoCreate([]string{

239

"my-repo", "--reader",

282

"my-repo", "--reader",

240

})

283

})

241

if err == nil {

284

if err == nil {

242

t.Fatal(

285

t.Fatal(

243

"want error for --reader without value")

286

"want error for --reader without value")

244

}

287

}

245

}

288

}

246

289

247

func TestRunRepoCreateUnknownFlag(t *testing.T) {

290

func TestRunRepoCreateUnknownFlag(t *testing.T) {

248

err := runRepoCreate([]string{

291

err := runRepoCreate([]string{

249

"my-repo", "--bogus",

292

"my-repo", "--bogus",

250

})

293

})

251

if err == nil {

294

if err == nil {

252

t.Fatal("want error for unknown flag")

295

t.Fatal("want error for unknown flag")

253

}

296

}

254

}

297

}

255

298

256

func TestRunRepoCreateDuplicateName(

299

func TestRunRepoCreateDuplicateName(

257

t *testing.T,

300

t *testing.T,

258

) {

301

) {

259

err := runRepoCreate([]string{

302

err := runRepoCreate([]string{

260

"my-repo", "extra",

303

"my-repo", "extra",

261

})

304

})

262

if err == nil {

305

if err == nil {

263

t.Fatal(

306

t.Fatal(

264

"want error for extra positional arg")

307

"want error for extra positional arg")

265

}

308

}

266

}

309

}

267

310

268

func TestRunRepoCreateServerError(t *testing.T) {

311

func TestRunRepoCreateServerError(t *testing.T) {

269

mock := newMockKleeRepo(t, 403,

312

mock := newMockKleeRepo(t, 403,

270

"you are not an owner of "+

313

"you are not an owner of "+

271

"klee://code.oscarkilo.com/.new-repo")

314

"klee://code.oscarkilo.com/.new-repo")

272

defer mock.Close()

315

defer mock.Close()

273

316

274

os.Setenv("OKG_HOST", mock.URL)

317

writeTestKey(t, "test-key")

275

os.Setenv("KLEX_API_KEY", "test-key")

318

t.Setenv("OKG_HOST", mock.URL)

276

defer os.Unsetenv("OKG_HOST")

277

defer os.Unsetenv("KLEX_API_KEY")

278

319

279

err := runRepoCreate([]string{"my-repo"})

320

err := runRepoCreate([]string{"my-repo"})

280

if err == nil {

321

if err == nil {

281

t.Fatal("want error on 403")

322

t.Fatal("want error on 403")

282

}

323

}

283

if !strings.Contains(err.Error(), "403") {

324

if !strings.Contains(err.Error(), "403") {

284

t.Errorf("want 403 in error, got %q", err)

325

t.Errorf("want 403 in error, got %q", err)

285

}

326

}

286

}

327

}

287

328

288

// mockKleeRepo captures the /.add-repo request.

329

// mockKleeRepo captures the /.add-repo request.

289

type mockKleeRepo struct {

330

type mockKleeRepo struct {

290

*httptest.Server

331

*httptest.Server

291

req klee.CreateRepoRequest

332

req klee.CreateRepoRequest

292

}

333

}

293

334

294

func newMockKleeRepo(

335

func newMockKleeRepo(

295

t *testing.T, status int, body string,

336

t *testing.T, status int, body string,

296

) *mockKleeRepo {

337

) *mockKleeRepo {

297

t.Helper()

338

t.Helper()

298

mk := &mockKleeRepo{}

339

mk := &mockKleeRepo{}

299

mk.Server = httptest.NewServer(

340

mk.Server = httptest.NewServer(

300

http.HandlerFunc(func(

341

http.HandlerFunc(func(

301

w http.ResponseWriter, r *http.Request,

342

w http.ResponseWriter, r *http.Request,

302

) {

343

) {

303

json.NewDecoder(r.Body).Decode(&mk.req)

344

json.NewDecoder(r.Body).Decode(&mk.req)

304

w.WriteHeader(status)

345

w.WriteHeader(status)

305

if body != "" {

346

if body != "" {

306

w.Write([]byte(body))

347

w.Write([]byte(body))

307

}

348

}

308

}))

349

}))

309

return mk

350

return mk

310

}

351

}