@kindgi/cli 0.1.4-rc.5 → 0.1.5-rc.0

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

@@ -34,16 +34,16 @@ assistant in the loop.
 ## Run
 
 ```sh
-pnpm install
-pnpm typecheck              # verify the pack compiles
-kindgi dev                  # runs the Kindgi runtime (Docker) + hot-reloads this pack
+{{INSTALL}}
+{{TYPECHECK}}  # verify the pack compiles
+{{KINDGI}} dev  # runs the Kindgi runtime (Docker) + hot-reloads this pack
 ```
 
 The api-server ships with a built-in `demo.echo-agent` you can hit to
 verify boot before authoring anything:
 
 ```sh
-kindgi runs start --agent=demo.echo-agent --input='{"userMessage":"hi"}'
+{{KINDGI}} runs start --agent=demo.echo-agent --input='{"userMessage":"hi"}'
 ```
 
 ## Use a real model
@@ -55,21 +55,15 @@ use a real model, set one LLM provider's key and register its preset, with
 `kindgi dev` running, from another terminal. For Claude:
 
 ```sh
-kindgi secrets set ANTHROPIC_API_KEY --env=local --scope=tenant   # no-echo prompt; writes .env.local
-kindgi providers register --preset=anthropic                      # Opus 5.5, Sonnet 5.5, Haiku 4.5
+{{KINDGI}} secrets set ANTHROPIC_API_KEY --env=local --scope=tenant   # no-echo prompt; writes .env.local
+{{KINDGI}} providers register --preset=anthropic                      # Opus 5.5, Sonnet 5.5 (default), Haiku 5.5, Haiku 4.5
 ```
 
 Claude takes over from dev-echo on the next turn; nothing to restart.
-`--models=claude-haiku-4-5` registers one model only. OpenAI
+`--models=claude-sonnet-5-5` registers one model only. OpenAI
 (`OPENAI_API_KEY`, `--preset=openai`), Gemini (`GEMINI_API_KEY`,
 `--preset=gemini-api`), Groq (`GROQ_API_KEY`, `--preset=groq`) and
-OpenRouter, many vendors' models with one key (`OPENROUTER_API_KEY`,
+OpenRouter, a hosted service your prompts pass through (`OPENROUTER_API_KEY`,
 `--preset=openrouter`), work the same way; `kindgi providers presets` lists
 the presets (Gemini on Vertex AI too). Picking a model per
 agent, and other providers: `.claude/skills/kindgi-authoring-providers/SKILL.md`.
-
-## Note on `@kindgi/sdk` versioning
-
-This template pins `@kindgi/sdk: "workspace:*"` because the SDK is not
-yet published to npm. Until it is, add the pack to a pnpm workspace that
-contains the Kindgi packages (`pnpm-workspace.yaml`).

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

@@ -23,14 +23,14 @@ that uses both tools and the guardrail, and one flow that runs the echo tool.
 ```sh
 uv sync          # .venv with kindgi and the dev tools
 uv run pytest
-kindgi dev       # boots Kindgi locally and runs this pack's code, reloading on save
+{{KINDGI}} dev  # boots Kindgi locally and runs this pack's code, reloading on save
 ```
 
 `kindgi dev` uses the pack's `.venv/bin/python` (or `dev.python` in
 `[tool.kindgi]`). Then, from another terminal:
 
 ```sh
-kindgi runs start --agent={{PACK_ID}}.echo-agent --input='{"userMessage":"hi"}'
+{{KINDGI}} runs start --agent={{PACK_ID}}.echo-agent --input='{"userMessage":"hi"}'
 ```
 
 ## Use a real model
