@kindgi/cli 0.1.4 → 0.1.5

package/dist/templates/scala/README.md.tmpl

@@ -0,0 +1,75 @@
+# {{PACK_NAME}}
+
+A sample Kindgi pack in Scala — scaffolded by `kindgi init --template=scala`.
+
+Two tools (`echo`, `greet`), one guardrail (`response-not-empty`), one agent
+that uses both tools and the guardrail, and one flow that runs the echo tool.
+
+Java and Scala support is in preview: tested and supported, but the API may
+still change in 0.1.6 without the usual deprecation period.
+
+## Layout
+
+```
+{{PACK_NAME}}/
+├── kindgi.config.json                         # the pack's id and version ("language": "scala"), the CLI it pins
+├── build.sbt                                  # kindgi-pack-scala, Scala 3.3, Java 17
+├── src/main/scala/{{SCALA_PACKAGE_PATH}}/
+│   ├── tools/Echo.scala                       # Tool[Input, Output] — case classes in, case classes out
+│   ├── tools/Greet.scala                      # a parameter's default is the schema's default
+│   ├── guardrails/ResponseNotEmpty.scala      # Guardrail[Config] — a zero-LLM check over the run
+│   ├── agents/EchoAgent.scala                 # Agent — data
+│   └── flows/EchoFlow.scala                   # Flow — data
+└── src/test/scala/{{SCALA_PACKAGE_PATH}}/ToolsSuite.scala   # the tools, called directly
+```
+
+A file's tools, guardrails, agents and flows are the `val`s of an object named
+like the file (`Greet.scala` holds `object Greet`).
+
+## Run
+
+You need a JDK 17 or later (`JAVA_HOME`) and sbt.
+
+```sh
+sbt test
+./kindgiw dev    # the CLI the pack pins: boots Kindgi locally, compiles and runs this pack, recompiling on save
+```
+
+Then, from another terminal:
+
+```sh
+./kindgiw runs start --agent={{PACK_ID}}.echo-agent --input='{"userMessage":"hi"}'
+```
+
+`kindgi dev` compiles through sbt's server (`sbt --client`), so a save compiles
+in about a second once it's warm. It starts that server when none is running
+and stops it when it stops; a server you already run (your IDE's) is used and
+left running. It uses `JAVA_HOME`'s JDK (or `dev.javaHome` in
+`kindgi.config.json`) and the `sbt` on your `PATH` (or `dev.sbt`, e.g.
+`["sbt", "-mem", "2048"]`). `SBT_OPTS` in your shell reaches sbt only, never
+the pack.
+
+## Use a real model
+
+`kindgi dev` gives a new pack `dev-echo`, a fallback provider that isn't a
+model: it calls the first tool and replies "Tool responded: …", after a
+warning line that says so. It answers only while no other provider fits. To
+use a real model, set one LLM provider's key and register its preset, with
+`kindgi dev` running, from another terminal. For Claude:
+
+```sh
+./kindgiw secrets set ANTHROPIC_API_KEY --env=local --scope=tenant   # no-echo prompt; writes .env.local
+./kindgiw providers register --preset=anthropic                      # Opus 5.5, Sonnet 5.5, Haiku 4.5
+```
+
+Claude takes over from dev-echo on the next turn; nothing to restart.
+OpenAI (`OPENAI_API_KEY`, `--preset=openai`), Gemini (`GEMINI_API_KEY`,
+`--preset=gemini-api`), Groq (`GROQ_API_KEY`, `--preset=groq`) and
+OpenRouter (`OPENROUTER_API_KEY`, `--preset=openrouter`) work the same way;
+`kindgi providers presets` lists the presets.
+
+## Build
+
+`kindgi build --env=<name>` makes the pack's image: sbt compiles it in a
+pinned sbt + JDK 17 image, the index is built in the image, and the pack
+service runs on a JRE 17 as its entrypoint.

package/dist/templates/scala/build.sbt.tmpl

@@ -0,0 +1,16 @@
+// {{PACK_ID}}: a Kindgi pack in Scala (kindgi.config.json, "language": "scala").
+
+ThisBuild / scalaVersion := "3.3.8"
+
+lazy val root = (project in file("."))
+  .settings(
+    name := "{{PACK_NAME}}",
+    version := "{{PACK_VERSION}}",{{SCALA_LOCAL_RESOLVER}}
+    libraryDependencies ++= Seq(
+      "com.kindgi" %% "kindgi-pack-scala" % "{{KINDGI_SCALA_VERSION}}",
+      "jakarta.validation" % "jakarta.validation-api" % "3.0.2",
+      "org.scalameta" %% "munit" % "1.3.6" % Test
+    ),
+    javacOptions ++= Seq("--release", "17"),
+    scalacOptions ++= Seq("-release", "17", "-deprecation", "-feature")
+  )

