This repository has been archived on 2026-11-17. You can view files and clone it, but cannot push or open issues or pull requests.
caelum0x 49b183818c Unify gitgram + aitimemachine into the monorepo (de-submodule) and merge vendored engines
Convert gitgram/ and aitimemachine/ from embedded git repos (which showed as
opaque submodule gitlinks on GitHub) into fully-tracked first-party content.

AITM now merges its 7 vendored repos as first-party engines:
- memory: beads (Go task DAG) + context7 (docs SDK), unified into saved_contexts
- git: vendored C git (bundled binary) + gitnexus (in-process code intelligence)
- agentic: a2a (@a2a-js/sdk) + pal (AITM-managed Python subprocess)

Includes the full session's product build: Gitgram web/mobile/backend features,
AITM website/CLI/MCP, the unified memory layer, engine build tooling
(scripts/build-engines.sh, Dockerfile, CI), docs (README, ENGINES.md, ARCHITECTURE.md),
and extensive test suites.

Build artifacts, node_modules, external/, and gemini-cli are gitignored.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>
2026-06-23 14:14:09 +03:00

286 lines
6.9 KiB
Go

package main
import (
"reflect"
"strings"
"testing"
)
func TestTokenizeBatchLine(t *testing.T) {
tests := []struct {
name string
in string
want []string
wantErr bool
}{
{
name: "simple",
in: "close bd-1 done",
want: []string{"close", "bd-1", "done"},
},
{
name: "tabs and spaces",
in: "close\tbd-1 done",
want: []string{"close", "bd-1", "done"},
},
{
name: "quoted with spaces",
in: `update bd-2 title="hello world"`,
want: []string{"update", "bd-2", "title=hello world"},
},
{
name: "escaped quote",
in: `create bug 1 "say \"hi\""`,
want: []string{"create", "bug", "1", `say "hi"`},
},
{
name: "escaped backslash",
in: `create bug 1 "back\\slash"`,
want: []string{"create", "bug", "1", `back\slash`},
},
{
name: "unterminated quote",
in: `close bd-1 "oops`,
wantErr: true,
},
{
name: "empty string",
in: "",
want: nil,
},
{
name: "empty quoted",
in: `update bd-1 title=""`,
want: []string{"update", "bd-1", "title="},
},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
got, err := tokenizeBatchLine(tt.in)
if (err != nil) != tt.wantErr {
t.Fatalf("tokenizeBatchLine(%q) err = %v, wantErr %v", tt.in, err, tt.wantErr)
}
if tt.wantErr {
return
}
if !reflect.DeepEqual(got, tt.want) {
t.Errorf("tokenizeBatchLine(%q) = %v, want %v", tt.in, got, tt.want)
}
})
}
}
func TestParseBatchScript(t *testing.T) {
script := `# leading comment
# another
close bd-1 stale
update bd-2 status=in_progress priority=1
create task 2 "triage the backlog"
dep add bd-3 bd-4
dep add bd-3 bd-5 related
dep remove bd-6 bd-7
dep rm bd-8 bd-9
`
ops, err := parseBatchScript(strings.NewReader(script))
if err != nil {
t.Fatalf("parseBatchScript: %v", err)
}
wantCmds := []string{
"close",
"update",
"create",
"dep.add",
"dep.add",
"dep.remove",
"dep.remove",
}
if len(ops) != len(wantCmds) {
t.Fatalf("got %d ops, want %d: %+v", len(ops), len(wantCmds), ops)
}
for i, op := range ops {
if op.cmd != wantCmds[i] {
t.Errorf("op %d: cmd = %q, want %q", i, op.cmd, wantCmds[i])
}
if op.line == 0 {
t.Errorf("op %d: line number not set", i)
}
}
// Spot check: create title is one token via quoting
create := ops[2]
if create.cmd != "create" {
t.Fatalf("expected create, got %q", create.cmd)
}
if len(create.args) != 3 {
t.Fatalf("create args = %v, want 3 tokens", create.args)
}
if create.args[2] != "triage the backlog" {
t.Errorf("create title = %q, want %q", create.args[2], "triage the backlog")
}
// dep.add with type
depWithType := ops[4]
if depWithType.cmd != "dep.add" || len(depWithType.args) != 3 || depWithType.args[2] != "related" {
t.Errorf("dep.add with type mismatch: %+v", depWithType)
}
}
func TestParseBatchScript_Empty(t *testing.T) {
ops, err := parseBatchScript(strings.NewReader(""))
if err != nil {
t.Fatalf("parseBatchScript empty: %v", err)
}
if len(ops) != 0 {
t.Errorf("expected 0 ops, got %d", len(ops))
}
}
func TestParseBatchScript_OnlyCommentsAndBlank(t *testing.T) {
ops, err := parseBatchScript(strings.NewReader("# comment\n\n \n# another\n"))
if err != nil {
t.Fatalf("parseBatchScript: %v", err)
}
if len(ops) != 0 {
t.Errorf("expected 0 ops, got %d", len(ops))
}
}
func TestParseBatchScript_UnsupportedCommand(t *testing.T) {
_, err := parseBatchScript(strings.NewReader("show bd-1\n"))
if err == nil {
t.Fatal("expected error for unsupported command")
}
if !strings.Contains(err.Error(), "unsupported batch command") {
t.Errorf("error should mention unsupported command, got: %v", err)
}
if !strings.Contains(err.Error(), "line 1") {
t.Errorf("error should include line number, got: %v", err)
}
}
func TestParseBatchScript_UnsupportedCommandOnLaterLine(t *testing.T) {
script := "close bd-1\nshow bd-2\n"
_, err := parseBatchScript(strings.NewReader(script))
if err == nil {
t.Fatal("expected error")
}
if !strings.Contains(err.Error(), "line 2") {
t.Errorf("error should include line 2, got: %v", err)
}
}
func TestParseBatchScript_DepRequiresSubcommand(t *testing.T) {
_, err := parseBatchScript(strings.NewReader("dep\n"))
if err == nil {
t.Fatal("expected error for bare 'dep'")
}
if !strings.Contains(err.Error(), "subcommand") {
t.Errorf("error should mention subcommand, got: %v", err)
}
}
func TestParseBatchScript_DepUnknownSubcommand(t *testing.T) {
_, err := parseBatchScript(strings.NewReader("dep list bd-1\n"))
if err == nil {
t.Fatal("expected error for unknown dep subcommand")
}
if !strings.Contains(err.Error(), "dep subcommand") {
t.Errorf("error should mention dep subcommand, got: %v", err)
}
}
func TestParseBatchScript_UnterminatedQuote(t *testing.T) {
_, err := parseBatchScript(strings.NewReader(`create task 1 "oops`))
if err == nil {
t.Fatal("expected error for unterminated quote")
}
}
func TestParseUpdateKVs(t *testing.T) {
tests := []struct {
name string
in []string
want map[string]interface{}
wantErr bool
}{
{
name: "status and priority",
in: []string{"status=in_progress", "priority=1"},
want: map[string]interface{}{"status": "in_progress", "priority": 1},
},
{
name: "title",
in: []string{"title=new title"},
want: map[string]interface{}{"title": "new title"},
},
{
name: "assignee blank allowed (unassign)",
in: []string{"assignee="},
want: map[string]interface{}{"assignee": ""},
},
{
name: "unsupported key",
in: []string{"description=foo"},
wantErr: true,
},
{
name: "missing equals",
in: []string{"status"},
wantErr: true,
},
{
name: "invalid priority",
in: []string{"priority=high"},
wantErr: true,
},
{
name: "empty status",
in: []string{"status="},
wantErr: true,
},
{
name: "empty title",
in: []string{"title="},
wantErr: true,
},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
got, err := parseUpdateKVs(tt.in)
if (err != nil) != tt.wantErr {
t.Fatalf("parseUpdateKVs err = %v, wantErr %v", err, tt.wantErr)
}
if tt.wantErr {
return
}
if !reflect.DeepEqual(got, tt.want) {
t.Errorf("parseUpdateKVs = %v, want %v", got, tt.want)
}
})
}
}
func TestBatchCmd_Registered(t *testing.T) {
// Ensure 'bd batch' is wired into rootCmd with the correct group.
cmd, _, err := rootCmd.Find([]string{"batch"})
if err != nil {
t.Fatalf("rootCmd.Find batch: %v", err)
}
if cmd == nil || cmd.Name() != "batch" {
t.Fatalf("expected batch command, got %+v", cmd)
}
if cmd.GroupID != "maint" {
t.Errorf("batch GroupID = %q, want %q", cmd.GroupID, "maint")
}
if cmd.Flags().Lookup("file") == nil {
t.Error("batch missing --file flag")
}
if cmd.Flags().Lookup("dry-run") == nil {
t.Error("batch missing --dry-run flag")
}
if cmd.Flags().Lookup("message") == nil {
t.Error("batch missing --message flag")
}
}