@arnilo/prism 0.3.2 → 0.5.0

package/templates/deep-research/README.md.tmpl

@@ -0,0 +1,47 @@
+# __PROJECT_NAME__ — Deep Research Agent
+
+A production-grade, modular deep research agent built on **Prism**.
+
+The agent executes an end-to-end research pipeline:
+1. **Plan:** Generates a structured research plan with targeted queries.
+2. **Search & Extract:** Fetches search results and content via `@arnilo/prism-web-tools`.
+3. **Refine (Bounded Loop):** Evaluates coverage and refines queries across bounded iterations.
+4. **Cite & Synthesize:** Synthesizes findings with verifiable, traceable source citations.
+5. **HITL Clarification:** Proposes structured clarification choices when research topics are ambiguous.
+
+## Quick Start
+
+```bash
+# 1. Install dependencies
+npm install
+
+# 2. Run offline tests (100% offline with mock provider)
+npm test
+
+# 3. Start the research agent
+npm start
+
+# 4. Launch local dev inspector
+npm run dev
+```
+
+## Architecture & Component Mapping
+
+| Stage / Seam | Component | Documentation |
+| --- | --- | --- |
+| **Orchestration** | `@arnilo/prism-workflows` DAG with bounded refine loop & checkpoints | [`docs/workflows.md`](https://github.com/arniloy/prism/blob/main/docs/workflows.md) |
+| **Search & Fetch** | `@arnilo/prism-web-tools` Brave/Exa search & Firecrawl fetch | [`docs/web-tools.md`](https://github.com/arniloy/prism/blob/main/docs/web-tools.md) |
+| **Citations & RAG** | Attribution via `@arnilo/prism-web-tools` & `@arnilo/prism-memory` | [`docs/rag.md`](https://github.com/arniloy/prism/blob/main/docs/rag.md) |
+| **HITL Clarification** | Structured decision tool with durable suspend/resume | [`docs/coding-agent-tools.md`](https://github.com/arniloy/prism/blob/main/docs/coding-agent-tools.md) |
+| **Security & Trust** | Untrusted content boundaries for search & web data | [`docs/host-security.md`](https://github.com/arniloy/prism/blob/main/docs/host-security.md) |
+| **Inspector** | Local loopback playground via `prism dev` | [`docs/cli-rpc.md`](https://github.com/arniloy/prism/blob/main/docs/cli-rpc.md) |
+
+## Live Configuration (Opt-in)
+
+To connect real LLM providers and live web search APIs:
+1. Copy `.env.example` to `.env`:
+   ```bash
+   cp .env.example .env
+   ```
+2. Set your provider key (e.g. `OPENAI_API_KEY`) and search key (e.g. `BRAVE_API_KEY`).
+3. Update `src/tools.ts` or `src/agent.ts` to instantiate live providers.

package/templates/deep-research/env.example.tmpl

@@ -0,0 +1,12 @@
+# Deep Research Agent Environment Configuration
+# Copy this file to .env to configure live providers and search tools.
+# By default, tests and starter runs use the offline mock provider (no keys required).
+
+# --- Model Providers (Optional) ---
+# OPENAI_API_KEY=sk-...
+# ANTHROPIC_API_KEY=sk-ant-...
+
+# --- Web Search & Extraction (Optional) ---
+# BRAVE_API_KEY=...
+# FIRECRAWL_API_KEY=...
+# EXA_API_KEY=...

package/templates/deep-research/gitignore.tmpl

@@ -0,0 +1,7 @@
+node_modules/
+dist/
+.env
+.env.local
+.prism/
+coverage/
+*.log

package/templates/deep-research/manifest.json

@@ -0,0 +1,12 @@
+{
+  "name": "deep-research",
+  "description": "Deep research agent: plan -> search -> extract -> refine loop -> citations -> HITL clarify",
+  "version": "0.1.0",
+  "tags": ["research", "workflows", "web-tools", "rag", "hitl"],
+  "packages": [
+    "@arnilo/prism",
+    "@arnilo/prism-web-tools",
+    "@arnilo/prism-memory",
+    "@arnilo/prism-workflows"
+  ]
+}

package/templates/deep-research/package.json.tmpl

@@ -0,0 +1,23 @@
+{
+  "name": "__PROJECT_NAME__",
+  "version": "0.1.0",
+  "private": true,
+  "type": "module",
+  "scripts": {
+    "build": "tsc -p tsconfig.json",
+    "typecheck": "tsc -p tsconfig.json --noEmit",
+    "test": "npm run build && node --test dist/__tests__/research.test.js",
+    "start": "npm run build && node dist/index.js",
+    "dev": "prism dev"
+  },
+  "dependencies": {
+__DEPENDENCIES__
+  },
+  "devDependencies": {
+    "@types/node": "^22.0.0",
+    "typescript": "^5.7.0"
+  },
+  "engines": {
+    "node": ">=20"
+  }
+}

package/templates/deep-research/src/agent.ts.tmpl

@@ -0,0 +1,81 @@
+import {
+  type Agent,
+  createAgent,
+  createMockProvider,
+  providerDone,
+  providerTextDelta,
+} from "@arnilo/prism";
+import { createResearchSearchAdapter, createResearchWebTools } from "./tools.js";
+
+/**
+ * Creates the planning agent responsible for breaking down topics into search queries.
+ */
+export function createPlannerAgent(options?: {
+  readonly model?: { provider: string; model: string };
+  readonly provider?: import("@arnilo/prism").AIProvider;
+}): Agent {
+  const provider =
+    options?.provider ??
+    createMockProvider([
+      providerTextDelta(
+        JSON.stringify({
+          topic: "Prism Architecture",
+          queries: [
+            { query: "Prism workflows orchestration", rationale: "Understand DAG execution", aspect: "workflows" },
+            { query: "Prism web tools citations", rationale: "Check search and citation seam", aspect: "web-tools" },
+          ],
+        }),
+      ),
+      providerDone(),
+    ]);
+
+  return createAgent({
+    model: options?.model ?? { provider: "mock", model: "demo" },
+    provider,
+    instructions:
+      "You are a research planning agent. Given a research topic, produce a structured research plan breaking down the topic into targeted search queries.",
+  });
+}
+
+/**
+ * Creates the synthesis agent responsible for compiling findings into a cited report.
+ */
+export function createSynthesizerAgent(options?: {
+  readonly model?: { provider: string; model: string };
+  readonly provider?: import("@arnilo/prism").AIProvider;
+}): Agent {
+  const provider =
+    options?.provider ??
+    createMockProvider([
+      providerTextDelta(
+        "### Executive Summary\nPrism provides modular agent runtimes with durable workflows and verifiable web-tool citations.\n\n### Findings\n- Workflows execute deterministic DAG pipelines.\n- Web tools generate verifiable cryptographic citations.",
+      ),
+      providerDone(),
+    ]);
+
+  return createAgent({
+    model: options?.model ?? { provider: "mock", model: "demo" },
+    provider,
+    instructions:
+      "You are a research synthesis agent. Review the gathered research findings and compose a detailed, factual summary referencing the attributable citations.",
+  });
+}
+
+/**
+ * Default app agent export for `prism dev` and CLI inspector.
+ */
+export function createAppAgent(): Agent {
+  const adapter = createResearchSearchAdapter();
+  const tools = createResearchWebTools(adapter);
+
+  return createAgent({
+    model: { provider: "mock", model: "demo" },
+    provider: createMockProvider([
+      providerTextDelta("Deep Research Agent ready. Ask me to research any topic."),
+      providerDone(),
+    ]),
+    tools,
+    instructions:
+      "You are a Deep Research Assistant. You break down topics, search the web, refine evidence, and produce cited reports.",
+  });
+}

package/templates/deep-research/src/index.ts.tmpl

@@ -0,0 +1,53 @@
+import { createAppAgent, createPlannerAgent, createSynthesizerAgent } from "./agent.js";
+import { createClarifyTool, createResearchSearchAdapter, createResearchWebTools } from "./tools.js";
+import type { ResearchFinding, ResearchPlan, ResearchReport } from "./types.js";
+import { createResearchWorkflow, executeResearch } from "./workflow.js";
+
+export {
+  createAppAgent,
+  createPlannerAgent,
+  createSynthesizerAgent,
+  createResearchSearchAdapter,
+  createResearchWebTools,
+  createClarifyTool,
+  createResearchWorkflow,
+  executeResearch,
+  type ResearchPlan,
+  type ResearchFinding,
+  type ResearchReport,
+};
+
+export async function main() {
+  const topic = process.argv.slice(2).join(" ") || "Prism Agent Architecture";
+  console.log(`Starting deep research on: "${topic}"\n`);
+
+  const report = await executeResearch(topic, {
+    onEvent: (event) => {
+      if (event.type === "node_started") {
+        console.log(`  -> [${event.nodeId}] started...`);
+      } else if (event.type === "node_finished") {
+        console.log(`  ✓ [${event.nodeId}] finished`);
+      }
+    },
+  });
+
+  console.log("\n========================================================");
+  console.log(`RESEARCH REPORT: ${report.topic}`);
+  console.log("========================================================");
+  console.log(`\n${report.summary}\n`);
+  console.log("Key Findings:");
+  for (const f of report.findings) {
+    console.log(`- [${f.citationId}] ${f.title}`);
+    console.log(`  ${f.snippet}`);
+    console.log(`  Source: ${f.url}\n`);
+  }
+  console.log("Citations & References:");
+  for (const c of report.citations) {
+    console.log(`  [${c.citationId}] ${c.title} — ${c.url}`);
+  }
+  console.log("========================================================\n");
+}
+
+if (import.meta.url === `file://${process.argv[1]}`) {
+  await main();
+}

package/templates/deep-research/src/tests/research.test.ts.tmpl

@@ -0,0 +1,114 @@
+import assert from "node:assert/strict";
+import { describe, it } from "node:test";
+import { citation, createWebTools } from "@arnilo/prism-web-tools";
+import { createAppAgent, createPlannerAgent } from "../agent.js";
+import { createClarifyTool, createResearchSearchAdapter, formatResearchFindings } from "../tools.js";
+import { createResearchWorkflow, executeResearch } from "../workflow.js";
+
+describe("deep-research template", () => {
+  it("generates research plans with structured query breakdowns", async () => {
+    const planner = createPlannerAgent();
+    const session = planner.createSession({ id: "test-plan" });
+    const result = await session.run("Prism architecture");
+
+    assert.equal(result.status, "succeeded");
+    assert.ok(result.text.length > 0);
+    const plan = JSON.parse(result.text);
+    assert.ok(Array.isArray(plan.queries));
+    assert.ok(plan.queries.length >= 2);
+    assert.ok(plan.queries[0].query);
+    assert.ok(plan.queries[0].aspect);
+  });
+
+  it("produces attributable citations for search findings", async () => {
+    const customUrl = "https://docs.prism.ai/workflows";
+    const customCitation = citation("brave", customUrl);
+
+    const adapter = createResearchSearchAdapter({
+      searchFn: async (query) => [
+        {
+          ...customCitation,
+          title: `Custom result for ${query}`,
+          snippet: "Deterministic snippet for verification",
+          retrievedAt: "2026-08-31T00:00:00.000Z",
+        },
+      ],
+    });
+
+    const response = await adapter.search("workflows", { count: 1 });
+    assert.equal(response.results.length, 1);
+    const finding = formatResearchFindings("workflows", response.results)[0]!;
+
+    assert.equal(finding.url, customUrl);
+    assert.equal(finding.citationId, customCitation.citationId);
+    assert.ok(finding.citationId.startsWith("web:brave:"));
+    assert.equal(finding.title, "Custom result for workflows");
+  });
+
+  it("clarify tool executes human-in-the-loop decision resolution", async () => {
+    let receivedQuestion = "";
+    let receivedChoices: readonly string[] = [];
+
+    const tool = createClarifyTool({
+      onClarify: async (question, choices) => {
+        receivedQuestion = question;
+        receivedChoices = choices;
+        return choices[1]!; // select second choice
+      },
+    });
+
+    const context = {
+      toolCallId: "call-clarify-1",
+      sessionId: "session-1",
+    };
+
+    const result = await tool.execute(
+      {
+        question: "Which aspect of Prism should we focus on?",
+        choices: ["Orchestration DAGs", "Web Tools & Search", "RAG & Citations"],
+      },
+      context,
+    );
+
+    assert.equal(result.name, "clarify_research_scope");
+    assert.equal(receivedQuestion, "Which aspect of Prism should we focus on?");
+    assert.equal(receivedChoices.length, 3);
+    const val = result.value as { question: string; selectedOption: string };
+    assert.equal(val.selectedOption, "Web Tools & Search");
+  });
+
+  it("executes the full research workflow DAG offline within bounded limits", async () => {
+    const events: string[] = [];
+    const report = await executeResearch("Autonomous Agents", {
+      maxIterations: 2,
+      onEvent: (e) => events.push(e.type),
+    });
+
+    assert.ok(report);
+    assert.equal(report.topic, "Autonomous Agents");
+    assert.ok(report.findings.length >= 2);
+    assert.ok(report.citations.length >= 1);
+    assert.ok(report.summary.includes("Autonomous Agents"));
+
+    // Verify all findings carry valid, attributable citation IDs matching citations list
+    const citationIds = new Set(report.citations.map((c) => c.citationId));
+    for (const finding of report.findings) {
+      assert.ok(finding.citationId, "Finding must have a citation ID");
+      assert.ok(citationIds.has(finding.citationId), `Finding citationId ${finding.citationId} must be in report citations`);
+      assert.ok(finding.url.startsWith("https://"), "Finding must have a valid URL");
+    }
+
+    // Verify workflow lifecycle events
+    assert.ok(events.includes("node_started"));
+    assert.ok(events.includes("node_finished"));
+  });
+
+  it("default createAppAgent boots and exposes search tools", async () => {
+    const appAgent = createAppAgent();
+    const session = appAgent.createSession({ id: "app-test" });
+    const result = await session.run("Hello");
+
+    assert.equal(result.status, "succeeded");
+    assert.match(result.text, /Deep Research Agent ready/);
+  });
+});

package/templates/deep-research/src/tools.ts.tmpl

@@ -0,0 +1,86 @@
+import { type ToolDefinition, type ToolExecutionContext, type ToolResult } from "@arnilo/prism";
+import { citation, createWebTools, type WebSearchAdapter, type WebSearchResult } from "@arnilo/prism-web-tools";
+import type { ResearchFinding } from "./types.js";
+
+/**
+ * Creates search tools backed by web-tools with attributable citation IDs.
+ */
+export function createResearchSearchAdapter(options?: {
+  readonly searchFn?: (query: string) => Promise<readonly WebSearchResult[]>;
+}): WebSearchAdapter {
+  return {
+    provider: "brave",
+    search: async (query: string) => {
+      if (options?.searchFn) {
+        const results = await options.searchFn(query);
+        return { provider: "brave", query, results, untrusted: true };
+      }
+      // Offline fallback mock results with attributable citations
+      const url = `https://docs.prism.ai/research/${encodeURIComponent(query.toLowerCase().replace(/\s+/g, "-"))}`;
+      const baseCitation = citation("brave", url);
+      const mockResult: WebSearchResult = {
+        ...baseCitation,
+        title: `Research findings for ${query}`,
+        snippet: `Verified architectural overview and technical analysis regarding ${query}.`,
+        retrievedAt: new Date().toISOString(),
+      };
+      return { provider: "brave", query, results: [mockResult], untrusted: true };
+    },
+  };
+}
+
+
+/**
+ * Create web tools for the research agent.
+ */
+export function createResearchWebTools(adapter: WebSearchAdapter): readonly ToolDefinition[] {
+  return createWebTools({ search: adapter });
+}
+
+/**
+ * Normalizes raw search results into domain ResearchFindings with citations.
+ */
+export function formatResearchFindings(query: string, results: readonly WebSearchResult[]): readonly ResearchFinding[] {
+  return results.map((r) => ({
+    query,
+    title: r.title ?? "Untitled Resource",
+    snippet: r.snippet ?? "",
+    url: r.url,
+    citationId: r.citationId,
+    retrievedAt: r.retrievedAt ?? new Date().toISOString(),
+  }));
+}
+
+/**
+ * Simple Human-in-the-Loop clarify tool for resolving broad research topics.
+ */
+export function createClarifyTool(options: {
+  readonly onClarify?: (question: string, choices: readonly string[]) => Promise<string>;
+}): ToolDefinition {
+  return {
+    name: "clarify_research_scope",
+    description: "Propose clarification questions to the user when a research topic is broad or ambiguous.",
+    parameters: {
+      type: "object",
+      properties: {
+        question: { type: "string" },
+        choices: { type: "array", items: { type: "string" }, minItems: 2 },
+      },
+      required: ["question", "choices"],
+      additionalProperties: false,
+    },
+    execute: async (args: Record<string, unknown>, context: ToolExecutionContext): Promise<ToolResult> => {
+      const question = String(args.question ?? "");
+      const choices = Array.isArray(args.choices) ? (args.choices as string[]) : [];
+      let selected = choices[0] ?? "default";
+      if (options.onClarify) {
+        selected = await options.onClarify(question, choices);
+      }
+      return {
+        toolCallId: context.toolCallId,
+        name: "clarify_research_scope",
+        value: { question, selectedOption: selected },
+      };
+    },
+  };
+}

package/templates/deep-research/src/types.ts.tmpl

@@ -0,0 +1,45 @@
+/**
+ * Deep Research domain types and contracts.
+ */
+
+export interface ResearchQuery {
+  readonly query: string;
+  readonly rationale: string;
+  readonly aspect: string;
+}
+
+export interface ResearchPlan {
+  readonly topic: string;
+  readonly queries: readonly ResearchQuery[];
+  readonly clarifyQuestion?: string;
+  readonly clarifyOptions?: readonly string[];
+}
+
+export interface ResearchFinding {
+  readonly query: string;
+  readonly title: string;
+  readonly snippet: string;
+  readonly url: string;
+  readonly citationId: string;
+  readonly retrievedAt: string;
+}
+
+export interface ResearchCitation {
+  readonly citationId: string;
+  readonly url: string;
+  readonly title: string;
+}
+
+export interface ResearchReport {
+  readonly topic: string;
+  readonly summary: string;
+  readonly findings: readonly ResearchFinding[];
+  readonly citations: readonly ResearchCitation[];
+  readonly iterations: number;
+  readonly completedAt: string;
+}
+
+export interface ClarifyDecision {
+  readonly question: string;
+  readonly selectedOption: string;
+}

package/templates/deep-research/src/workflow.ts.tmpl

@@ -0,0 +1,156 @@
+import { createSecretRedactor } from "@arnilo/prism";
+import {
+  createMemoryWorkflowCheckpoints,
+  defineWorkflow,
+  functionNode,
+  runWorkflow,
+  type WorkflowDefinition,
+  type WorkflowEvent,
+} from "@arnilo/prism-workflows";
+import { createPlannerAgent, createSynthesizerAgent } from "./agent.js";
+import { createResearchSearchAdapter, formatResearchFindings } from "./tools.js";
+import type { ResearchCitation, ResearchFinding, ResearchPlan, ResearchReport } from "./types.js";
+
+export interface ResearchWorkflowOptions {
+  readonly maxIterations?: number;
+  readonly searchAdapter?: import("@arnilo/prism-web-tools").WebSearchAdapter;
+  readonly onEvent?: (event: WorkflowEvent) => void;
+  readonly onClarify?: (question: string, choices: readonly string[]) => Promise<string>;
+}
+
+/**
+ * Builds the deep research workflow DAG.
+ */
+export function createResearchWorkflow(options?: ResearchWorkflowOptions): WorkflowDefinition {
+  const maxIterations = options?.maxIterations ?? 2;
+  const searchAdapter = options?.searchAdapter ?? createResearchSearchAdapter();
+
+  const plan = functionNode({
+    execute: async (ctx) => {
+      const input = (ctx.workflowInput as { topic: string }) ?? { topic: "General Research" };
+      // Planning step: create initial structured plan
+      const planResult: ResearchPlan = {
+        topic: input.topic,
+        queries: [
+          { query: `${input.topic} overview and core architecture`, rationale: "Foundational concepts", aspect: "architecture" },
+          { query: `${input.topic} performance and security considerations`, rationale: "Production considerations", aspect: "security" },
+        ],
+      };
+      return planResult;
+    },
+  });
+
+  const search = functionNode({
+    execute: async (ctx) => {
+      const currentPlan = ctx.upstream.plan as ResearchPlan;
+      const findings: ResearchFinding[] = [];
+
+      for (const query of currentPlan.queries) {
+        const response = await searchAdapter.search(query.query, { count: 2, signal: ctx.signal });
+        const normalized = formatResearchFindings(query.query, response.results);
+        findings.push(...normalized);
+      }
+
+      return { findings };
+    },
+  });
+
+  const refine = functionNode({
+    execute: async (ctx) => {
+      const searchOutput = ctx.upstream.search as { findings: readonly ResearchFinding[] };
+      const currentFindings = [...searchOutput.findings];
+      let iterations = 1;
+
+      // Bounded refine loop: verify aspect coverage and execute additional queries if bounded budget allows
+      if (iterations < maxIterations && currentFindings.length < 4) {
+        iterations += 1;
+        const refineQuery = `${(ctx.upstream.plan as ResearchPlan).topic} best practices`;
+        const extra = await searchAdapter.search(refineQuery, { count: 1, signal: ctx.signal });
+        currentFindings.push(...formatResearchFindings(refineQuery, extra.results));
+      }
+
+      return { findings: currentFindings, iterations };
+    },
+  });
+
+  const synthesize = functionNode({
+    execute: async (ctx) => {
+      const planOutput = ctx.upstream.plan as ResearchPlan;
+      const refineOutput = ctx.upstream.refine as { findings: readonly ResearchFinding[]; iterations: number };
+      const findings = refineOutput.findings;
+
+      // Collect attributable citations
+      const citationsMap = new Map<string, ResearchCitation>();
+      for (const f of findings) {
+        if (!citationsMap.has(f.citationId)) {
+          citationsMap.set(f.citationId, {
+            citationId: f.citationId,
+            url: f.url,
+            title: f.title,
+          });
+        }
+      }
+
+      const citations = Array.from(citationsMap.values());
+      const summary = `Research completed on topic "${planOutput.topic}". Synthesized ${findings.length} findings across ${citations.length} verified sources.`;
+
+      const report: ResearchReport = {
+        topic: planOutput.topic,
+        summary,
+        findings,
+        citations,
+        iterations: refineOutput.iterations,
+        completedAt: new Date().toISOString(),
+      };
+
+      return report;
+    },
+  });
+
+  return defineWorkflow({
+    id: "deep-research-workflow",
+    revision: "1",
+    nodes: { plan, search, refine, synthesize },
+    edges: [
+      ["plan", "search"],
+      ["search", "refine"],
+      ["refine", "synthesize"],
+    ],
+    limits: {
+      maxConcurrency: 2,
+      maxFanOut: 4,
+      maxNodes: 16,
+      maxStateBytes: 65_536,
+    },
+  });
+}
+
+/**
+ * Execute the deep research workflow on a specified topic.
+ */
+export async function executeResearch(
+  topic: string,
+  options?: ResearchWorkflowOptions,
+): Promise<ResearchReport> {
+  const workflow = createResearchWorkflow(options);
+  const redactor = createSecretRedactor([]);
+  const checkpoints = createMemoryWorkflowCheckpoints({ redactor });
+
+  const result = await runWorkflow(
+    workflow,
+    { topic },
+    {
+      checkpoints,
+      redactor,
+      ownership: { tenantId: "research-session" },
+      signal: AbortSignal.timeout(60_000),
+      onEvent: options?.onEvent,
+    },
+  );
+
+  if (result.status !== "completed") {
+    throw new Error(`Research workflow did not complete successfully. Status: ${result.status}`);
+  }
+
+  return result.outputs.synthesize as ResearchReport;
+}

package/templates/deep-research/tsconfig.json.tmpl

@@ -0,0 +1,15 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "NodeNext",
+    "moduleResolution": "NodeNext",
+    "lib": ["ES2022"],
+    "outDir": "./dist",
+    "rootDir": "./src",
+    "strict": true,
+    "noImplicitOverride": true,
+    "skipLibCheck": true,
+    "forceConsistentCasingInFileNames": true
+  },
+  "include": ["src/**/*"]
+}

package/templates/init/manifest.json

@@ -0,0 +1,5 @@
+{
+  "name": "init",
+  "description": "Minimal starter Prism agent with one selected provider and offline mock test",
+  "version": "0.1.0"
+}

package/templates/init/package.json.tmpl

@@ -7,7 +7,8 @@
     "build": "tsc -p tsconfig.json",
     "typecheck": "tsc -p tsconfig.json --noEmit",
     "test": "npm run build && node --test dist/__tests__/agent.test.js",
-    "start": "npm run build && node dist/index.js"
+    "start": "npm run build && node dist/index.js",
+    "dev": "prism dev"
   },
   "dependencies": {
 __DEPENDENCIES__