@directive-run/cli 0.2.0

package/dist/index.cjs

@@ -0,0 +1,681 @@
+'use strict';
+
+var knowledge = require('@directive-run/knowledge');
+var fs = require('fs');
+var path = require('path');
+var pc = require('picocolors');
+
+function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
+
+var pc__default = /*#__PURE__*/_interopDefault(pc);
+
+// src/lib/knowledge.ts
+
+// src/templates/claude.ts
+function generateClaudeRules() {
+  const corePatterns = knowledge.getKnowledge("core-patterns");
+  const antiPatterns = knowledge.getKnowledge("anti-patterns");
+  const naming = knowledge.getKnowledge("naming");
+  const schemaTypes = knowledge.getKnowledge("schema-types");
+  return `# Directive \u2014 Complete AI Coding Rules
+
+> Constraint-driven runtime for TypeScript. Declare requirements, let the runtime resolve them.
+> https://directive.run | \`npm install @directive-run/core\`
+> Full reference with examples: https://directive.run/llms.txt
+
+## Core Patterns
+
+${corePatterns}
+
+---
+
+## Anti-Patterns (All 36)
+
+${antiPatterns}
+
+### AI Package Anti-Patterns (21-36)
+
+| # | WRONG | CORRECT |
+|---|-------|---------|
+| 21 | TS types for factsSchema: \`{ confidence: number }\` | Use \`{ confidence: t.number() }\` |
+| 22 | \`facts.cache.push(item)\` in orchestrator | \`facts.cache = [...facts.cache, item]\` |
+| 23 | Returning data from orchestrator \`resolve\` | Resolvers return \`void\` \u2014 mutate \`context.facts\` |
+| 24 | Forgetting \`orchestrator.start()\` multi-agent | Single: implicit. Multi: must call \`start()\` |
+| 25 | Catching \`Error\` not \`GuardrailError\` | \`GuardrailError\` has \`.guardrailName\`, \`.errorCode\` |
+| 26 | \`from '@directive-run/ai'\` for adapters | Subpath: \`from '@directive-run/ai/openai'\` |
+| 27 | Assuming \`{ input_tokens }\` structure | Normalized: \`{ inputTokens, outputTokens }\` |
+| 28 | Same CircuitBreaker across agents | Create separate instances per dependency |
+| 29 | \`budgetWarningThreshold: 1.5\` | Must be 0-1 (percentage) |
+| 30 | \`race\` minSuccess > agents.length | Must be \`1 \u2264 minSuccess \u2264 agents.length\` |
+| 31 | Async summarizer with autoManage: true | Use \`autoManage: false\` for sync control |
+| 32 | Side effects in reflect \`evaluator\` | Evaluator must be pure |
+| 33 | Task calling \`runSingleAgent\` | Tasks can't call agents \u2014 separate node |
+| 34 | Task expecting object input | Input is always \`string\` \u2014 \`JSON.parse(input)\` |
+| 35 | Task ID same as agent ID | IDs share namespace \u2014 distinct names |
+| 36 | \`from '@directive-run/ai/mcp'\` | \`from '@directive-run/ai'\` (main export) |
+
+---
+
+## Naming Conventions
+
+${naming}
+
+---
+
+## Schema Type Builders
+
+${schemaTypes}
+
+---
+
+## Multi-Module Quick Reference
+
+\`\`\`typescript
+// Two modules with cross-module dependency
+const authSchema = { facts: { token: t.string(), isAuth: t.boolean() } };
+const authModule = createModule("auth", { schema: authSchema, /* ... */ });
+
+const cartModule = createModule("cart", {
+  schema: { facts: { items: t.array<CartItem>() } },
+  crossModuleDeps: { auth: authSchema },  // Declare dependency
+  constraints: {
+    checkout: {
+      when: (facts) => facts.self.items.length > 0 && facts.auth.isAuth,  // facts.self.* for own, facts.auth.* for cross
+      require: () => ({ type: "CHECKOUT" }),
+    },
+  },
+  // ...
+});
+
+const system = createSystem({ modules: { auth: authModule, cart: cartModule } });
+// Access: system.facts.auth.token, system.events.cart.addItem({...})
+\`\`\`
+
+Key rules:
+- \`facts.self.*\` for own module facts in constraints/resolvers
+- \`facts.otherModule.*\` for cross-module reads
+- \`crossModuleDeps\` must declare consumed schemas
+- \`system.events.moduleName.eventName(payload)\` for namespaced events
+- The \`::\` separator is internal \u2014 always use dot notation
+
+---
+
+## Constraints
+
+- \`when(facts)\` \u2192 boolean. When true, requirement is emitted.
+- \`require(facts)\` \u2192 \`{ type: "TYPE", ...data }\` object (never string literal)
+- \`priority: number\` \u2014 higher evaluated first
+- \`after: ["constraintName"]\` \u2014 ordering within same priority
+- Async: \`async: true\` + \`deps: ['factName']\` (deps REQUIRED for async)
+- Constraints DECLARE needs, resolvers FULFILL them \u2014 decoupled.
+
+---
+
+## Resolvers
+
+- \`resolve(req, context)\` \u2014 async, returns \`void\`. Mutate \`context.facts.*\`.
+- \`requirement: "TYPE"\` \u2014 which type this handles
+- \`key: (req) => string\` \u2014 deduplication key
+- \`retry: { attempts: 3, backoff: "exponential", initialDelay: 100 }\`
+- \`batch: { maxSize: 10, windowMs: 50 }\` for N+1 prevention
+- Always \`await system.settle()\` after start to wait for resolution
+
+---
+
+## System API
+
+- \`system.facts.fieldName\` \u2014 read/write facts
+- \`system.derive.derivationName\` \u2014 read derived values
+- \`system.events.eventName(payload)\` \u2014 dispatch events
+- \`system.subscribe(listener)\` \u2014 subscribe to all changes
+- \`system.read(key)\` \u2014 read fact or derivation by string key
+- \`system.inspect()\` \u2014 full state snapshot
+- \`system.settle()\` \u2014 wait for async operations
+- \`system.start()\` / \`system.stop()\` / \`system.destroy()\`
+
+---
+
+## React (\`@directive-run/react\`)
+
+\`\`\`typescript
+import { useSelector, useEvent } from "@directive-run/react";
+
+const count = useSelector(system, (s) => s.facts.count);
+const events = useEvent(system);
+// onClick={() => events.increment()}
+\`\`\`
+
+**NO** \`useDirective()\` hook. Use \`useSelector\` + \`useEvent\`.
+
+---
+
+## Plugins (\`@directive-run/core/plugins\`)
+
+\`devtoolsPlugin()\`, \`loggingPlugin()\`, \`persistencePlugin(config)\`,
+\`createCircuitBreaker(config)\`, \`createObservability(config)\`
+
+---
+
+## AI Package (\`@directive-run/ai\`)
+
+### Single-Agent Orchestrator
+
+\`\`\`typescript
+import { createAgentOrchestrator, t } from '@directive-run/ai';
+import { createAnthropicRunner } from '@directive-run/ai/anthropic';
+
+const orchestrator = createAgentOrchestrator({
+  runner: createAnthropicRunner({ apiKey }),
+  factsSchema: { result: t.string(), confidence: t.number() },
+  init: (facts) => { facts.result = ""; facts.confidence = 0; },
+  maxTokenBudget: 100000,
+  budgetWarningThreshold: 0.8,
+  guardrails: { input: [...], output: [...] },
+  memory: createAgentMemory({ strategy: createSlidingWindowStrategy({ maxMessages: 30 }) }),
+  debug: true,
+});
+
+const result = await orchestrator.run(agent, "analyze this");
+\`\`\`
+
+### Multi-Agent
+
+\`\`\`typescript
+import { createMultiAgentOrchestrator, parallel, sequential, dag } from '@directive-run/ai';
+
+const orch = createMultiAgentOrchestrator({
+  agents: { researcher: agentA, writer: agentB },
+  patterns: {
+    pipeline: sequential(["researcher", "writer"]),
+    brainstorm: parallel(["researcher", "writer"], mergeResults),
+    workflow: dag([
+      { id: "research", handler: "researcher" },
+      { id: "write", handler: "writer", dependencies: ["research"] },
+    ]),
+  },
+  runner,
+});
+orch.start();  // Required for multi-agent!
+\`\`\`
+
+8 patterns: \`parallel\`, \`sequential\`, \`supervisor\`, \`dag\`, \`reflect\`, \`race\`, \`debate\`, \`goal\`
+
+### Adapter Imports (Subpath!)
+
+\`\`\`typescript
+import { createAnthropicRunner } from '@directive-run/ai/anthropic';
+import { createOpenAIRunner } from '@directive-run/ai/openai';
+import { createOllamaRunner } from '@directive-run/ai/ollama';
+import { createGeminiRunner } from '@directive-run/ai/gemini';
+\`\`\`
+
+### Guardrails
+
+\`createPIIGuardrail\`, \`createModerationGuardrail\`, \`createRateLimitGuardrail\`,
+\`createToolGuardrail\`, \`createOutputSchemaGuardrail\`, \`createLengthGuardrail\`,
+\`createContentFilterGuardrail\`
+
+\`GuardrailResult: { passed: boolean, reason?: string, transformed?: unknown }\`
+
+### Memory
+
+\`createAgentMemory({ strategy, summarizer?, autoManage? })\`
+Strategies: \`createSlidingWindowStrategy\`, \`createTokenBasedStrategy\`, \`createHybridStrategy\`
+Summarizers: \`createTruncationSummarizer\`, \`createKeyPointsSummarizer\`, \`createLLMSummarizer(runner)\`
+
+### Streaming
+
+\`\`\`typescript
+const streamResult = orchestrator.runStream(agent, "analyze");
+for await (const chunk of streamResult.stream) {
+  switch (chunk.type) {
+    case "token": process.stdout.write(chunk.data); break;
+    case "done": console.log("Tokens:", chunk.totalTokens); break;
+    case "error": console.error(chunk.error); break;
+  }
+}
+\`\`\`
+
+Backpressure: \`"buffer"\` (default), \`"block"\`, \`"drop"\`
+`;
+}
+
+// src/templates/cursor.ts
+function generateCursorRules() {
+  return `# Directive \u2014 AI Coding Rules
+
+> Constraint-driven runtime for TypeScript. \`npm install @directive-run/core\`
+> Full reference: https://directive.run/llms.txt
+
+## Schema Shape (CRITICAL)
+
+\`\`\`typescript
+import { createModule, createSystem, t } from "@directive-run/core";
+
+const myModule = createModule("name", {
+  schema: {
+    facts: { count: t.number(), items: t.array<string>() },
+    derivations: { total: "number" },
+    events: { increment: "void", addItem: "string" },
+    requirements: { FETCH_DATA: { url: "string" } },
+  },
+  init: (facts) => { facts.count = 0; facts.items = []; },
+  derive: {
+    total: (facts) => facts.items.length + facts.count,
+  },
+  events: {
+    increment: (facts) => { facts.count += 1; },
+    addItem: (facts, item) => { facts.items = [...facts.items, item]; },
+  },
+  constraints: {
+    fetchWhenReady: {
+      when: (facts) => facts.count > 0 && facts.items.length === 0,
+      require: (facts) => ({ type: "FETCH_DATA", url: "/api/items" }),
+    },
+  },
+  resolvers: {
+    fetchData: {
+      requirement: "FETCH_DATA",
+      resolve: async (req, context) => {
+        const data = await fetch(req.url).then(r => r.json());
+        context.facts.items = data;
+      },
+    },
+  },
+});
+
+const system = createSystem({ module: myModule });
+await system.settle();
+\`\`\`
+
+## Top 10 Anti-Patterns
+
+| # | WRONG | CORRECT |
+|---|-------|---------|
+| 1 | \`facts.profile as ResourceState<Profile>\` | Remove cast \u2014 schema provides types |
+| 2 | \`{ phase: t.string() }\` flat schema | \`schema: { facts: { phase: t.string() } }\` |
+| 3 | \`facts.items\` in multi-module | \`facts.self.items\` |
+| 4 | \`t.map()\`, \`t.set()\`, \`t.promise()\` | Don't exist. Use \`t.object<Map<K,V>>()\` |
+| 5 | \`(req, ctx)\` in resolver | \`(req, context)\` \u2014 never abbreviate |
+| 6 | \`createModule("n", { phase: t.string() })\` | Must wrap: \`schema: { facts: { ... } }\` |
+| 7 | \`system.dispatch('login', {...})\` | \`system.events.login({...})\` |
+| 8 | \`facts.items.push(item)\` | \`facts.items = [...facts.items, item]\` |
+| 9 | \`useDirective(system)\` | \`useSelector(system, s => s.facts.count)\` |
+| 10 | \`facts['auth::status']\` | \`facts.auth.status\` dot notation |
+
+## Naming
+
+- \`req\` = requirement (not request). Parameter: \`(req, context)\`
+- \`derive\` / derivations \u2014 never "computed" or "selectors"
+- Resolvers return \`void\` \u2014 mutate \`context.facts\` instead
+- Always use braces for returns: \`if (x) { return y; }\`
+- Multi-module: \`facts.self.fieldName\` for own module facts
+- Events: \`system.events.eventName(payload)\` \u2014 not \`system.dispatch()\`
+- Import from main: \`import { createModule } from '@directive-run/core'\`
+
+## Schema Types That Exist
+
+\`t.string<T>()\`, \`t.number()\`, \`t.boolean()\`, \`t.array<T>()\`, \`t.object<T>()\`,
+\`t.enum("a","b")\`, \`t.literal(value)\`, \`t.nullable(inner)\`, \`t.optional(inner)\`, \`t.union(...)\`
+
+Chainable: \`.default()\`, \`.validate()\`, \`.transform()\`, \`.brand<>()\`, \`.refine()\`
+
+**DO NOT USE** (hallucinations): \`t.map()\`, \`t.set()\`, \`t.date()\`, \`t.tuple()\`, \`t.record()\`, \`t.promise()\`, \`t.any()\`
+
+## Key Pattern: Constraint \u2192 Requirement \u2192 Resolver
+
+When the user wants "do X when Y": create THREE things:
+1. **Constraint**: \`when: (facts) => Y_condition\` \u2192 \`require: { type: "DO_X" }\`
+2. **Resolver**: handles "DO_X", calls API, sets \`context.facts\`
+3. They are **decoupled**. Constraint declares need, resolver fulfills it.
+`;
+}
+
+// src/templates/copilot.ts
+function generateCopilotRules() {
+  const base = generateCursorRules();
+  const extraAntiPatterns = `
+## Anti-Patterns 11-20
+
+| # | WRONG | CORRECT |
+|---|-------|---------|
+| 11 | \`module("name").schema({...}).build()\` | Prefer \`createModule("name", {...})\` object syntax |
+| 12 | Returning data from \`resolve\` | Resolvers return \`void\` \u2014 mutate \`context.facts\` |
+| 13 | Async logic in \`init\` | \`init\` is synchronous, facts assignment only |
+| 14 | \`await system.start()\` without settle | Add \`await system.settle()\` after start |
+| 15 | Missing \`crossModuleDeps\` | Declare \`crossModuleDeps: { auth: authSchema }\` |
+| 16 | \`require: "TYPE"\` string literal | \`require: { type: "TYPE" }\` object form |
+| 17 | Passthrough derivation \`(f) => f.count\` | Remove \u2014 read fact directly |
+| 18 | \`from '@directive-run/core/module'\` | \`from '@directive-run/core'\` (main export) |
+| 19 | \`async when()\` without \`deps\` | Add \`deps: ['factName']\` for async constraints |
+| 20 | No error boundary on resolver | Use try-catch or module error boundary config |
+`;
+  const multiModule = `
+## Multi-Module
+
+\`\`\`typescript
+const system = createSystem({
+  modules: { auth: authModule, cart: cartModule },
+});
+
+// Access: system.facts.auth.token, system.events.cart.addItem({...})
+// In constraints/resolvers: use facts.self.* for own module
+// Declare deps: crossModuleDeps: { auth: authSchema }
+\`\`\`
+`;
+  const aiBasics = `
+## AI Package Basics (\`@directive-run/ai\`)
+
+\`\`\`typescript
+import { createAgentOrchestrator, t } from '@directive-run/ai';
+import { createAnthropicRunner } from '@directive-run/ai/anthropic'; // Subpath import!
+
+const orchestrator = createAgentOrchestrator({
+  runner: createAnthropicRunner({ apiKey: process.env.ANTHROPIC_API_KEY }),
+  factsSchema: { result: t.string(), confidence: t.number() }, // Use t.*() !
+  init: (facts) => { facts.result = ""; facts.confidence = 0; },
+});
+
+const result = await orchestrator.run(agent, "analyze this");
+\`\`\`
+
+**AI Anti-Patterns:**
+- Use \`t.number()\` not \`number\` for factsSchema
+- Subpath imports: \`from '@directive-run/ai/anthropic'\` not \`from '@directive-run/ai'\`
+- Token usage normalized: \`{ inputTokens, outputTokens }\` (not provider-specific)
+- \`facts.cache = [...facts.cache, item]\` not \`facts.cache.push(item)\`
+`;
+  return base + extraAntiPatterns + multiModule + aiBasics;
+}
+
+// src/templates/cline.ts
+function generateClineRules() {
+  return generateCopilotRules();
+}
+
+// src/templates/llms-txt.ts
+function generateLlmsTxt() {
+  const knowledge$1 = knowledge.getAllKnowledge();
+  const examples = knowledge.getAllExamples();
+  const coreOrder = [
+    "core-patterns",
+    "anti-patterns",
+    "naming",
+    "multi-module",
+    "constraints",
+    "resolvers",
+    "error-boundaries",
+    "testing",
+    "time-travel",
+    "schema-types",
+    "system-api",
+    "react-adapter",
+    "plugins"
+  ];
+  const aiOrder = [
+    "ai-orchestrator",
+    "ai-multi-agent",
+    "ai-tasks",
+    "ai-agents-streaming",
+    "ai-guardrails-memory",
+    "ai-adapters",
+    "ai-budget-resilience",
+    "ai-mcp-rag",
+    "ai-communication",
+    "ai-debug-observability",
+    "ai-security",
+    "ai-testing-evals"
+  ];
+  const exampleOrder = [
+    "counter",
+    "auth-flow",
+    "shopping-cart",
+    "error-boundaries",
+    "ai-orchestrator",
+    "fraud-analysis",
+    "ai-checkpoint"
+  ];
+  const sections = [
+    "# Directive \u2014 Complete AI Reference (llms.txt)",
+    "",
+    "> Constraint-driven runtime for TypeScript.",
+    "> Declare requirements. Let the runtime resolve them.",
+    "> https://directive.run",
+    "",
+    "## Core API (@directive-run/core)",
+    ""
+  ];
+  for (const name of coreOrder) {
+    const content = knowledge$1.get(name);
+    if (content) {
+      sections.push(content, "", "---", "");
+    }
+  }
+  sections.push("## AI Package (@directive-run/ai)", "");
+  for (const name of aiOrder) {
+    const content = knowledge$1.get(name);
+    if (content) {
+      sections.push(content, "", "---", "");
+    }
+  }
+  const apiSkeleton = knowledge$1.get("api-skeleton");
+  if (apiSkeleton) {
+    sections.push("## API Reference (Auto-Generated)", "", apiSkeleton, "");
+  }
+  sections.push("## Complete Examples", "");
+  for (const name of exampleOrder) {
+    const content = examples.get(name);
+    if (content) {
+      sections.push(
+        `### ${name}`,
+        "",
+        "```typescript",
+        content,
+        "```",
+        ""
+      );
+    }
+  }
+  return sections.join("\n");
+}
+
+// src/templates/windsurf.ts
+function generateWindsurfRules() {
+  return generateCopilotRules();
+}
+
+// src/templates/index.ts
+var generators = {
+  cursor: generateCursorRules,
+  claude: generateClaudeRules,
+  copilot: generateCopilotRules,
+  windsurf: generateWindsurfRules,
+  cline: generateClineRules
+};
+function getTemplate(toolId) {
+  const generator = generators[toolId];
+  if (!generator) {
+    throw new Error(`No template for tool: ${toolId}`);
+  }
+  return generator();
+}
+var TOOL_SIGNALS = [
+  {
+    id: "cursor",
+    name: "Cursor",
+    signals: [".cursor", ".cursorrules"],
+    outputPath: ".cursorrules"
+  },
+  {
+    id: "claude",
+    name: "Claude Code",
+    signals: [".claude"],
+    outputPath: ".claude/CLAUDE.md"
+  },
+  {
+    id: "copilot",
+    name: "GitHub Copilot",
+    signals: [".github"],
+    outputPath: ".github/copilot-instructions.md"
+  },
+  {
+    id: "windsurf",
+    name: "Windsurf",
+    signals: [".windsurfrules"],
+    outputPath: ".windsurfrules"
+  },
+  {
+    id: "cline",
+    name: "Cline",
+    signals: [".clinerules"],
+    outputPath: ".clinerules"
+  }
+];
+function detectTools(rootDir) {
+  const detected = [];
+  for (const tool of TOOL_SIGNALS) {
+    const hasSignal = tool.signals.some(
+      (signal) => fs.existsSync(path.join(rootDir, signal))
+    );
+    if (hasSignal) {
+      detected.push({
+        name: tool.name,
+        id: tool.id,
+        outputPath: path.join(rootDir, tool.outputPath)
+      });
+    }
+  }
+  return detected;
+}
+var MONOREPO_SIGNALS = [
+  { file: "pnpm-workspace.yaml", tool: "pnpm" },
+  { file: "turbo.json", tool: "turbo" }
+];
+function detectMonorepo(startDir) {
+  let dir = path.resolve(startDir);
+  while (dir !== path.dirname(dir)) {
+    for (const signal of MONOREPO_SIGNALS) {
+      if (fs.existsSync(path.join(dir, signal.file))) {
+        return { isMonorepo: true, rootDir: dir, tool: signal.tool };
+      }
+    }
+    const pkgPath = path.join(dir, "package.json");
+    if (fs.existsSync(pkgPath)) {
+      try {
+        const pkg = JSON.parse(fs.readFileSync(pkgPath, "utf-8"));
+        if (pkg.workspaces) {
+          const tool = fs.existsSync(path.join(dir, "yarn.lock")) ? "yarn" : "npm";
+          return { isMonorepo: true, rootDir: dir, tool };
+        }
+      } catch {
+      }
+    }
+    dir = path.dirname(dir);
+  }
+  return { isMonorepo: false, rootDir: startDir };
+}
+
+// src/lib/constants.ts
+var CLI_NAME = "directive";
+var PACKAGE_NAME = "@directive-run/cli";
+var SECTION_START = "<!-- directive:start -->";
+var SECTION_END = "<!-- directive:end -->";
+
+// src/lib/merge.ts
+function mergeSection(existingContent, newSection) {
+  const startIdx = existingContent.indexOf(SECTION_START);
+  const endIdx = existingContent.indexOf(SECTION_END);
+  const wrapped = `${SECTION_START}
+${newSection}
+${SECTION_END}`;
+  if (startIdx !== -1 && endIdx !== -1 && endIdx > startIdx) {
+    return existingContent.slice(0, startIdx) + wrapped + existingContent.slice(endIdx + SECTION_END.length);
+  }
+  const separator = existingContent.endsWith("\n") ? "\n" : "\n\n";
+  return existingContent + separator + wrapped + "\n";
+}
+function hasDirectiveSection(content) {
+  return content.includes(SECTION_START) && content.includes(SECTION_END);
+}
+async function loadSystem(filePath) {
+  const resolved = path.resolve(filePath);
+  if (!fs.existsSync(resolved)) {
+    throw new Error(`File not found: ${resolved}`);
+  }
+  try {
+    const mod = await import(resolved);
+    if (mod.default && isSystem(mod.default)) {
+      return mod.default;
+    }
+    if (mod.system && isSystem(mod.system)) {
+      return mod.system;
+    }
+    for (const key of Object.keys(mod)) {
+      if (isSystem(mod[key])) {
+        return mod[key];
+      }
+    }
+    throw new Error(
+      `No Directive system found in ${pc__default.default.dim(filePath)}
+Export a system as default or named "system":
+
+  ${pc__default.default.cyan("export default")} createSystem({ module: myModule });
+  ${pc__default.default.cyan("export const system")} = createSystem({ module: myModule });`
+    );
+  } catch (err) {
+    if (err instanceof Error && err.message.includes("No Directive system")) {
+      throw err;
+    }
+    throw new Error(
+      `Failed to load ${pc__default.default.dim(filePath)}: ${err instanceof Error ? err.message : String(err)}
+
+Make sure the file is valid TypeScript and tsx is installed:
+  ${pc__default.default.cyan("npm install -D tsx")}`
+    );
+  }
+}
+function isSystem(obj) {
+  if (typeof obj !== "object" || obj === null) {
+    return false;
+  }
+  const sys = obj;
+  return typeof sys.inspect === "function" && typeof sys.start === "function" && typeof sys.stop === "function" && "facts" in sys;
+}
+
+Object.defineProperty(exports, "getAllExamples", {
+  enumerable: true,
+  get: function () { return knowledge.getAllExamples; }
+});
+Object.defineProperty(exports, "getAllKnowledge", {
+  enumerable: true,
+  get: function () { return knowledge.getAllKnowledge; }
+});
+Object.defineProperty(exports, "getExample", {
+  enumerable: true,
+  get: function () { return knowledge.getExample; }
+});
+Object.defineProperty(exports, "getExampleFiles", {
+  enumerable: true,
+  get: function () { return knowledge.getExampleFiles; }
+});
+Object.defineProperty(exports, "getKnowledge", {
+  enumerable: true,
+  get: function () { return knowledge.getKnowledge; }
+});
+Object.defineProperty(exports, "getKnowledgeFiles", {
+  enumerable: true,
+  get: function () { return knowledge.getKnowledgeFiles; }
+});
+exports.CLI_NAME = CLI_NAME;
+exports.PACKAGE_NAME = PACKAGE_NAME;
+exports.SECTION_END = SECTION_END;
+exports.SECTION_START = SECTION_START;
+exports.detectMonorepo = detectMonorepo;
+exports.detectTools = detectTools;
+exports.generateLlmsTxt = generateLlmsTxt;
+exports.getTemplate = getTemplate;
+exports.hasDirectiveSection = hasDirectiveSection;
+exports.loadSystem = loadSystem;
+exports.mergeSection = mergeSection;
+//# sourceMappingURL=index.cjs.map
+//# sourceMappingURL=index.cjs.map