Enhance command interface (#2)

* Generic reasoner for commands (single and sequence)
* Support Python command
* Support Golan
* Support language commands via <codeblock>

Author: fogfish

README.md

@@ -49,6 +49,7 @@ In this library, an agent is defined as a side-effect function `ƒ: A ⟼ B`, wh
 - [Quick example](#quick-example)
 - [Agent Architecture](#agent-architecture)
   - [Commands \& Tools](#commands--tools)
+    - [Supported commands](#supported-commands)
   - [Chaining agents](#chaining-agents)
 - [How To Contribute](#how-to-contribute)
   - [commit message](#commit-message)
@@ -192,6 +193,10 @@ When constructing a prompt, it is essential to include a section that "advertise
 
 The [script example](./examples/script/script.go) demonstrates a simple agent that utilizes `bash` to generate and modify files on the local filesystem.
 
+#### Supported commands
+* `bash` execute bash script or single command
+* `golang` execute golang code block
+* `python` execute python code block
 
 ### Chaining agents
 

command/bash.go

@@ -11,6 +11,7 @@ package command
 import (
 	"bytes"
 	"fmt"
+	"os"
 	"os/exec"
 
 	"github.com/kshard/chatter"
@@ -24,15 +25,40 @@ const BASH = "bash"
 func Bash(os, dir string) thinker.Cmd {
 	return thinker.Cmd{
 		Cmd:    BASH,
-		Short:  fmt.Sprintf("executes shell command, strictly adhere shell command syntaxt to %s", os),
-		Syntax: "bash <command>",
+		Short:  fmt.Sprintf("executes shell command, strictly adhere shell command syntaxt to %s. Enclose the bash commands in <codeblock> tags.", os),
+		Syntax: "bash <codeblock>source code</codeblock>",
 		Run:    bash(os, dir),
 	}
 }
 
+func shfile(dir, code string) (string, error) {
+	fd, err := os.CreateTemp(dir, "job-*.sh")
+	if err != nil {
+		return "", err
+	}
+	defer fd.Close()
+
+	_, err = fd.WriteString(code)
+	if err != nil {
+		return "", err
+	}
+
+	return fd.Name(), nil
+}
+
 func bash(os string, dir string) func(chatter.Reply) (float64, thinker.CmdOut, error) {
 	return func(command chatter.Reply) (float64, thinker.CmdOut, error) {
-		cmd := exec.Command("bash", "-c", command.Text)
+		code, err := CodeBlock(BASH, command.Text)
+		if err != nil {
+			return 0.00, thinker.CmdOut{Cmd: BASH}, err
+		}
+
+		file, err := shfile(dir, code)
+		if err != nil {
+			return 0.00, thinker.CmdOut{Cmd: BASH}, err
+		}
+
+		cmd := exec.Command("bash", file)
 		var stdout bytes.Buffer
 		var stderr bytes.Buffer
 		cmd.Dir = dir

command/bash_test.go

@@ -16,8 +16,8 @@ import (
 )
 
 func TestBash(t *testing.T) {
-	cmd := Bash("", "")
-	conf, out, err := cmd.Run(chatter.Reply{Text: "ls"})
+	cmd := Bash("", "/tmp")
+	conf, out, err := cmd.Run(chatter.Reply{Text: "<codeblock>ls</codeblock>"})
 
 	it.Then(t).Should(
 		it.Nil(err),

command/codeblock.go

@@ -0,0 +1,35 @@
+//
+// Copyright (C) 2025 Dmitry Kolesnikov
+//
+// This file may be modified and distributed under the terms
+// of the MIT license.  See the LICENSE file for details.
+// https://github.com/kshard/thinker
+//
+
+package command
+
+import (
+	"fmt"
+	"strings"
+
+	"github.com/kshard/thinker"
+)
+
+func CodeBlock(tool string, str string) (string, error) {
+	const btag = "<codeblock>"
+	const etag = "</codeblock>"
+
+	b := strings.Index(str, btag)
+	e := strings.Index(str, etag)
+	if b == -1 || e == -1 || b >= e {
+		err := thinker.Feedback(
+			fmt.Sprintf("The TOOL:%s has failed, improve the response based on feedback:", tool),
+
+			fmt.Sprintf(`Strictly adhere %s code formatting and enclose the %s code in <codeblock> tags`, tool, tool),
+		)
+		return "", err
+	}
+
+	code := str[b+len(btag) : e]
+	return code, nil
+}

command/codeblock_test.go

@@ -0,0 +1,48 @@
+//
+// Copyright (C) 2025 Dmitry Kolesnikov
+//
+// This file may be modified and distributed under the terms
+// of the MIT license.  See the LICENSE file for details.
+// https://github.com/kshard/thinker
+//
+
+package command
+
+import (
+	"testing"
+
+	"github.com/fogfish/it/v2"
+)
+
+func TestCodeBlock(t *testing.T) {
+	t.Run("Success", func(t *testing.T) {
+		for in, ex := range map[string]string{
+			"<codeblock>a</codeblock>":       "a",
+			"xxx<codeblock>a</codeblock>":    "a",
+			"<codeblock>a</codeblock>xxx":    "a",
+			"xxx<codeblock>a</codeblock>xxx": "a",
+		} {
+			code, err := CodeBlock(BASH, in)
+			it.Then(t).Should(
+				it.Nil(err),
+				it.Equal(code, ex),
+			)
+		}
+	})
+
+	t.Run("Failed", func(t *testing.T) {
+		for _, in := range []string{
+			"<codeblock>a",
+			"a</codeblock>",
+			"</codeblock>a<codeblock>",
+			"xxxcodeblock>a</codeblock>",
+			"<codeblock>a<codeblock>xxx",
+			"xxx<codeblock>acodeblockxxx",
+		} {
+			_, err := CodeBlock(BASH, in)
+			it.Then(t).ShouldNot(
+				it.Nil(err),
+			)
+		}
+	})
+}

command/golang.go

@@ -0,0 +1,144 @@
+//
+// Copyright (C) 2025 Dmitry Kolesnikov
+//
+// This file may be modified and distributed under the terms
+// of the MIT license.  See the LICENSE file for details.
+// https://github.com/kshard/thinker
+//
+
+package command
+
+import (
+	"bytes"
+	"fmt"
+	"os"
+	"os/exec"
+	"path/filepath"
+
+	"github.com/kshard/chatter"
+	"github.com/kshard/thinker"
+)
+
+// A unique name for bash (the shell)
+const GOLANG = "go"
+
+// Create new Golang command, defining goroot
+func Golang(gopath string) thinker.Cmd {
+	return thinker.Cmd{
+		Cmd:    GOLANG,
+		Short:  "Use golang to execute scripts (package main) that help you complete your task. Enclose the golang code in <codeblock> tags.",
+		Syntax: `go  <codeblock>source code</codeblock>`,
+		Run:    golang(gopath),
+	}
+}
+
+func goSourceCode(gopath string) string {
+	return filepath.Join(gopath, "src", "github.com", "kshard", "jobs")
+}
+
+func goSetup(gopath string) error {
+	gojob := goSourceCode(gopath)
+	if err := os.MkdirAll(gojob, 0755); err != nil {
+		return err
+	}
+
+	gomod := filepath.Join(gojob, "go.mod")
+
+	if _, err := os.Stat(gomod); err != nil {
+		setup := exec.Command("go", "mod", "init")
+		setup.Dir = gojob
+		setup.Env = []string{
+			"GOPATH=" + gopath,
+		}
+
+		_, err := setup.Output()
+		if err != nil {
+			return err
+		}
+	}
+
+	return nil
+}
+
+func goDeps(gopath string) error {
+	gojob := goSourceCode(gopath)
+
+	deps := exec.Command("go", "mod", "tidy")
+	deps.Dir = gojob
+	deps.Env = []string{
+		"GOPATH=" + gopath,
+	}
+
+	_, err := deps.Output()
+	if err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func gofile(gopath, code string) (string, error) {
+	gojob := goSourceCode(gopath)
+	dir, err := os.MkdirTemp(gojob, "job*")
+	if err != nil {
+		return "", err
+	}
+
+	fd, err := os.Create(filepath.Join(dir, "main.go"))
+	if err != nil {
+		return "", err
+	}
+	defer fd.Close()
+
+	_, err = fd.WriteString(code)
+	if err != nil {
+		return "", err
+	}
+
+	return filepath.Join(filepath.Base(dir), "main.go"), nil
+}
+
+func golang(gopath string) func(chatter.Reply) (float64, thinker.CmdOut, error) {
+	return func(command chatter.Reply) (float64, thinker.CmdOut, error) {
+		if err := goSetup(gopath); err != nil {
+			return 0.0, thinker.CmdOut{}, err
+		}
+
+		code, err := CodeBlock(GOLANG, command.Text)
+		if err != nil {
+			return 0.00, thinker.CmdOut{Cmd: GOLANG}, err
+		}
+
+		file, err := gofile(gopath, code)
+		if err != nil {
+			return 0.00, thinker.CmdOut{Cmd: GOLANG}, err
+		}
+
+		if err := goDeps(gopath); err != nil {
+			return 0.0, thinker.CmdOut{}, err
+		}
+
+		cmd := exec.Command("go", "run", file)
+		var stdout bytes.Buffer
+		var stderr bytes.Buffer
+		cmd.Dir = goSourceCode(gopath)
+		cmd.Env = []string{
+			"GOPATH=" + gopath,
+			"GOCACHE=" + filepath.Join(gopath, "cache"),
+		}
+		cmd.Stdout = &stdout
+		cmd.Stderr = &stderr
+
+		if err := cmd.Run(); err != nil {
+			err = thinker.Feedback(
+				fmt.Sprintf("The TOOL:%s has failed, improve the response based on feedback:", GOLANG),
+
+				"Execution of golang program is failed with the error: "+err.Error(),
+				"The error output is "+stderr.String(),
+			)
+			return 0.05, thinker.CmdOut{Cmd: GOLANG}, err
+		}
+
+		return 1.0, thinker.CmdOut{Cmd: GOLANG, Output: stdout.String()}, nil
+	}
+}

command/golang_test.go

@@ -0,0 +1,37 @@
+//
+// Copyright (C) 2025 Dmitry Kolesnikov
+//
+// This file may be modified and distributed under the terms
+// of the MIT license.  See the LICENSE file for details.
+// https://github.com/kshard/thinker
+//
+
+package command
+
+import (
+	"testing"
+
+	"github.com/fogfish/it/v2"
+	"github.com/kshard/chatter"
+)
+
+func TestGolang(t *testing.T) {
+	cmd := Golang("/tmp")
+	conf, out, err := cmd.Run(chatter.Reply{Text: `<codeblock>
+package main
+
+import "fmt"
+
+func main() {
+	fmt.Println("response")
+}
+</codeblock>
+`})
+
+	it.Then(t).Should(
+		it.Nil(err),
+		it.Equal(conf, 1.0),
+		it.Equal(out.Cmd, cmd.Cmd),
+		it.String(out.Output).Contain("response"),
+	)
+}