@@ -42,15 +42,15 @@ use a real model, set one LLM provider's key and register its preset, with
 `kindgi dev` running, from another terminal. For Claude:
 
 ```sh
-kindgi secrets set ANTHROPIC_API_KEY --env=local --scope=tenant   # no-echo prompt; writes .env.local
-kindgi providers register --preset=anthropic                      # Opus 5.5, Sonnet 5.5, Haiku 4.5
+{{KINDGI}} secrets set ANTHROPIC_API_KEY --env=local --scope=tenant   # no-echo prompt; writes .env.local
+{{KINDGI}} providers register --preset=anthropic                      # Opus 5.5, Sonnet 5.5 (default), Haiku 5.5, Haiku 4.5
 ```
 
 Claude takes over from dev-echo on the next turn; nothing to restart.
-`--models=claude-haiku-4-5` registers one model only. OpenAI
+`--models=claude-sonnet-5-5` registers one model only. OpenAI
 (`OPENAI_API_KEY`, `--preset=openai`), Gemini (`GEMINI_API_KEY`,
 `--preset=gemini-api`), Groq (`GROQ_API_KEY`, `--preset=groq`) and
-OpenRouter, many vendors' models with one key (`OPENROUTER_API_KEY`,
+OpenRouter, a hosted service your prompts pass through (`OPENROUTER_API_KEY`,
 `--preset=openrouter`), work the same way; `kindgi providers presets` lists
 the presets (Gemini on Vertex AI too). Picking a model per
 agent, and other providers: `.claude/skills/kindgi-authoring-providers/SKILL.md`.

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

@@ -28,9 +28,9 @@ run with `kindgi dev`.
 ## Run
 
 ```sh
-pnpm install
-pnpm typecheck                                # verify the pack compiles
-kindgi dev                                 # runs the Kindgi runtime (Docker) + hot-reloads this pack
+{{INSTALL}}
+{{TYPECHECK}}  # verify the pack compiles
+{{KINDGI}} dev  # runs the Kindgi runtime (Docker) + hot-reloads this pack
 ```
 
 `kindgi dev` bundles every primitive under the four folders above,
@@ -47,15 +47,15 @@ use a real model, set one LLM provider's key and register its preset, with
 `kindgi dev` running, from another terminal. For Claude:
 
 ```sh
-kindgi secrets set ANTHROPIC_API_KEY --env=local --scope=tenant   # no-echo prompt; writes .env.local
-kindgi providers register --preset=anthropic                      # Opus 5.5, Sonnet 5.5, Haiku 4.5
+{{KINDGI}} secrets set ANTHROPIC_API_KEY --env=local --scope=tenant   # no-echo prompt; writes .env.local
+{{KINDGI}} providers register --preset=anthropic                      # Opus 5.5, Sonnet 5.5 (default), Haiku 5.5, Haiku 4.5
 ```
 
 Claude takes over from dev-echo on the next turn; nothing to restart.
-`--models=claude-haiku-4-5` registers one model only. OpenAI
+`--models=claude-sonnet-5-5` registers one model only. OpenAI
 (`OPENAI_API_KEY`, `--preset=openai`), Gemini (`GEMINI_API_KEY`,
 `--preset=gemini-api`), Groq (`GROQ_API_KEY`, `--preset=groq`) and
-OpenRouter, many vendors' models with one key (`OPENROUTER_API_KEY`,
+OpenRouter, a hosted service your prompts pass through (`OPENROUTER_API_KEY`,
 `--preset=openrouter`), work the same way; `kindgi providers presets` lists
 the presets (Gemini on Vertex AI too). Picking a model per
 agent, and other providers: `.claude/skills/kindgi-authoring-providers/SKILL.md`.
@@ -83,9 +83,3 @@ import { z } from 'zod';
 
 Every `define*` export ships with JSDoc — hover it in your editor for
 field-level docs.
-
-## Note on `@kindgi/sdk` versioning
-
-This template pins `@kindgi/sdk: "workspace:*"` because the SDK is not
-yet published to npm. Until it is, add the pack to a pnpm workspace that
-contains the Kindgi packages (`pnpm-workspace.yaml`).

package/dist/templates/scala/AGENTS.md

