import { Mandu } from "@mandujs/core";

export default Mandu.filling()
  .guard((ctx) => {
    if (!ctx.get("user")) return ctx.unauthorized("Login required");
  })
  .get(async (ctx) => {
    const users = await db.users.findMany();
    return ctx.ok({ data: users });
  })
  .post(async (ctx) => {
    const body = await ctx.body<{ name: string }>();
    const user = await db.users.create({ data: body });
    return ctx.created({ data: user });
  });

import { Mandu } from "@mandujs/core";
import { z } from "zod";

const userContract = Mandu.contract({
  request: {
    GET: { query: z.object({ id: z.string() }) },
    POST: { body: z.object({ name: z.string() }) }
  },
  response: {
    200: z.object({ data: z.any() }),
    400: z.object({ error: z.string() })
  }
});

const handlers = Mandu.handler(userContract, {
  GET: (ctx) => ({ data: fetchUser(ctx.query.id) }),
  POST: (ctx) => ({ data: createUser(ctx.body) })
});

import { scanRoutes, generateManifest, watchFSRoutes } from "@mandujs/core/router";

// Scan routes from app/ directory
const result = await scanRoutes("/path/to/project");
console.log(result.routes);

// Generate manifest
const { manifest } = await generateManifest("/path/to/project", {
  outputPath: ".mandu/manifest.json"
});

// Watch for changes
const watcher = await watchFSRoutes("/path/to/project", {
  onChange: (result) => console.log("Routes updated!", result.routes.length)
});

import { pathToPattern, parseSegments } from "@mandujs/core/router";

// Convert path to URL pattern
pathToPattern("users/[id]/posts");     // → "/users/:id/posts"
pathToPattern("docs/[...slug]");       // → "/docs/:slug*"
pathToPattern("(auth)/login");         // → "/login" (group ignored)

// Parse segments
parseSegments("[id]");                 // → [{ type: "dynamic", name: "id" }]
parseSegments("[...slug]");            // → [{ type: "catch-all", name: "slug" }]

import {
  createGuardWatcher,
  checkDirectory,
  getPreset,
  listPresets
} from "@mandujs/core/guard";

// One-time check
const report = await checkDirectory(
  { preset: "mandu" },
  process.cwd()
);
console.log(`Violations: ${report.totalViolations}`);

// Real-time watching
const watcher = createGuardWatcher({
  config: { preset: "mandu", srcDir: "src" },
  rootDir: process.cwd(),
  onViolation: (v) => console.log(`${v.filePath}: ${v.ruleDescription}`),
});
watcher.start();

// List available presets
listPresets().forEach(p => console.log(p.name, p.description));

import { extractImportsAST, analyzeModuleAST } from "@mandujs/core/guard";

// Extract imports with AST (more accurate than regex)
const imports = extractImportsAST(code);
// → [{ path: "./utils", type: "static", line: 1, namedImports: ["foo"] }]

// Full module analysis
const analysis = analyzeModuleAST(code, "src/features/user/api.ts");

import {
  createScanRecord,
  addScanRecord,
  analyzeTrend,
  generateGuardMarkdownReport
} from "@mandujs/core/guard";

// Save scan for trend analysis
const record = createScanRecord(report, "mandu");
await addScanRecord(rootDir, record);

// Analyze improvement trend
const trend = analyzeTrend(records, 7); // 7 days
console.log(trend.trend); // "improving" | "stable" | "degrading"

// Generate reports
const markdown = generateGuardMarkdownReport(report, trend);

import { checkWithHealing, healAll, explainRule } from "@mandujs/core/guard";

// Detect violations with fix suggestions
const result = await checkWithHealing({ preset: "mandu" }, process.cwd());

// Auto-fix all fixable violations
if (result.items.length > 0) {
  const healResult = await healAll(result);
  console.log(`Fixed: ${healResult.fixed}, Failed: ${healResult.failed}`);
}

// Explain any rule
const explanation = explainRule("layer-dependency");
console.log(explanation.description, explanation.examples);

import {
  searchDecisions,
  saveDecision,
  checkConsistency,
  getCompactArchitecture
} from "@mandujs/core/guard";

// Search past decisions
const results = await searchDecisions(rootDir, ["auth", "jwt"]);

// Save new decision (ADR)
await saveDecision(rootDir, {
  id: "ADR-002",
  title: "Use PostgreSQL",
  status: "accepted",
  context: "Need relational database",
  decision: "Use PostgreSQL with Drizzle ORM",
  consequences: ["Need to manage migrations"],
  tags: ["database", "orm"]
});

// Check implementation consistency
const consistency = await checkConsistency(rootDir);

import { negotiate, generateScaffold } from "@mandujs/core/guard";

// AI negotiates with framework before implementation
const plan = await negotiate({
  intent: "Add user authentication",
  requirements: ["JWT based", "Refresh tokens"],
  constraints: ["Use existing User model"]
}, projectRoot);

if (plan.approved) {
  // Generate scaffold files
  await generateScaffold(plan.structure, projectRoot);
}

import { Mandu } from "@mandujs/core";

export default Mandu.filling()
  // Lifecycle hooks
  .onRequest((ctx) => {
    ctx.set("requestId", crypto.randomUUID());
  })

  // Guard (return Response to block)
  .guard((ctx) => {
    if (!ctx.get("user")) return ctx.unauthorized("Login required");
  })

  // Handlers
  .get(async (ctx) => {
    return ctx.ok({ users: await fetchUsers() });
  })

  .post(async (ctx) => {
    const body = await ctx.body();
    return ctx.created({ user: await createUser(body) });
  })

  // After response
  .afterResponse((ctx) => {
    console.log("Request completed:", ctx.get("requestId"));
  });