package/dist/templates/scala/gitignore

@@ -0,0 +1,13 @@
+target/
+project/target/
+project/project/
+.bsp/
+.metals/
+.bloop/
+.kindgi/
+.kindgirc.json
+.env
+.env.*
+!.env.example
+.idea/
+.vscode/

package/dist/templates/scala/kindgi.config.json.tmpl

@@ -0,0 +1,8 @@
+{
+  "language": "scala",
+  "cli": "{{KINDGI_CLI_VERSION}}",
+  "pack": {
+    "id": "{{PACK_ID}}",
+    "version": "{{PACK_VERSION}}"
+  }
+}

package/dist/templates/scala/project/build.properties

@@ -0,0 +1 @@
+sbt.version=1.12.15

package/dist/templates/scala/src/main/scala/__PACKAGE__/agents/EchoAgent.scala.tmpl

@@ -0,0 +1,23 @@
+package {{SCALA_PACKAGE}}.agents
+
+import com.kindgi.pack.scaladsl._
+import {{SCALA_PACKAGE}}.guardrails.ResponseNotEmpty
+import {{SCALA_PACKAGE}}.tools.{Echo, Greet}
+
+/** {{PACK_ID}}.echo-agent — uses both tools; the response-not-empty guardrail guards its answer. */
+object EchoAgent {
+  val agent: Agent = Agent("{{PACK_ID}}.echo-agent")
+    .version("{{PACK_VERSION}}")
+    .name("Echo Agent")
+    .description("Uses the pack's echo and greet tools; the response-not-empty guardrail guards the output.")
+    .instructions(
+      "For each user message: if the user sends a name, greet them with the greet tool. " +
+        "Otherwise echo their message with the echo tool. Quote the tool result verbatim.")
+    .capability(Map("needs" -> List(Map("feature" -> "tool-use"))))
+    .tool(Echo.tool)
+    .tool(Greet.tool)
+    .guardrail(ResponseNotEmpty.guardrail)
+    .set("conversationPolicy", Map("historyLimit" -> 10))
+    .set("budget", Map("maxSteps" -> 4, "maxCostUsd" -> 0.1, "maxWallMs" -> 60000))
+    .build()
+}

package/dist/templates/scala/src/main/scala/__PACKAGE__/flows/EchoFlow.scala.tmpl

@@ -0,0 +1,16 @@
+package {{SCALA_PACKAGE}}.flows
+
+import com.kindgi.pack.scaladsl._
+import {{SCALA_PACKAGE}}.tools.Echo
+
+/** {{PACK_ID}}.echo-flow — runs the pack's echo tool, then ends. */
+object EchoFlow {
+  val flow: Flow = Flow("{{PACK_ID}}.echo-flow")
+    .version("{{PACK_VERSION}}")
+    .set("name", "Echo Flow")
+    .set("description", "Runs the pack's echo tool and terminates.")
+    .toolNode("echo", Echo.tool)
+    .edge("e-start", "$start", "echo")
+    .edge("e-end", "echo", "$end")
+    .build()
+}

package/dist/templates/scala/src/main/scala/__PACKAGE__/guardrails/ResponseNotEmpty.scala.tmpl

@@ -0,0 +1,21 @@
+package {{SCALA_PACKAGE}}.guardrails
+
+import com.kindgi.pack.scaladsl._
+import jakarta.validation.constraints.Min
+
+/** {{PACK_ID}}.response-not-empty — a zero-LLM guardrail: the run's answer has content. */
+object ResponseNotEmpty {
+  final case class Config(@Min(value = 0) minLength: Int = 1)
+
+  val guardrail: Guardrail[Config] = Guardrail[Config]("{{PACK_ID}}.response-not-empty")
+    .name("Response is non-empty")
+    .checkId("{{PACK_ID}}.checks.response-not-empty")
+    .onViolation("halt")
+    .severity("error")
+    .set("scope", Map("when" -> "runtime-only"))
+    .check { (config, trace) =>
+      val text = Option(trace.output).getOrElse("").strip
+      if (text.length >= config.minLength) CheckResult.pass
+      else CheckResult.fail(s"Response too short: ${text.length} chars, expected >= ${config.minLength}.")
+    }
+}

package/dist/templates/scala/src/main/scala/__PACKAGE__/tools/Echo.scala.tmpl

