@kindgi/cli 0.0.0-bootstrap.0 → 0.1.1

package/dist/templates/minimal/gitignore

@@ -0,0 +1,8 @@
+node_modules/
+dist/
+.kindgi/
+.kindgirc.json
+*.tsbuildinfo
+.env
+.env.local
+.DS_Store

package/dist/templates/minimal/kindgi.config.ts.tmpl

@@ -0,0 +1,44 @@
+// Kindgi pack config — scaffolded by `kindgi init --template=minimal`.
+
+const config = {
+  pack: {
+    id: '{{PACK_ID}}',
+    version: '{{PACK_VERSION}}',
+    description: 'A minimal Kindgi pack.',
+  },
+  discovery: {
+    tools: 'tools/**/*.ts',
+    guardrails: 'guardrails/**/*.ts',
+    agents: 'agents/**/*.ts',
+    flows: 'flows/**/*.ts',
+  },
+  // ---------------------------------------------------------------
+  // Environments — one entry per deploy target (staging / production
+  // / preview / custom). Each names the build server endpoint, the
+  // signing key path (Ed25519 PEM, never leaves the developer's
+  // machine), the target registry (build server pushes here on your
+  // behalf), and the tenantId the Kindgi runtime scopes the
+  // deployment to. Consumed by `kindgi build` + `kindgi deploy`.
+  //
+  // Fill these in when you're ready to push a build off the laptop.
+  // Local `kindgi dev` does NOT read this block.
+  // ---------------------------------------------------------------
+  environments: {
+    staging: {
+      endpoint: 'https://api.staging.example.com',
+      build: 'http://localhost:8787', // your Kindgi build server
+      registry: 'ghcr.io/your-org',
+      signingKey: '~/.kindgi/keys/staging.pem',
+      tenantId: 'tenant-your-org-staging',
+    },
+    production: {
+      endpoint: 'https://api.example.com',
+      build: 'https://build.example.com',
+      registry: 'ghcr.io/your-org',
+      signingKey: '~/.kindgi/keys/production.pem',
+      tenantId: 'tenant-your-org-production',
+    },
+  },
+} as const;
+
+export default config;

package/dist/templates/minimal/package.json.tmpl

@@ -0,0 +1,25 @@
+{
+  "name": "{{PACK_NAME}}",
+  "version": "{{PACK_VERSION}}",
+  "private": true,
+  "description": "Kindgi pack — scaffolded by `kindgi init --template=minimal`.",
+  "license": "UNLICENSED",
+  "type": "module",
+  "engines": {
+    "node": ">=22.0.0"
+  },
+  "scripts": {
+    "typecheck": "tsc --noEmit",
+    "test": "vitest run"
+  },
+  "dependencies": {
+    "@kindgi/sdk": "workspace:*",
+    "zod": "^4.0.0"
+  },
+  "devDependencies": {
+    "@kindgi/cli": "workspace:*",
+    "@types/node": "^22.0.0",
+    "typescript": "^5.7.3",
+    "vitest": "^3.0.0"
+  }
+}

package/dist/templates/minimal/pnpm-workspace.yaml

@@ -0,0 +1,8 @@
+# pnpm 12+ reads settings from this file, not from `package.json`'s
+# `pnpm` block. `allowBuilds` records, per dependency, whether pnpm runs
+# its install script (true) or skips it (false); pnpm 11+ stops an install
+# until each one has a decision. esbuild (the CLI's bundler, and vitest's
+# transform) works without its script: its native binary comes from its
+# `@esbuild/<platform>` package, so the script stays off.
+allowBuilds:
+  esbuild: false

package/dist/templates/minimal/tsconfig.json.tmpl

