agentic-scaffold 0.0.0-stage → 0.1.1

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,108 @@
-# 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.
+Canonical scaffold for a CLI plus library plus MCP server pack.
+
+Clone this repo to start a new pack. It gives one core with three
+faces: a terminal command, an npm import, and an MCP server.
+
+## What you get
+
+- One core: brand config, logs, guards, routing, dry run, cost reports.
+- Three faces over that core: CLI, library, MCP server.
+- A frozen core contract, so packs share one API.
+- A worker entry and a wrangler sample for edge deploys.
+- Build, typecheck, and tests that pass from a fresh clone.
+
+## Quick start
+
+```sh
+git clone https://github.com/pooriaarab/agentic-scaffold.git my-pack
+cd my-pack
+npm install
+npm run build
+npm run typecheck
+npm test
+```
+
+Run the command:
+
+```sh
+node dist/cli.js summary --text "hello world hello"
+```
+
+Call the library:
+
+```js
+import { summarizeText } from "./dist/index.js";
+
+console.log(summarizeText("hello world hello"));
+```
+
+Start the MCP server:
+
+```sh
+node dist/cli.js mcp
+```
+
+## Three usecases
+
+1. You run one text summary from the terminal.
+2. You import the summary function in a script.
+3. You let an agent call the same function as an MCP tool.
+
+## Clone checklist
+
+This repo is a template. Replace each slot in each file that holds it.
+
+- `__PACK_NAME__`: the directory name, like `my-pack`.
+- `__NPM_NAME__`: the npm name, like `agentic-<block>` (bare name, never @pooriaarab/ scoped unless the brief says scoped).
+- `__PACK_COMMAND__`: the terminal command, like `my-pack`.
+- `__PACK_DESCRIPTION__`: one plain sentence, under 100 chars.
+- `__PACK_KEYWORDS__`: plain keywords, like `notes, search, cli`.
+- `__GITHUB_USER__`: the repo owner, like `pooriaarab`.
+
+Slot files: `AGENTS.md`, `SKILL.md`, `RULES.md`, `llms.txt`,
+`server.json`, `.mcp.json`, `wrangler.jsonc`.
+
+Then rename the scaffold identity itself:
+
+- `package.json`: name, bin commands, mcpName. Remove `"private": true`.
+- `src/index.ts`: the `DEFAULT_BRAND` fields.
+- This file: the pitch and the examples above.
+
+At publish time, set `server.json` version to the npm version and
+`server.json` repository id from `gh api repos/OWNER/REPO --jq .id`.
+
+## Gates
+
+Run all three before you push a pack:
+
+```sh
+npm run build && npm run typecheck && npm test
+```
+
+Then run the real installed CLI once from a tarball:
+
+```sh
+npm pack
+npx --yes --package ./pooriaarab-agentic-scaffold-0.1.0.tgz agentic-pack summary --text "hello"
+```
+
+## Release flow
+
+Push to `main` for review. Merge to `release` to publish. The
+publish workflow ships only when the version is new.
+
+## Layout
+
+- `src/index.ts`: the library face.
+- `src/cli.ts`: the terminal face.
+- `src/mcp.ts`: the MCP server. `src/mcp-bin.ts` starts it.
+- `src/worker.ts`: the edge worker face.
+- `src/core.ts`: the shared core.
+- `agentic-core.d.ts`: the frozen contract.
+- `docs/agentic-core.md`: the contract in plain words.
+
+## License
+
+MIT. See `LICENSE`.

package/dist/chunk-E72J53UI.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.1" : readPackageVersion();
+
+export {
+  defineBrand,
+  createLogger,
+  GuardError,
+  VendorError,
+  createGuards,
+  LocalRouterAdapter,
+  HttpRouterAdapter,
+  recordCost,
+  getCostReport,
+  resetCosts,
+  createDryRunResult,
+  dispatchText,
+  summarizeText,
+  VERSION
+};

package/dist/chunk-P7R4J6SZ.js

@@ -0,0 +1,17 @@
+import {
+  VERSION,
+  defineBrand
+} from "./chunk-E72J53UI.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-USTEVUWE.js

@@ -0,0 +1,91 @@
+import {
+  DEFAULT_BRAND
+} from "./chunk-P7R4J6SZ.js";
+import {
+  GuardError,
+  LocalRouterAdapter,
+  VendorError,
+  createLogger,
+  dispatchText,
+  getCostReport,
+  summarizeText
+} from "./chunk-E72J53UI.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/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-P7R4J6SZ.js";
+import {
+  GuardError,
+  LocalRouterAdapter,
+  VERSION,
+  VendorError,
+  dispatchText,
+  getCostReport,
+  summarizeText
+} from "./chunk-E72J53UI.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-P7R4J6SZ.js";
+import {
+  GuardError,
+  HttpRouterAdapter,
+  LocalRouterAdapter,
+  VERSION,
+  VendorError,
+  createDryRunResult,
+  createGuards,
+  createLogger,
+  defineBrand,
+  dispatchText,
+  getCostReport,
+  recordCost,
+  resetCosts,
+  summarizeText
+} from "./chunk-E72J53UI.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-USTEVUWE.js";
+import "./chunk-P7R4J6SZ.js";
+import "./chunk-E72J53UI.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-USTEVUWE.js";
+import "./chunk-P7R4J6SZ.js";
+import "./chunk-E72J53UI.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-E72J53UI.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,58 @@
 {
   "name": "agentic-scaffold",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "0.1.1",
+  "description": "Canonical scaffold for a CLI plus library plus MCP server pack.",
+  "keywords": [
+    "cli",
+    "mcp",
+    "scaffold",
+    "starter",
+    "typescript"
+  ],
+  "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"
+  }
+}