@@ -0,0 +1,32 @@
+# AGENTS.md
+
+This directory is a Kindgi pack written in Scala (`com.kindgi %% kindgi-pack-scala`,
+package `com.kindgi.pack.scaladsl`). Tools (`Tool[Input, Output](id)`) and
+guardrail checks (`Guardrail[Config](id)`) are `val`s of an object named like
+its file, under `src/main/scala/**/tools/` and `…/guardrails/`; agents
+(`Agent(id)`) and flows (`Flow(id)`) are data, under `…/agents/` and
+`…/flows/`. A tool's input and output schemas come from its case classes:
+`Option` is optional, a parameter's default is the schema's default, Jakarta
+Validation constraints become their keywords (in Scala 3, name their arguments:
+`@Min(value = 0)`). A tool defined as a `def` or a `lazy val` isn't indexed:
+make it a `val`. The config is `kindgi.config.json`.
+
+- `./kindgiw dev` boots Kindgi locally, compiles this pack through sbt's server
+  and runs it with its JDK (17 or later), recompiling on every save.
+- `sbt test` runs the tests; `tool.call(input, ToolContext.forTest())` calls a
+  handler directly.
+- `java -cp "$(sbt -batch -error 'export Runtime/fullClasspath')" com.kindgi.pack.Main index --pack-dir .`
+  shows what Kindgi sees.
+- Agents answer through a model provider. `kindgi dev` gives a new pack
+  `dev-echo`, a fallback that isn't a model: it calls the first tool and
+  replies "Tool responded: …" after a warning line, while no other provider
+  fits. For a real model, put one LLM provider's key in `.env`
+  (`ANTHROPIC_API_KEY`, `OPENAI_API_KEY`, `GEMINI_API_KEY`, `GROQ_API_KEY` or
+  `OPENROUTER_API_KEY`) and add a `providers` list with its preset
+  (`[{"preset": "anthropic"}]`, or `"openai"`, `"gemini-api"`, `"groq"`,
+  `"openrouter"`) to `kindgi.config.json`: `kindgi dev` then registers it on
+  every boot, in every worktree.
+
+When you diagnose a framework bug (something in Kindgi itself, not in this
+pack's code), append an entry to `FEEDBACK.md` at the pack root with
+`./kindgiw feedback write`.

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-rc.5",
+  "version": "0.1.5-rc.0",
   "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-rc.5",
-    "@kindgi/client": "0.1.4-rc.5",
-    "@kindgi/dotenv-file": "0.1.4-rc.5",
-    "@kindgi/crypto": "0.1.4-rc.5",
-    "@kindgi/env-schema": "0.1.4-rc.5",
-    "@kindgi/flow": "0.1.4-rc.5",
-    "@kindgi/handler-runtime": "0.1.4-rc.5",
-    "@kindgi/secrets-dotenv": "0.1.4-rc.5",
-    "@kindgi/platform": "0.1.4-rc.5",
-    "@kindgi/sdk": "0.1.4-rc.5",
-    "@kindgi/types": "0.1.4-rc.5",
+    "@kindgi/agents": "0.1.5-rc.0",
+    "@kindgi/client": "0.1.5-rc.0",
+    "@kindgi/dotenv-file": "0.1.5-rc.0",
+    "@kindgi/crypto": "0.1.5-rc.0",
+    "@kindgi/env-schema": "0.1.5-rc.0",
+    "@kindgi/flow": "0.1.5-rc.0",
+    "@kindgi/handler-runtime": "0.1.5-rc.0",
+    "@kindgi/log": "0.1.5-rc.0",
+    "@kindgi/secrets-dotenv": "0.1.5-rc.0",
+    "@kindgi/platform": "0.1.5-rc.0",
+    "@kindgi/sdk": "0.1.5-rc.0",
+    "@kindgi/types": "0.1.5-rc.0",
     "esbuild": "^0.24.0",
     "semver": "^7.8.5",
     "smol-toml": "^1.9.0",