@@ -0,0 +1,27 @@
+{
+  "compilerOptions": {
+    "target": "ES2023",
+    "module": "NodeNext",
+    "moduleResolution": "NodeNext",
+    "lib": ["ES2023", "DOM"],
+    "types": ["node"],
+    "strict": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "verbatimModuleSyntax": true,
+    "isolatedModules": true,
+    "declaration": true,
+    "sourceMap": true,
+    "noEmit": true,
+    "resolveJsonModule": true,
+    "forceConsistentCasingInFileNames": true
+  },
+  "include": [
+    "tools/**/*.ts",
+    "guardrails/**/*.ts",
+    "agents/**/*.ts",
+    "flows/**/*.ts",
+    "kindgi.config.ts"
+  ],
+  "exclude": ["node_modules", "dist", ".kindgi"]
+}

package/dist/templates/minimal/vitest.config.ts.tmpl

@@ -0,0 +1,14 @@
+// Vitest configuration for {{PACK_NAME}}. Scaffolded by `kindgi init`.
+// `kindgi test` shells out to the pack's local vitest install using
+// this config — the CLI does NOT force a vitest version through.
+
+import { defineConfig } from 'vitest/config';
+
+export default defineConfig({
+  test: {
+    include: ['**/*.test.ts'],
+    exclude: ['node_modules/**', '.kindgi/**', 'dist/**'],
+    reporters: ['default'],
+    passWithNoTests: true,
+  },
+});

package/dist/templates/python/AGENTS.md

@@ -0,0 +1,30 @@
+# AGENTS.md
+
+This directory is a Kindgi pack written in Python (the `kindgi` package).
+Tools are `@tool` functions, guardrail checks `@guardrail` functions; agents
+(`Agent`) and flows (`Flow`) are data. Each lives at module level in a file
+under `tools/`, `guardrails/`, `agents/` or `flows/`; a helper module there
+starts with `_`. The config is `[tool.kindgi]` in `pyproject.toml`.
+
+- `kindgi dev` boots Kindgi locally and runs this pack's code with its own
+  `.venv`, reloading on every save.
+- `uv run pytest` runs the tests; a `Tool` or `Guardrail` is still callable.
+- `uv run python -m kindgi.pack index --pack-dir .` shows what Kindgi sees.
+- Agents answer through a model provider. `kindgi dev` gives a new pack
+  `dev-echo`, a fallback that calls the first tool and replies
+  "Tool responded: …" while no other provider fits. For Claude:
+  `kindgi providers register --preset=anthropic` (the key in `.env`
+  first); other providers and per-agent model choice:
+  `.claude/skills/kindgi-authoring-providers/SKILL.md`.
+
+## Skills
+
+`.claude/skills/` holds Kindgi's skills for Python packs: getting started,
+tools, guardrails and agents in Python (`kindgi-python-*`), model providers,
+MCP servers, framework feedback. Claude Code loads them on its own; other
+coding agents can read them. `kindgi skills sync` refreshes them.
+
+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 via
+`kindgi feedback write` — see
+`.claude/skills/kindgi-framework-feedback/SKILL.md`.

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