@@ -0,0 +1,16 @@
+package {{SCALA_PACKAGE}}.tools
+
+import com.kindgi.pack.scaladsl._
+import jakarta.validation.constraints.{PositiveOrZero, Size}
+import java.time.Instant
+
+/** {{PACK_ID}}.echo — echoes the message back with a UTC timestamp and its length. */
+object Echo {
+  final case class Input(@Size(min = 1, max = 500) message: String)
+  final case class Output(echo: String, echoedAt: Instant, @PositiveOrZero characterCount: Int)
+
+  val tool: Tool[Input, Output] = Tool[Input, Output]("{{PACK_ID}}.echo")
+    .description("Echoes the caller-provided message with a UTC timestamp and character count.")
+    .readOnly
+    .handler((in, _) => Output(in.message, Instant.now(), in.message.length))
+}

package/dist/templates/scala/src/main/scala/__PACKAGE__/tools/Greet.scala.tmpl

@@ -0,0 +1,17 @@
+package {{SCALA_PACKAGE}}.tools
+
+import com.kindgi.pack.scaladsl._
+import jakarta.validation.constraints.Size
+
+/** {{PACK_ID}}.greet — greets a named recipient. */
+object Greet {
+  final case class Input(
+      @Size(min = 1, max = 100) name: String,
+      @Size(min = 1, max = 50) greeting: String = "Hello")
+  final case class Output(message: String)
+
+  val tool: Tool[Input, Output] = Tool[Input, Output]("{{PACK_ID}}.greet")
+    .description("Formats a greeting for the named recipient.")
+    .readOnly
+    .handler((in, _) => Output(s"${in.greeting}, ${in.name}!"))
+}

package/dist/templates/scala/src/test/scala/__PACKAGE__/ToolsSuite.scala.tmpl

@@ -0,0 +1,23 @@
+package {{SCALA_PACKAGE}}
+
+import com.kindgi.pack.ToolContext
+import {{SCALA_PACKAGE}}.tools.{Echo, Greet}
+
+/** The pack's tools, called directly — `sbt test`. */
+class ToolsSuite extends munit.FunSuite {
+  test("echo round-trips the message") {
+    val out = Echo.tool.call(Echo.Input("hello"), ToolContext.forTest())
+    assertEquals(out.echo, "hello")
+    assertEquals(out.characterCount, 5)
+  }
+
+  test("greet uses the greeting it is given, else Hello") {
+    assertEquals(Greet.tool.call(Greet.Input("Ada", "Hi"), ToolContext.forTest()).message, "Hi, Ada!")
+    assertEquals(Greet.tool.call(Greet.Input("Ada"), ToolContext.forTest()).message, "Hello, Ada!")
+  }
+
+  test("the tools say they only read") {
+    assert(!Echo.tool.mutating())
+    assert(!Greet.tool.mutating())
+  }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kindgi/cli",
-  "version": "0.1.4",
+  "version": "0.1.5",
   "description": "Command-line interface for Kindgi™ — the sovereign AI OS. Create a pack, run it on your machine (`kindgi dev`), build, sign and deploy it, and work with a running Kindgi API from the terminal.",
   "license": "Apache-2.0",
   "repository": {
@@ -37,17 +37,18 @@
     "provenance": true
   },
   "dependencies": {
-    "@kindgi/agents": "0.1.4",
-    "@kindgi/client": "0.1.4",
-    "@kindgi/dotenv-file": "0.1.4",
-    "@kindgi/crypto": "0.1.4",
-    "@kindgi/env-schema": "0.1.4",
-    "@kindgi/flow": "0.1.4",
-    "@kindgi/handler-runtime": "0.1.4",
-    "@kindgi/secrets-dotenv": "0.1.4",
-    "@kindgi/platform": "0.1.4",
-    "@kindgi/sdk": "0.1.4",
-    "@kindgi/types": "0.1.4",
+    "@kindgi/agents": "0.1.5",
+    "@kindgi/client": "0.1.5",
+    "@kindgi/dotenv-file": "0.1.5",
+    "@kindgi/crypto": "0.1.5",
+    "@kindgi/env-schema": "0.1.5",
+    "@kindgi/flow": "0.1.5",
+    "@kindgi/handler-runtime": "0.1.5",
+    "@kindgi/log": "0.1.5",
+    "@kindgi/secrets-dotenv": "0.1.5",
+    "@kindgi/platform": "0.1.5",
+    "@kindgi/sdk": "0.1.5",
+    "@kindgi/types": "0.1.5",
     "esbuild": "^0.24.0",
     "semver": "^7.8.5",
     "smol-toml": "^1.9.0",