export default Mandu.filling()
  .middleware(async (ctx, next) => {
    console.log("before");
    await next();
    console.log("after");
  })
  .get((ctx) => ctx.ok({ ok: true }));

import { Mandu } from "@mandujs/core";
import { z } from "zod";

// Define contract
const userContract = Mandu.contract({
  request: {
    GET: { query: z.object({ id: z.string() }) },
    POST: { body: z.object({ name: z.string() }) }
  },
  response: {
    200: z.object({ data: z.any() }),
    400: z.object({ error: z.string() })
  }
});

// Create typed handlers
const handlers = Mandu.handler(userContract, {
  GET: (ctx) => ({ data: fetchUser(ctx.query.id) }),
  POST: (ctx) => ({ data: createUser(ctx.body) })
});

  // Type-safe client
  const client = Mandu.client(userContract, { baseUrl: "/api/users" });
  const result = await client.GET({ query: { id: "123" } });

const clientContract = Mandu.clientContract(userContract, {
  request: {
    POST: { body: true },
  },
  response: [201],
  includeErrors: true,
});

const client = Mandu.client(clientContract, { baseUrl: "/api/users" });

import { startServer, registerApiHandler, registerPageLoader } from "@mandujs/core";

// Register handlers
registerApiHandler("getUsers", async (req) => ({ users: [] }));
registerPageLoader("home", () => import("./pages/Home"));

// Start server
const server = startServer(manifest, { port: 3000 });

import { renderToStream } from "@mandujs/core";

const stream = await renderToStream(<App />, {
  bootstrapScripts: ["/client.js"],
  onError: (err) => console.error(err)
});

import { createIsland, partial } from "@mandujs/core/client";

// Define island
const CounterIsland = createIsland({
  name: "counter",
  component: Counter,
  priority: "visible"
});

// Partial (smaller than island)
const ButtonPartial = partial("submit-btn", SubmitButton);

import { useRouter, useParams, Link, NavLink } from "@mandujs/core/client";

function Navigation() {
  const router = useRouter();
  const params = useParams();

  return (
    <nav>
      <NavLink href="/users" activeClass="active">Users</NavLink>
      <button onClick={() => router.push("/settings")}>Settings</button>
    </nav>
  );
}

// content.config.ts
import { defineContentConfig, glob, file, api } from "@mandujs/core/content";
import { z } from "zod";

const postSchema = z.object({
  title: z.string(),
  date: z.coerce.date(),
  tags: z.array(z.string()).default([]),
});

export default defineContentConfig({
  collections: {
    // Markdown files with frontmatter
    posts: {
      loader: glob({ pattern: "content/posts/**/*.md" }),
      schema: postSchema,
    },
    // Single JSON/YAML file
    settings: {
      loader: file({ path: "data/settings.json" }),
    },
    // External API
    products: {
      loader: api({
        url: "https://api.example.com/products",
        headers: () => ({ Authorization: `Bearer ${process.env.API_KEY}` }),
        cacheTTL: 3600,
      }),
    },
  },
});

import { getCollection, getEntry } from "@mandujs/core/content";

// Get all entries
const posts = await getCollection("posts");
posts.forEach(post => {
  console.log(post.id, post.data.title);
});

// Get single entry
const post = await getEntry("posts", "hello-world");
console.log(post?.data.title, post?.body);

import {
  initializeBrain,
  getBrain,
  analyzeViolations,
  initializeArchitectureAnalyzer
} from "@mandujs/core";

// Initialize
await initializeBrain();
const brain = getBrain();

// Analyze violations with suggestions
const analysis = await analyzeViolations(violations, { useLLM: true });
console.log(analysis.patches); // Suggested fixes

// Architecture analyzer
const analyzer = initializeArchitectureAnalyzer(rootDir);
const locationResult = await analyzer.checkLocation({ path: "src/features/user.ts" });
const importResult = await analyzer.checkImports({
  sourceFile: "src/features/user.ts",
  imports: ["../entities/product"]
});

import { buildClientBundle, createDevBundler } from "@mandujs/core/bundler";

// Production build
const result = await buildClientBundle(manifest, {
  outDir: ".mandu/client",
  minify: true,
  sourcemap: true
});

// Development with HMR
const devBundler = await createDevBundler(manifest, {
  rootDir: process.cwd(),
  isDev: true
});

import { beginChange, commitChange, rollbackChange } from "@mandujs/core";

// Start transaction
const { changeId, snapshotId } = await beginChange(rootDir, "Add user API");

// Make changes...

// Commit or rollback
await commitChange(rootDir);
// or
await rollbackChange(rootDir);

import type {
  // Spec
  RoutesManifest,
  RouteSpec,

  // Guard
  GuardPreset,
  GuardConfig,
  Violation,
  ViolationReport,

  // Router
  ScanResult,
  FSRouteConfig,

  // Contract
  ContractDefinition,
  ContractHandlers,

  // Filling
  ManduContext,

  // Content Layer
  DataEntry,
  ContentConfig,
  CollectionConfig,
  Loader,
  LoaderContext,
} from "@mandujs/core";