@@ -0,0 +1,56 @@
+# {{PACK_NAME}}
+
+A sample Kindgi pack in Python — scaffolded by `kindgi init --template=python`.
+
+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.
+
+## Layout
+
+```
+{{PACK_NAME}}/
+├── pyproject.toml                     # [tool.kindgi] — the pack's id and version
+├── tools/echo.py                      # @tool — pydantic in, pydantic out
+├── tools/greet.py                     # @tool
+├── guardrails/response_not_empty.py   # @guardrail — a zero-LLM check over the run
+├── agents/echo_agent.py               # Agent(...) — data
+├── flows/echo_flow.py                 # Flow(...) — data
+└── tests/test_tools.py                # the tools and the check, called directly
+```
+
+## Run
+
+```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` 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"}'
+```
+
+## Use a real model
+
+`kindgi dev` gives a new pack `dev-echo`, a fallback provider that calls the
+first tool and replies "Tool responded: …" — it answers only while no other
+provider fits. To use Claude, with `kindgi dev` running, from another terminal:
+
+```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
+```
+
+Claude takes over from dev-echo on the next turn; nothing to restart.
+`--models=claude-haiku-4-5` registers one model only; `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`.
+
+## Build
+
+`kindgi build --env=<name>` makes the pack's image: dependencies from `uv.lock`
+(run `uv lock` first), the index built in the image, the pack service as its
+entrypoint.

package/dist/templates/python/agents/echo_agent.py.tmpl

@@ -0,0 +1,23 @@
+"""{{PACK_ID}}.echo-agent — uses both tools; the response-not-empty guardrail guards its answer."""
+
+from kindgi import Agent
+
+from ..guardrails.response_not_empty import response_not_empty
+from ..tools.echo import echo
+from ..tools.greet import greet
+
+echo_agent = Agent(
+    id="{{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, invoke `{{PACK_ID}}.greet` with it. "
+        "Otherwise invoke `{{PACK_ID}}.echo` with the message text. Quote the tool result verbatim."
+    ),
+    capabilities=[{"needs": [{"feature": "tool-use"}]}],
+    tools=[echo, greet],
+    guardrails=[response_not_empty],
+    conversation_policy={"historyLimit": 10},
+    budget={"maxSteps": 4, "maxCostUsd": 0.1, "maxWallMs": 60_000},
+)

package/dist/templates/python/flows/echo_flow.py.tmpl

@@ -0,0 +1,17 @@
+"""{{PACK_ID}}.echo-flow — runs the pack's echo tool, then ends."""
+
+from kindgi import Flow
+
+from ..tools.echo import echo
+
+echo_flow = Flow(
+    id="{{PACK_ID}}.echo-flow",
+    version="{{PACK_VERSION}}",
+    name="Echo Flow",
+    description="Runs the pack's echo tool and terminates.",
+    nodes=[{"id": "echo", "kind": "tool", "ref": echo}],
+    edges=[
+        {"id": "e-start", "from": "$start", "to": "echo"},
+        {"id": "e-end", "from": "echo", "to": "$end"},
+    ],
+)

package/dist/templates/python/gitignore

@@ -0,0 +1,9 @@
+.venv/
+__pycache__/
+*.py[cod]
+.pytest_cache/
+.kindgi/
+.kindgirc.json
+.env
+.env.*
+!.env.example

package/dist/templates/python/guardrails/response_not_empty.py.tmpl

@@ -0,0 +1,27 @@
+"""{{PACK_ID}}.response-not-empty — a zero-LLM guardrail: the run's answer has content."""
+
+from pydantic import BaseModel, Field
+
+from kindgi import CheckResult, RunTrace, guardrail
+
+
+class Config(BaseModel):
+    min_length: int = Field(1, alias="minLength", ge=0)
+
+
+@guardrail(
+    id="{{PACK_ID}}.response-not-empty",
+    name="Response is non-empty",
+    check_id="{{PACK_ID}}.checks.response-not-empty",
+    on_violation="halt",
+    severity="error",
+    scope={"when": "runtime-only"},
+)
+def response_not_empty(config: Config, trace: RunTrace) -> CheckResult:
+    text = (trace.output or "").strip()
+    if len(text) < config.min_length:
+        return CheckResult(
+            passed=False,
+            reason=f"Response too short: {len(text)} chars, expected >= {config.min_length}.",
+        )
+    return CheckResult(passed=True)

package/dist/templates/python/pyproject.toml.tmpl

@@ -0,0 +1,42 @@
+[project]
+name = "{{PACK_NAME}}"
+version = "{{PACK_VERSION}}"
+description = "A Kindgi pack — scaffolded by `kindgi init --template=python`."
+requires-python = ">=3.11"
+dependencies = [{{KINDGI_REQUIREMENT}}]
+
+[dependency-groups]
+dev = ["pytest>=8"]
+
+# The uv versions this pack works with: `kindgi build` installs it with the
+# uv in Kindgi's image, which reads the uv.lock they write.
+[tool.uv]
+required-version = "{{UV_REQUIRED_VERSION}}"
+{{KINDGI_PYTHON_SOURCE}}
+# The pack: what `kindgi dev`, `kindgi build` and `python -m kindgi.pack` read.
+[tool.kindgi.pack]
+id = "{{PACK_ID}}"
+version = "{{PACK_VERSION}}"
+description = "A sample Kindgi pack in Python — two tools, one guardrail, one agent, one flow."
+
+# Optional — the defaults are shown.
+# [tool.kindgi.discovery]
+# tools = "tools/**/*.py"
+# guardrails = "guardrails/**/*.py"
+# agents = "agents/**/*.py"
+# flows = "flows/**/*.py"
+
+# [tool.kindgi.dev]
+# python = ["uv", "run", "python"]   # default: .venv/bin/python, else python3
+# envFiles = [".env", ".env.local"]
+
+# One block per deploy target; `kindgi build --env=<name>` reads it.
+# [tool.kindgi.environments.staging]
+# endpoint = "https://api.staging.example.com"
+# build = "http://localhost:4001"
+# tenantId = "tenant-your-org-staging"
+# signingKey = "~/.kindgi/keys/staging.pem"
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]
+pythonpath = ["."]

package/dist/templates/python/tests/test_tools.py.tmpl

@@ -0,0 +1,22 @@
+"""The pack's tools and guardrail, called directly — `uv run pytest`."""
+
+from kindgi import RunTrace
+from tools.echo import EchoInput, echo
+from tools.greet import GreetInput, greet
+
+from guardrails.response_not_empty import Config, response_not_empty
+
+
+def test_echo_round_trips_the_message() -> None:
+    out = echo(EchoInput(message="hello"))
+    assert out.echo == "hello"
+    assert out.character_count == 5
+
+
+def test_greet_uses_the_default_greeting() -> None:
+    assert greet(GreetInput(name="Ada")).message == "Hello, Ada!"
+
+
+def test_an_empty_answer_fails_the_guardrail() -> None:
+    trace = RunTrace(run_id="r", tenant_id="t", output="  ")
+    assert not response_not_empty(Config(), trace).passed

package/dist/templates/python/tools/echo.py.tmpl

@@ -0,0 +1,27 @@
+"""{{PACK_ID}}.echo — echoes the message back with a UTC timestamp and its length."""
+
+from datetime import UTC, datetime
+
+from pydantic import BaseModel, Field
+
+from kindgi import tool
+
+
+class EchoInput(BaseModel):
+    message: str = Field(min_length=1, max_length=500)
+
+
+class Echo(BaseModel):
+    echo: str
+    echoed_at: str = Field(alias="echoedAt")
+    character_count: int = Field(alias="characterCount", ge=0)
+
+
+@tool(id="{{PACK_ID}}.echo")
+def echo(input: EchoInput) -> Echo:
+    """Echoes the caller-provided message with a UTC timestamp and character count."""
+    return Echo(
+        echo=input.message,
+        echoedAt=datetime.now(UTC).isoformat(),
+        characterCount=len(input.message),
+    )

package/dist/templates/python/tools/greet.py.tmpl

@@ -0,0 +1,20 @@
+"""{{PACK_ID}}.greet — greets a named recipient."""
+
+from pydantic import BaseModel, Field
+
+from kindgi import tool
+
+
+class GreetInput(BaseModel):
+    name: str = Field(min_length=1, max_length=100)
+    greeting: str = Field("Hello", min_length=1, max_length=50)
+
+
+class Greeting(BaseModel):
+    message: str
+
+
+@tool(id="{{PACK_ID}}.greet")
+def greet(input: GreetInput) -> Greeting:
+    """Formats a greeting for the named recipient."""
+    return Greeting(message=f"{input.greeting}, {input.name}!")

package/dist/templates/sample/.nvmrc

@@ -0,0 +1 @@
+22

package/dist/templates/sample/AGENTS.md

@@ -0,0 +1,23 @@
+# AGENTS.md
+
+This directory is a Kindgi pack. Author primitives via
+`@kindgi/sdk` — `defineTool`, `defineAgent`, `defineCheck`,
+`defineFlow`. Every export ships with JSDoc; hover them for
+field-level docs. Iterate with `kindgi dev`; `kindgi --help` lists
+the full CLI.
+
+Agents answer through a model provider. `kindgi dev` gives a new pack
+`dev-echo`, a fallback that calls the first tool and replies
+"Tool responded: …" while no other provider fits. For Claude:
+`kindgi providers register --preset=anthropic` (the key in `.env`
+first); other providers and per-agent model choice:
+`.claude/skills/kindgi-authoring-providers/SKILL.md`.
+
+## For Claude Code sessions
+
+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
+via `kindgi feedback write` — see
+`.claude/skills/kindgi-framework-feedback/SKILL.md`. Mark items fixed
+by adding a `> **Fixed:** <note>` line right after their header; the
+file is a plain markdown list you edit directly.

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

@@ -0,0 +1,85 @@
+# {{PACK_NAME}}
+
+A sample Kindgi pack — scaffolded by `kindgi init --template=sample`.
+
+Two tools (`echo`, `greet`), one guardrail (`response-not-empty`), one
+agent that uses both tools + the guardrail, and one flow that stitches
+the two tools into a workflow. It is compile-time-valid and ready to
+run with `kindgi dev`.
+
+## Layout
+
+```
+{{PACK_NAME}}/
+├── kindgi.config.ts                       # pack id + version + discovery patterns
+├── package.json                              # depends on @kindgi/sdk + zod
+├── tsconfig.json
+├── tools/
+│   ├── echo/index.ts                         # defineTool — Zod-authored echo
+│   └── greet/index.ts                        # defineTool — Zod-authored greeting
+├── guardrails/
+│   └── response-not-empty/index.ts           # defineCheck — response has content
+├── agents/
+│   └── echo-agent/index.ts                   # defineAgent — uses both tools + guardrail
+└── flows/
+    └── echo-flow/index.ts                    # Flow — greet tool → echo agent step → declared output
+```
+
+## Run
+
+```sh
+pnpm install
+pnpm 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,
+runs their code in a local pack service, starts the Kindgi runtime as a
+Docker container (with a local Postgres), registers this pack, and
+re-registers on every file save.
+
+## Use a real model
+
+`kindgi dev` gives a new pack `dev-echo`, a fallback provider that calls the
+first tool and replies "Tool responded: …" — it answers only while no other
+provider fits. To use Claude, with `kindgi dev` running, from another terminal:
+
+```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
+```
+
+Claude takes over from dev-echo on the next turn; nothing to restart.
+`--models=claude-haiku-4-5` registers one model only; `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`.
+
+## The four primitives (one file each)
+
+| Kind | File | What it shows |
+|---|---|---|
+| Tool | `tools/echo/index.ts` | `defineTool` with Zod input/output; no `needs`; `effects: []`. |
+| Tool | `tools/greet/index.ts` | Second Zod-authored tool — takes a name, returns a greeting. |
+| Tool | `tools/fetch-httpbin/index.ts` | `defineTool({spec: {kind: 'http'}})` — declarative HTTP call, no imperative handler code. Hits httpbin.org so it works without credentials. |
+| Guardrail | `guardrails/response-not-empty/index.ts` | `defineCheck` — zero-LLM check that a response payload is non-empty. |
+| Agent | `agents/echo-agent/index.ts` | `defineAgent` — pulls in the local tools + the guardrail; uses `capabilities` for model routing. |
+| Flow | `flows/echo-flow/index.ts` | `defineFlow` — a tool step fed from the run input, an agent step, a declared `output`. Run: `kindgi runs start --flow={{PACK_ID}}.echo-flow --input='{"name":"Ada"}'`. |
+
+## Extend
+
+Add more primitives following the same folder convention. `defineTool` +
+`defineCheck` + `defineAgent` all come from `@kindgi/sdk/define`:
+
+```ts
+import { defineTool, defineCheck, defineAgent, defineFlow } from '@kindgi/sdk/define';
+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/sample/agents/echo-agent/index.ts.tmpl

@@ -0,0 +1,34 @@
+// {{PACK_ID}}.echo-agent — pulls in both tools + the response-not-empty
+// guardrail. The agent shape is pure metadata; every field is either a
+// primitive or a reference to a registered substrate object.
+
+import { defineAgent } from '@kindgi/sdk/define';
+import type { AgentId, GuardrailId, Semver } from '@kindgi/sdk/types';
+
+const defined = defineAgent({
+  id: '{{PACK_ID}}.echo-agent' as AgentId,
+  version: '{{PACK_VERSION}}' as Semver,
+  name: 'Echo Agent',
+  description:
+    'Uses the pack\'s echo + greet tools; the response-not-empty guardrail guards the output.',
+  instructions:
+    'For each user message: if the user sends a name, invoke `{{PACK_ID}}.greet` with it. Otherwise invoke `{{PACK_ID}}.echo` with the message text. Quote the tool result verbatim in your reply.',
+  capabilities: [{ needs: [{ feature: 'tool-use' as const }] }],
+  tools: [
+    { id: '{{PACK_ID}}.echo', version: '{{PACK_VERSION}}' },
+    { id: '{{PACK_ID}}.greet', version: '{{PACK_VERSION}}' },
+  ],
+  retrieval: [],
+  guardrails: ['{{PACK_ID}}.response-not-empty' as GuardrailId],
+  parameters: [],
+  conversationPolicy: { historyLimit: 10 },
+  budget: { maxSteps: 4, maxCostUsd: 0.1, maxWallMs: 15_000 },
+});
+
+if (defined.kind === 'err') {
+  throw new Error(
+    `{{PACK_ID}}.echo-agent failed to compile: ${defined.error.message}`,
+  );
+}
+
+export default defined.value;

package/dist/templates/sample/flows/echo-flow/index.ts.tmpl

@@ -0,0 +1,59 @@
+// {{PACK_ID}}.echo-flow — greets a name with the greet tool, then hands
+// the greeting to the echo agent as an agent step, and returns both.
+//
+// It shows the parts most flows use:
+//   - a tool step whose input is mapped from the run input
+//     (`inputMapping` — `runInput.name`);
+//   - an agent step: the agent runs one turn as a child run, gets the
+//     step's input as structured input (`{{ input.text }}` in its
+//     instructions) and as its message, and its answer is
+//     `nodeOutputs.respond.text` (`.output.<field>` with a typed `output`);
+//   - a declared `output`, checked against its schema.
+// The kindgi-authoring-flows skill covers branches, loops and the rest.
+//
+// Run it:  kindgi runs start --flow={{PACK_ID}}.echo-flow --input='{"name":"Ada"}'
+
+import { defineFlow } from '@kindgi/sdk/define';
+
+const defined = defineFlow({
+  id: '{{PACK_ID}}.echo-flow',
+  version: '{{PACK_VERSION}}',
+  name: 'Echo Flow',
+  description: 'Greets a name, then has the echo agent respond to the greeting.',
+  nodes: [
+    {
+      id: 'greet',
+      kind: 'tool',
+      ref: '{{PACK_ID}}.greet',
+      inputMapping: { name: { path: 'runInput.name' } },
+    },
+    {
+      id: 'respond',
+      kind: 'agent',
+      ref: '{{PACK_ID}}.echo-agent',
+      inputMapping: { text: { path: 'nodeOutputs.greet.message' } },
+    },
+  ],
+  edges: [
+    { id: 'e-start', from: '$start', to: 'greet' },
+    { id: 'e-respond', from: 'greet', to: 'respond' },
+    { id: 'e-end', from: 'respond', to: '$end' },
+  ],
+  output: {
+    mapping: {
+      greeting: { path: 'nodeOutputs.greet.message' },
+      reply: { path: 'nodeOutputs.respond.text' },
+    },
+    schema: {
+      type: 'object',
+      properties: { greeting: { type: 'string' }, reply: { type: 'string' } },
+      required: ['greeting', 'reply'],
+    },
+  },
+});
+
+if (defined.kind === 'err') {
+  throw new Error(`{{PACK_ID}}.echo-flow failed to compile: ${defined.error.message}`);
+}
+
+export default defined.value;

package/dist/templates/sample/gitignore

@@ -0,0 +1,8 @@
+node_modules/
+dist/
+.kindgi/
+.kindgirc.json
+*.tsbuildinfo
+.env
+.env.local
+.DS_Store