littleblacky/agenticforge/agenticforge-vibe-coding

@agenticforge/kit          — all-in-one re-export, use for quick prototypes
@agenticforge/core         — LLMClient, Agent base, Message, Config, hooks API
@agenticforge/tools        — Tool, FunctionTool, toolAction, ToolRegistry, ToolChain
@agenticforge/agents       — FunctionCallAgent, ReActAgent, PlanSolveAgent,
                             ReflectionAgent, SimpleAgent, SkillAgent, WorkflowAgent
@agenticforge/workflow     — WorkflowEngine, WorkflowDefinition, WorkflowNode types
@agenticforge/skills       — AgentSkill, SkillRegistry, SkillRunner,
                             MarkdownSkill, SkillLoader
@agenticforge/memory       — MemoryManager, WorkingMemory, EpisodicMemory,
                             SemanticMemory, InMemoryVectorStore, InMemoryKVStore
@agenticforge/tools-builtin — SearchTool, MemoryTool, NoteTool, RAGTool, TerminalTool
@agenticforge/context      — ContextBuilder
@agenticforge/protocols    — A2AClient, A2AServer, MCPClient, MCPServer

import { Tool, toolAction } from "@agenticforge/tools";
import { z } from "zod";
const myTool = new Tool({
  name: "tool-name",
  description: "What this tool does — be specific for LLM routing",
  parameters: [{ name: "param", type: "string", required: true }],
  action: toolAction(
    z.object({ param: z.string() }),
    async ({ param }) => {
      // implementation
      return `result: ${param}`;
    }
  ),
});

import "dotenv/config";
import { FunctionCallAgent, LLMClient } from "@agenticforge/kit";
const agent = new FunctionCallAgent({
  llm: new LLMClient({ provider: "openai", model: "gpt-4o" }),
  tools: [myTool],
  systemPrompt: "You are a helpful assistant.",
  maxIterations: 10,
});
const result = await agent.run("user query here");
console.log(result);

import { SkillAgent } from "@agenticforge/agents";
import { SkillLoader } from "@agenticforge/skills";
import { LLMClient } from "@agenticforge/core";
const llm = new LLMClient({ provider: "openai", model: "gpt-4o" });
const skills = await SkillLoader.fromDirectory(".cursor/skills");
const agent = new SkillAgent({ name: "assistant", llm, skills });
const reply = await agent.run("user query");

import { createRagPipeline, InMemoryVectorStore } from "@agenticforge/kit";
// For production: import { QdrantVectorStore } from "@agenticforge/memory";
const vectorStore = new InMemoryVectorStore();
const rag = createRagPipeline({ store: vectorStore, ragNamespace: "docs" });
await rag.ingest([{ content: "doc text", metadata: { source: "file.md" } }]);
const results = await rag.retrieve("query", { topK: 5 });

---
name: skill-name           # kebab-case, unique
description: One sentence — what this skill does and when to use it
triggerHint: Specific user phrasing that should trigger this skill
---
 
# Skill Title
 
## Role
You are [specific persona]. [Core constraint in one sentence].
 
## When to activate
-[trigger pattern 1]
-[trigger pattern 2]
 
## Rules
-[concrete rule 1]
-[concrete rule 2]
-Do NOT [what to avoid].
 
## Output format
[How to structure the response]

const agent = new SimpleAgent({ llm, systemPrompt: "..." });
await agent.run("first message");   // history auto-tracked
await agent.run("follow-up");       // context preserved
agent.clearHistory();               // reset

import { createConsoleLoggingHook, MetricsHook } from "@agenticforge/core";
const metrics = new MetricsHook();
agent
  .useHook(createConsoleLoggingHook({ events: ["afterRun", "onError"] }))
  .useHook(metrics.hook);
console.log(metrics.getSnapshot());

import { ToolChain } from "@agenticforge/tools";
const chain = new ToolChain([searchTool, summarizeTool, noteTool]);
const result = await chain.run({ query: "research topic" });

import { AsyncToolExecutor } from "@agenticforge/tools";
const executor = new AsyncToolExecutor([tool1, tool2, tool3]);
const results = await executor.runAll({ input: "..." });

import { SkillRunner, AgentSkill } from "@agenticforge/skills";
const runner = new SkillRunner({ llm, skills: [skill1, skill2] });
const { output } = await runner.run("query");
// Direct call — bypasses routing:
const { output } = await runner.runSkill("skill-name", "query");

import { ContextBuilder } from "@agenticforge/context";
const ctx = new ContextBuilder({ maxTokens: 4096 });
ctx.addSystem(systemPrompt);
ctx.addHistory(conversationHistory);
ctx.addUser(userQuery);
const messages = ctx.build(); // guaranteed to fit in window

import { A2AServer, A2AClient } from "@agenticforge/protocols";
// Server side
const server = new A2AServer({ agent: myAgent, port: 3001 });
await server.start();
// Client side
const client = new A2AClient({ url: "http://localhost:3001" });
const result = await client.run("delegate this task");