agentic-scaffold 0.0.0-stage → 0.1.2

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Pooria Arab
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -1,3 +1,74 @@
-# Temporary Holding Version
+# agentic-scaffold
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+[![npm version](https://img.shields.io/npm/v/agentic-scaffold)](https://www.npmjs.com/package/agentic-scaffold)
+[![Monthly downloads](https://img.shields.io/npm/dm/agentic-scaffold)](https://www.npmjs.com/package/agentic-scaffold)
+[![MIT license](https://img.shields.io/badge/license-MIT-blue)](https://opensource.org/license/mit)
+
+[Package](https://www.npmjs.com/package/agentic-scaffold) · [Source](https://github.com/pooriaarab/agentic-scaffold) · [Support](https://github.com/pooriaarab/agentic-scaffold/issues)
+
+agentic-scaffold is an open-source TypeScript starter for developers who need a Node.js library, command-line interface, and Model Context Protocol (MCP) server.
+
+## Install
+
+```sh
+npm install agentic-scaffold
+```
+
+Requires Node.js 18 or later. Includes TypeScript declarations and two direct dependencies: the MCP SDK and Zod.
+
+## Run your first summary
+
+No credentials, environment variables, or `.env` loader are required.
+
+```sh
+npx agentic-scaffold summary --text "hello world hello"
+```
+
+Success prints JSON with `chars: 17`, `words: 3`, `lines: 1`, and `hello` counted twice.
+
+```js
+import { summarizeText, getCostReport } from "agentic-scaffold";
+console.log(summarizeText("hello world hello"));
+console.log(getCostReport()); // { entries: [], dispatches: 0, units: 0 }
+```
+
+## Features and runtime surfaces
+
+- **Text statistics:** Character, word, line, and top-word counts; no semantic summarization.
+- **Routing:** Two generic adapters: local receipts and HTTP POST with `{ text }`.
+- **Guards:** Optional dispatch caps, UTC quiet hours, and text blocklists.
+- **Utilities:** Brand configuration, stderr logging, dry-run results, and in-memory cost units.
+- **CLI:** `summary`, `dispatch`, `costs`, `mcp`; help via `--help` and version via `--version`.
+- **MCP:** Three tools: `summarize_text`, `dispatch_text`, `get_cost_report`.
+- **Worker scaffold:** Source handler for `GET /health` and `POST /summarize`; users deploy it themselves.
+
+Start MCP with `npx agentic-scaffold mcp`. Preview routing with `npx agentic-scaffold dispatch --text hello --dry-run`.
+
+## Limits
+
+This starter has zero vendor-specific integrations. Local dispatch creates a receipt without external delivery.
+CLI and MCP dispatch use the local adapter by default; SDK callers can supply the HTTP adapter.
+HTTP delivery defaults to a ten-second timeout, with no retries. Cost units count text length rather than billing charges.
+Reports reset when the process exits. CLI help and MCP identity still use the starter name `agentic-pack`.
+
+## Customize a cloned starter
+
+```sh
+git clone https://github.com/pooriaarab/agentic-scaffold.git my-pack
+cd my-pack
+npm ci
+npm run build && npm run typecheck && npm test
+node dist/cli.js summary --text "hello world hello"
+```
+
+Replace `__PACK_NAME__`, `__NPM_NAME__`, `__PACK_COMMAND__`, `__PACK_DESCRIPTION__`, `__PACK_KEYWORDS__`, and `__GITHUB_USER__` wherever they appear.
+Check `AGENTS.md`, `SKILL.md`, `RULES.md`, `llms.txt`, `server.json`, `.mcp.json`, and `wrangler.jsonc`.
+Update package identity, bin commands, `mcpName`, and `DEFAULT_BRAND` in `src/index.ts`.
+Set the MCP manifest version and repository ID before publishing your own package.
+
+The repository includes a shared core contract and a publish workflow. Inspect that workflow before adopting its release process.
+Version 0.1.1 is an early starter release; interfaces can change.
+
+## License
+
+MIT.

package/dist/chunk-FYTHYRXT.js

@@ -0,0 +1,91 @@
+import {
+  DEFAULT_BRAND
+} from "./chunk-QWFNPAA4.js";
+import {
+  GuardError,
+  LocalRouterAdapter,
+  VendorError,
+  createLogger,
+  dispatchText,
+  getCostReport,
+  summarizeText
+} from "./chunk-USJ2R2T2.js";
+
+// src/mcp.ts
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { z } from "zod";
+var textShape = {
+  text: z.string().describe("The text to handle.")
+};
+function errorResult(error) {
+  const message = error instanceof Error ? error.message : String(error);
+  return { content: [{ type: "text", text: JSON.stringify({ error: message }) }], isError: true };
+}
+function okResult(value) {
+  return { content: [{ type: "text", text: JSON.stringify(value) }] };
+}
+function createMcpServer(deps = {}) {
+  const router = deps.router ?? new LocalRouterAdapter();
+  const guards = deps.guards;
+  const logger = deps.logger ?? createLogger({ quiet: true });
+  const server = new McpServer({
+    name: DEFAULT_BRAND.command,
+    version: DEFAULT_BRAND.version
+  });
+  server.registerTool(
+    "summarize_text",
+    {
+      description: "Count chars, words, and lines in a text, with top words.",
+      inputSchema: textShape,
+      annotations: { readOnlyHint: true }
+    },
+    async ({ text }) => okResult(summarizeText(text))
+  );
+  server.registerTool(
+    "dispatch_text",
+    {
+      description: "Route one text through the pack router. Pass dryRun to preview only.",
+      inputSchema: {
+        ...textShape,
+        dryRun: z.boolean().optional().describe("Preview the route without delivery.")
+      },
+      annotations: {
+        readOnlyHint: false,
+        destructiveHint: false,
+        idempotentHint: false,
+        openWorldHint: false
+      }
+    },
+    async ({ text, dryRun }) => {
+      try {
+        return okResult(await dispatchText(text, { adapter: router, guards, logger, dryRun: dryRun ?? false }));
+      } catch (error) {
+        if (error instanceof GuardError || error instanceof VendorError) {
+          return errorResult(error);
+        }
+        throw error;
+      }
+    }
+  );
+  server.registerTool(
+    "get_cost_report",
+    {
+      description: "Read the cost report for this session.",
+      inputSchema: {},
+      annotations: { readOnlyHint: true }
+    },
+    async () => okResult(getCostReport())
+  );
+  return server;
+}
+async function startMcp(deps = {}) {
+  const server = createMcpServer(deps);
+  const transport = new StdioServerTransport();
+  await server.connect(transport);
+}
+
+export {
+  createMcpServer,
+  startMcp
+};

package/dist/chunk-QWFNPAA4.js

@@ -0,0 +1,17 @@
+import {
+  VERSION,
+  defineBrand
+} from "./chunk-USJ2R2T2.js";
+
+// src/index.ts
+var DEFAULT_BRAND = defineBrand({
+  name: "Agentic pack",
+  command: "agentic-pack",
+  description: "Canonical scaffold for a CLI plus library plus MCP server pack.",
+  keywords: ["cli", "mcp", "scaffold", "starter", "typescript"],
+  version: VERSION
+});
+
+export {
+  DEFAULT_BRAND
+};

package/dist/chunk-USJ2R2T2.js

@@ -0,0 +1,226 @@
+// src/core.ts
+import { randomUUID } from "crypto";
+function defineBrand(config) {
+  for (const key of ["name", "command", "version"]) {
+    if (config[key].trim().length === 0) {
+      throw new Error(`brand ${key} must not be empty`);
+    }
+  }
+  return Object.freeze({ ...config, keywords: [...config.keywords] });
+}
+var LEVEL_ORDER = {
+  debug: 0,
+  info: 1,
+  warn: 2,
+  error: 3
+};
+function createLogger(options = {}) {
+  const level = options.level ?? "info";
+  const quiet = options.quiet ?? false;
+  const sink = options.sink ?? ((line) => process.stderr.write(`${line}
+`));
+  const emit = (at, message) => {
+    if (quiet) return;
+    if (LEVEL_ORDER[at] < LEVEL_ORDER[level]) return;
+    sink(`[${at}] ${message}`);
+  };
+  return {
+    debug: (message) => emit("debug", message),
+    info: (message) => emit("info", message),
+    warn: (message) => emit("warn", message),
+    error: (message) => emit("error", message)
+  };
+}
+var GuardError = class extends Error {
+  code = "GUARD_DENIED";
+  constructor(message) {
+    super(message);
+    this.name = "GuardError";
+  }
+};
+var VendorError = class extends Error {
+  code = "VENDOR_FAILED";
+  status;
+  constructor(message, options = {}) {
+    super(message, { cause: options.cause });
+    this.name = "VendorError";
+    this.status = options.status;
+  }
+};
+function assertHour(value, label) {
+  if (value === void 0) return;
+  if (!Number.isInteger(value) || value < 0 || value > 24) {
+    throw new Error(`${label} must be an integer from 0 to 24`);
+  }
+}
+function createGuards(config = {}) {
+  const maxDispatches = config.caps?.maxDispatches;
+  if (maxDispatches !== void 0 && (!Number.isInteger(maxDispatches) || maxDispatches < 0)) {
+    throw new Error("caps.maxDispatches must be an integer of 0 or more");
+  }
+  const startHour = config.quietHours?.startHour;
+  const endHour = config.quietHours?.endHour;
+  assertHour(startHour, "quietHours.startHour");
+  assertHour(endHour, "quietHours.endHour");
+  const blocklist = (config.blocklist ?? []).map((term) => term.toLowerCase());
+  const now = config.now ?? (() => /* @__PURE__ */ new Date());
+  let count = 0;
+  const inQuietHours = (date) => {
+    if (startHour === void 0 || endHour === void 0) return false;
+    const hour = date.getUTCHours();
+    if (startHour <= endHour) {
+      return hour >= startHour && hour < endHour;
+    }
+    return hour >= startHour || hour < endHour;
+  };
+  return {
+    get dispatchCount() {
+      return count;
+    },
+    checkDispatch(text) {
+      if (maxDispatches !== void 0 && count >= maxDispatches) {
+        throw new GuardError(
+          `dispatch cap reached (${maxDispatches} of ${maxDispatches})`
+        );
+      }
+      if (inQuietHours(now())) {
+        throw new GuardError(
+          `quiet hours block dispatches from ${startHour}:00 to ${endHour}:00 UTC`
+        );
+      }
+      const lowered = text.toLowerCase();
+      for (const term of blocklist) {
+        if (term.length > 0 && lowered.includes(term)) {
+          throw new GuardError(`text matches blocklisted term "${term}"`);
+        }
+      }
+    },
+    recordDispatch() {
+      count += 1;
+    }
+  };
+}
+var LocalRouterAdapter = class {
+  name = "local";
+  async dispatch(text) {
+    if (typeof text !== "string") {
+      throw new VendorError("local adapter needs a string");
+    }
+    return {
+      adapter: this.name,
+      id: randomUUID(),
+      chars: text.length,
+      at: (/* @__PURE__ */ new Date()).toISOString()
+    };
+  }
+};
+var HttpRouterAdapter = class {
+  name = "http";
+  endpoint;
+  timeoutMs;
+  fetchFn;
+  constructor(endpoint, options = {}) {
+    if (endpoint.trim().length === 0) {
+      throw new Error("http adapter needs an endpoint URL");
+    }
+    this.endpoint = endpoint;
+    this.timeoutMs = options.timeoutMs ?? 1e4;
+    this.fetchFn = options.fetchFn ?? fetch;
+  }
+  async dispatch(text) {
+    let response;
+    try {
+      response = await this.fetchFn(this.endpoint, {
+        method: "POST",
+        headers: { "content-type": "application/json" },
+        body: JSON.stringify({ text }),
+        signal: AbortSignal.timeout(this.timeoutMs)
+      });
+    } catch (error) {
+      throw new VendorError(`http adapter request failed: ${String(error)}`, {
+        cause: error
+      });
+    }
+    if (!response.ok) {
+      throw new VendorError(
+        `http adapter got status ${response.status} from ${this.endpoint}`,
+        { status: response.status }
+      );
+    }
+    return {
+      adapter: this.name,
+      id: randomUUID(),
+      chars: text.length,
+      at: (/* @__PURE__ */ new Date()).toISOString()
+    };
+  }
+};
+var costEntries = [];
+function recordCost(entry) {
+  costEntries.push({ ...entry, at: (/* @__PURE__ */ new Date()).toISOString() });
+}
+function getCostReport() {
+  const entries = costEntries.map((entry) => ({ ...entry }));
+  return {
+    entries,
+    dispatches: entries.filter((entry) => entry.kind === "dispatch").length,
+    units: entries.reduce((sum, entry) => sum + entry.units, 0)
+  };
+}
+function resetCosts() {
+  costEntries.length = 0;
+}
+function createDryRunResult(text, adapterName) {
+  return { dryRun: true, adapter: adapterName, chars: text.length };
+}
+async function dispatchText(text, options = {}) {
+  const adapter = options.adapter ?? new LocalRouterAdapter();
+  options.guards?.checkDispatch(text);
+  if (options.dryRun === true) {
+    options.logger?.info(`dry run: would dispatch ${text.length} chars`);
+    return createDryRunResult(text, adapter.name);
+  }
+  const receipt = await adapter.dispatch(text);
+  options.guards?.recordDispatch();
+  recordCost({ kind: "dispatch", adapter: adapter.name, units: text.length });
+  options.logger?.info(`dispatched ${text.length} chars via ${adapter.name}`);
+  return { dryRun: false, adapter: adapter.name, chars: text.length, receipt };
+}
+function summarizeText(text, options = {}) {
+  const topN = options.topN ?? 5;
+  const tokens = text.split(/\s+/).filter((token) => token.length > 0);
+  const counts = /* @__PURE__ */ new Map();
+  for (const token of tokens) {
+    const word = token.toLowerCase().replace(/[^a-z0-9]+/g, "");
+    if (word.length === 0) continue;
+    counts.set(word, (counts.get(word) ?? 0) + 1);
+  }
+  const topWords = [...counts.entries()].map(([word, count]) => ({ word, count })).sort((a, b) => b.count - a.count || a.word.localeCompare(b.word)).slice(0, Math.max(0, topN));
+  return {
+    chars: text.length,
+    words: tokens.length,
+    lines: text.length === 0 ? 0 : text.split("\n").length,
+    topWords
+  };
+}
+
+// src/version.ts
+import { createRequire } from "module";
+var VERSION = true ? "0.1.2" : readPackageVersion();
+
+export {
+  defineBrand,
+  createLogger,
+  GuardError,
+  VendorError,
+  createGuards,
+  LocalRouterAdapter,
+  HttpRouterAdapter,
+  recordCost,
+  getCostReport,
+  resetCosts,
+  createDryRunResult,
+  dispatchText,
+  summarizeText,
+  VERSION
+};

package/dist/cli.d.ts

@@ -0,0 +1,24 @@
+#!/usr/bin/env node
+import { R as RouterAdapter } from './core-gVNKa11w.js';
+
+declare class UsageError extends Error {
+    constructor(message: string);
+}
+type CliCommand = "summary" | "dispatch" | "costs" | "mcp" | "help" | "version";
+interface CliRequest {
+    command: CliCommand;
+    text?: string;
+    file?: string;
+    dryRun: boolean;
+    topN?: number;
+}
+declare function parseArgs(argv: string[]): CliRequest;
+interface CliIo {
+    out(line: string): void;
+    err(line: string): void;
+    readFile(path: string): string;
+    router: RouterAdapter;
+}
+declare function runCli(argv: string[], io?: CliIo): Promise<number>;
+
+export { type CliCommand, type CliIo, type CliRequest, UsageError, parseArgs, runCli };

package/dist/cli.js

@@ -0,0 +1,173 @@
+#!/usr/bin/env node
+import {
+  DEFAULT_BRAND
+} from "./chunk-QWFNPAA4.js";
+import {
+  GuardError,
+  LocalRouterAdapter,
+  VERSION,
+  VendorError,
+  dispatchText,
+  getCostReport,
+  summarizeText
+} from "./chunk-USJ2R2T2.js";
+
+// src/cli.ts
+import { readFileSync, realpathSync } from "fs";
+import { pathToFileURL } from "url";
+var UsageError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "UsageError";
+  }
+};
+function parseArgs(argv) {
+  const request = { command: "help", dryRun: false };
+  const args = [...argv];
+  const first = args.shift();
+  if (first === void 0 || first === "--help" || first === "-h") {
+    return request;
+  }
+  if (first === "--version" || first === "-V") {
+    request.command = "version";
+    return request;
+  }
+  if (first !== "summary" && first !== "dispatch" && first !== "costs" && first !== "mcp") {
+    throw new UsageError(`unknown command "${first}"`);
+  }
+  request.command = first;
+  while (args.length > 0) {
+    const flag = args.shift();
+    if (flag === "--dry-run" && request.command === "dispatch") {
+      request.dryRun = true;
+      continue;
+    }
+    if ((flag === "--text" || flag === "--file" || flag === "--top") && args.length > 0) {
+      const value = args.shift();
+      if (flag === "--text") request.text = value;
+      if (flag === "--file") request.file = value;
+      if (flag === "--top") {
+        const topN = Number.parseInt(value, 10);
+        if (!Number.isInteger(topN) || topN < 0) {
+          throw new UsageError(`--top needs an integer of 0 or more, got "${value}"`);
+        }
+        request.topN = topN;
+      }
+      continue;
+    }
+    throw new UsageError(`unknown flag "${flag}" for "${request.command}"`);
+  }
+  if ((request.command === "summary" || request.command === "dispatch") && request.text === void 0 && request.file === void 0) {
+    throw new UsageError(`${request.command} needs --text or --file`);
+  }
+  return request;
+}
+function defaultIo() {
+  return {
+    out: (line) => console.log(line),
+    err: (line) => console.error(line),
+    readFile: (path) => readFileSync(path, "utf8"),
+    router: new LocalRouterAdapter()
+  };
+}
+function helpText() {
+  const command = DEFAULT_BRAND.command;
+  return [
+    `${DEFAULT_BRAND.name} ${VERSION}`,
+    `${DEFAULT_BRAND.description}`,
+    "",
+    `Usage: ${command} <command> [flags]`,
+    "",
+    "Commands:",
+    "  summary --text <t> [--file <p>] [--top <n>]  Print text stats as JSON.",
+    "  dispatch --text <t> [--file <p>] [--dry-run] Route one text, print the receipt.",
+    "  costs                                      Print the cost report as JSON.",
+    "  mcp                                        Start the MCP server on stdio.",
+    "",
+    "Flags:",
+    "  --help, -h       Print this help.",
+    "  --version, -V    Print the version."
+  ].join("\n");
+}
+function readInput(request, io) {
+  if (request.file !== void 0) {
+    return io.readFile(request.file);
+  }
+  return request.text ?? "";
+}
+async function runCli(argv, io = defaultIo()) {
+  let request;
+  try {
+    request = parseArgs(argv);
+  } catch (error) {
+    io.err(error instanceof Error ? error.message : String(error));
+    io.err(`Run "${DEFAULT_BRAND.command} --help" for usage.`);
+    return 2;
+  }
+  try {
+    switch (request.command) {
+      case "help":
+        io.out(helpText());
+        return 0;
+      case "version":
+        io.out(VERSION);
+        return 0;
+      case "summary": {
+        const summary = summarizeText(readInput(request, io), { topN: request.topN });
+        io.out(JSON.stringify(summary));
+        return 0;
+      }
+      case "dispatch": {
+        const result = await dispatchText(readInput(request, io), {
+          adapter: io.router,
+          dryRun: request.dryRun
+        });
+        io.out(JSON.stringify(result));
+        return 0;
+      }
+      case "costs":
+        io.out(JSON.stringify(getCostReport()));
+        return 0;
+      case "mcp": {
+        const { startMcp } = await import("./mcp.js");
+        await startMcp();
+        return 0;
+      }
+    }
+  } catch (error) {
+    if (error instanceof GuardError || error instanceof VendorError || error instanceof UsageError) {
+      io.err(`${error.name}: ${error.message}`);
+      return 1;
+    }
+    if (error instanceof Error && "code" in error && error.code === "ENOENT") {
+      io.err(`file not found: ${request.file ?? ""}`);
+      return 1;
+    }
+    throw error;
+  }
+}
+function isMainModule() {
+  const invoked = process.argv[1];
+  if (typeof invoked !== "string") return false;
+  try {
+    return import.meta.url === pathToFileURL(realpathSync(invoked)).href;
+  } catch {
+    return false;
+  }
+}
+if (isMainModule()) {
+  runCli(process.argv.slice(2)).then(
+    (code) => {
+      if (code !== 0) process.exit(code);
+    },
+    (error) => {
+      console.error(error instanceof Error ? error.message : String(error));
+      process.exit(1);
+    }
+  );
+}
+export {
+  UsageError,
+  parseArgs,
+  runCli
+};

package/dist/core-gVNKa11w.d.ts

@@ -0,0 +1,126 @@
+interface BrandConfig {
+    name: string;
+    command: string;
+    description: string;
+    keywords: string[];
+    version: string;
+}
+declare function defineBrand(config: BrandConfig): BrandConfig;
+type LogLevel = "debug" | "info" | "warn" | "error";
+interface Logger {
+    debug(message: string): void;
+    info(message: string): void;
+    warn(message: string): void;
+    error(message: string): void;
+}
+interface LoggerOptions {
+    level?: LogLevel;
+    quiet?: boolean;
+    sink?: (line: string) => void;
+}
+declare function createLogger(options?: LoggerOptions): Logger;
+declare class GuardError extends Error {
+    readonly code = "GUARD_DENIED";
+    constructor(message: string);
+}
+declare class VendorError extends Error {
+    readonly code = "VENDOR_FAILED";
+    readonly status?: number;
+    constructor(message: string, options?: {
+        status?: number;
+        cause?: unknown;
+    });
+}
+interface CapsConfig {
+    maxDispatches?: number;
+}
+interface QuietHoursConfig {
+    startHour?: number;
+    endHour?: number;
+}
+interface GuardsConfig {
+    caps?: CapsConfig;
+    quietHours?: QuietHoursConfig;
+    blocklist?: string[];
+    now?: () => Date;
+}
+interface Guards {
+    readonly dispatchCount: number;
+    checkDispatch(text: string): void;
+    recordDispatch(): void;
+}
+declare function createGuards(config?: GuardsConfig): Guards;
+interface DispatchReceipt {
+    adapter: string;
+    id: string;
+    chars: number;
+    at: string;
+}
+interface RouterAdapter {
+    readonly name: string;
+    dispatch(text: string): Promise<DispatchReceipt>;
+}
+declare class LocalRouterAdapter implements RouterAdapter {
+    readonly name = "local";
+    dispatch(text: string): Promise<DispatchReceipt>;
+}
+interface HttpRouterOptions {
+    timeoutMs?: number;
+    fetchFn?: typeof fetch;
+}
+declare class HttpRouterAdapter implements RouterAdapter {
+    readonly name = "http";
+    private readonly endpoint;
+    private readonly timeoutMs;
+    private readonly fetchFn;
+    constructor(endpoint: string, options?: HttpRouterOptions);
+    dispatch(text: string): Promise<DispatchReceipt>;
+}
+interface CostEntry {
+    kind: string;
+    adapter: string;
+    units: number;
+    at: string;
+}
+interface CostReport {
+    entries: CostEntry[];
+    dispatches: number;
+    units: number;
+}
+declare function recordCost(entry: {
+    kind: string;
+    adapter: string;
+    units: number;
+}): void;
+declare function getCostReport(): CostReport;
+declare function resetCosts(): void;
+interface DispatchOptions {
+    adapter?: RouterAdapter;
+    guards?: Guards;
+    logger?: Logger;
+    dryRun?: boolean;
+}
+interface DispatchResult {
+    dryRun: boolean;
+    adapter: string;
+    chars: number;
+    receipt?: DispatchReceipt;
+}
+declare function createDryRunResult(text: string, adapterName: string): DispatchResult;
+declare function dispatchText(text: string, options?: DispatchOptions): Promise<DispatchResult>;
+interface TopWord {
+    word: string;
+    count: number;
+}
+interface TextSummary {
+    chars: number;
+    words: number;
+    lines: number;
+    topWords: TopWord[];
+}
+interface SummarizeOptions {
+    topN?: number;
+}
+declare function summarizeText(text: string, options?: SummarizeOptions): TextSummary;
+
+export { type BrandConfig as B, type CapsConfig as C, type DispatchOptions as D, type Guards as G, HttpRouterAdapter as H, type Logger as L, type QuietHoursConfig as Q, type RouterAdapter as R, type SummarizeOptions as S, type TextSummary as T, VendorError as V, type CostEntry as a, type CostReport as b, type DispatchReceipt as c, type DispatchResult as d, GuardError as e, type GuardsConfig as f, type HttpRouterOptions as g, LocalRouterAdapter as h, type LogLevel as i, type LoggerOptions as j, type TopWord as k, createDryRunResult as l, createGuards as m, createLogger as n, defineBrand as o, dispatchText as p, getCostReport as q, recordCost as r, resetCosts as s, summarizeText as t };

package/dist/index.d.ts

@@ -0,0 +1,8 @@
+import { B as BrandConfig } from './core-gVNKa11w.js';
+export { C as CapsConfig, a as CostEntry, b as CostReport, D as DispatchOptions, c as DispatchReceipt, d as DispatchResult, e as GuardError, G as Guards, f as GuardsConfig, H as HttpRouterAdapter, g as HttpRouterOptions, h as LocalRouterAdapter, i as LogLevel, L as Logger, j as LoggerOptions, Q as QuietHoursConfig, R as RouterAdapter, S as SummarizeOptions, T as TextSummary, k as TopWord, V as VendorError, l as createDryRunResult, m as createGuards, n as createLogger, o as defineBrand, p as dispatchText, q as getCostReport, r as recordCost, s as resetCosts, t as summarizeText } from './core-gVNKa11w.js';
+
+declare const VERSION: string;
+
+declare const DEFAULT_BRAND: BrandConfig;
+
+export { BrandConfig, DEFAULT_BRAND, VERSION };

package/dist/index.js

@@ -0,0 +1,36 @@
+import {
+  DEFAULT_BRAND
+} from "./chunk-QWFNPAA4.js";
+import {
+  GuardError,
+  HttpRouterAdapter,
+  LocalRouterAdapter,
+  VERSION,
+  VendorError,
+  createDryRunResult,
+  createGuards,
+  createLogger,
+  defineBrand,
+  dispatchText,
+  getCostReport,
+  recordCost,
+  resetCosts,
+  summarizeText
+} from "./chunk-USJ2R2T2.js";
+export {
+  DEFAULT_BRAND,
+  GuardError,
+  HttpRouterAdapter,
+  LocalRouterAdapter,
+  VERSION,
+  VendorError,
+  createDryRunResult,
+  createGuards,
+  createLogger,
+  defineBrand,
+  dispatchText,
+  getCostReport,
+  recordCost,
+  resetCosts,
+  summarizeText
+};

package/dist/mcp-bin.d.ts

@@ -0,0 +1 @@
+#!/usr/bin/env node

package/dist/mcp-bin.js

@@ -0,0 +1,12 @@
+#!/usr/bin/env node
+import {
+  startMcp
+} from "./chunk-FYTHYRXT.js";
+import "./chunk-QWFNPAA4.js";
+import "./chunk-USJ2R2T2.js";
+
+// src/mcp-bin.ts
+startMcp().catch((error) => {
+  console.error(error instanceof Error ? error.message : String(error));
+  process.exit(1);
+});

package/dist/mcp.d.ts

@@ -0,0 +1,12 @@
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { R as RouterAdapter, G as Guards, L as Logger } from './core-gVNKa11w.js';
+
+interface McpDeps {
+    router?: RouterAdapter;
+    guards?: Guards;
+    logger?: Logger;
+}
+declare function createMcpServer(deps?: McpDeps): McpServer;
+declare function startMcp(deps?: McpDeps): Promise<void>;
+
+export { type McpDeps, createMcpServer, startMcp };

package/dist/mcp.js

@@ -0,0 +1,10 @@
+import {
+  createMcpServer,
+  startMcp
+} from "./chunk-FYTHYRXT.js";
+import "./chunk-QWFNPAA4.js";
+import "./chunk-USJ2R2T2.js";
+export {
+  createMcpServer,
+  startMcp
+};

package/dist/worker.d.ts

@@ -0,0 +1,8 @@
+interface WorkerEnv {
+    PACK_NAME?: string;
+}
+declare const _default: {
+    fetch(request: Request, env: WorkerEnv): Promise<Response>;
+};
+
+export { type WorkerEnv, _default as default };

package/dist/worker.js

@@ -0,0 +1,40 @@
+import {
+  VERSION,
+  summarizeText
+} from "./chunk-USJ2R2T2.js";
+
+// src/worker.ts
+function json(value, status = 200) {
+  return new Response(JSON.stringify(value), {
+    status,
+    headers: { "content-type": "application/json" }
+  });
+}
+var worker_default = {
+  async fetch(request, env) {
+    const url = new URL(request.url);
+    if (request.method === "GET" && url.pathname === "/health") {
+      return json({ ok: true, pack: env.PACK_NAME ?? "agentic-pack", version: VERSION });
+    }
+    if (request.method === "POST" && url.pathname === "/summarize") {
+      let body;
+      try {
+        body = await request.json();
+      } catch {
+        return json({ error: "body must be JSON" }, 400);
+      }
+      if (typeof body !== "object" || body === null || !("text" in body)) {
+        return json({ error: "body needs a text string" }, 400);
+      }
+      const { text } = body;
+      if (typeof text !== "string") {
+        return json({ error: "body needs a text string" }, 400);
+      }
+      return json(summarizeText(text));
+    }
+    return json({ error: "not found" }, 404);
+  }
+};
+export {
+  worker_default as default
+};

package/package.json

@@ -1,6 +1,66 @@
 {
   "name": "agentic-scaffold",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "0.1.2",
+  "description": "TypeScript scaffold for a Node.js library, CLI, and MCP server with Zod schemas, text statistics, routing adapters, and dispatch guards.",
+  "keywords": [
+    "typescript",
+    "Node.js",
+    "cli",
+    "mcp",
+    "Model Context Protocol",
+    "Zod",
+    "scaffold",
+    "starter",
+    "sdk",
+    "text-statistics",
+    "http",
+    "dispatch",
+    "guards"
+  ],
+  "license": "MIT",
+  "author": "Pooria Arab",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/pooriaarab/agentic-scaffold.git"
+  },
+  "type": "module",
+  "private": false,
+  "engines": {
+    "node": ">=18"
+  },
+  "files": [
+    "dist"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "mcpName": "io.github.pooriaarab/agentic-scaffold",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    }
+  },
+  "bin": {
+    "agentic-scaffold": "./dist/cli.js",
+    "agentic-scaffold-mcp": "./dist/mcp-bin.js"
+  },
+  "scripts": {
+    "build": "tsup",
+    "typecheck": "tsc --noEmit",
+    "test": "vitest run",
+    "clean": "rm -rf dist"
+  },
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.12.0",
+    "zod": "^3.25.0"
+  },
+  "devDependencies": {
+    "@types/node": "^22.0.0",
+    "tsup": "^8.0.0",
+    "typescript": "^5.6.0",
+    "vitest": "^3.0.0"
+  }
+}