diff --git a/.gitignore b/.gitignore index 251a0b3..b977a4e 100644 --- a/.gitignore +++ b/.gitignore @@ -5,6 +5,7 @@ node_modules/ .pnpm-store/ dist/ +.astro/ coverage/ *.tsbuildinfo diff --git a/CHANGELOG.md b/CHANGELOG.md index 731e300..ff70e2b 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -17,7 +17,7 @@ Initial open-source MVP. - Added clean and broken TypeScript demo projects. - Added S-Agent dogfood architecture rules in `rules/s-agent-architecture.rules.yml`. - Added evaluation fixtures, precision/recall/false-positive benchmarks, and a 50-case synthetic dataset. -- Added product strategy docs for IntentGuard positioning, ICPs, pricing, messaging, and customer discovery. +- Added product strategy docs for AxiomGuard positioning, ICPs, pricing, messaging, and customer discovery. - Added release CI for install, build, test, lint, rule validation, clean demo analysis, and self-analysis. - Added Apache-2.0 licensing, open-core documentation, governance, contribution, security, and code of conduct docs. - Added GitHub issue templates, a pull request template, and community roadmap docs. diff --git a/GOVERNANCE.md b/GOVERNANCE.md index 4e52c40..e6d0fb7 100644 --- a/GOVERNANCE.md +++ b/GOVERNANCE.md @@ -92,7 +92,7 @@ Large roadmap items should start as design issues before implementation. ## Open-core boundary -S-Agent Core contains the open-source semantic analysis engine. IntentGuard +S-Agent Core contains the open-source semantic analysis engine. AxiomGuard Pro and Enterprise may contain future hosted, team, governance, and enterprise features. diff --git a/OPEN_CORE.md b/OPEN_CORE.md index 0e0865a..05c6b07 100644 --- a/OPEN_CORE.md +++ b/OPEN_CORE.md @@ -1,7 +1,7 @@ # Open-core model S-Agent Core is the open-source semantic analysis engine for intent-aware -code review. IntentGuard Pro and Enterprise will be commercial products built +code review. AxiomGuard Pro and Enterprise will be commercial products built on top of S-Agent Core for team workflows, governance, automation, dashboards, and enterprise deployment. @@ -32,9 +32,9 @@ S-Agent Core includes: - Local and basic CI usage. - A planned basic GitHub Action. -## What is IntentGuard Pro / Enterprise? +## What is AxiomGuard Pro / Enterprise? -IntentGuard is the future commercial platform built on top of S-Agent Core. +AxiomGuard is the future commercial platform built on top of S-Agent Core. It is intended for teams and organizations that need shared workflows around semantic code review. @@ -87,7 +87,7 @@ automation, enterprise deployment, and advanced organization-level workflows. The boundary is simple: - S-Agent Core owns the local semantic analysis engine. -- IntentGuard Pro / Enterprise owns hosted and team-oriented platform features. +- AxiomGuard Pro / Enterprise owns hosted and team-oriented platform features. ## Why open-core? diff --git a/README.md b/README.md index 3096108..e45b415 100644 --- a/README.md +++ b/README.md @@ -4,7 +4,7 @@ S-Agent is an open-source semantic analysis engine for intent-aware code review. It checks whether TypeScript code changes preserve approved business and architectural intent. -IntentGuard is the future commercial platform built on top of S-Agent Core for +AxiomGuard is the future commercial platform built on top of S-Agent Core for team workflows and enterprise governance. ## Translations @@ -243,7 +243,7 @@ not be moved behind a paywall. S-Agent Core is the open-source semantic analysis engine. -IntentGuard Pro and Enterprise may later add team and organization workflows on +AxiomGuard Pro and Enterprise may later add team and organization workflows on top of the core, such as: - hosted dashboard; @@ -307,7 +307,7 @@ Read the full [open-core model](OPEN_CORE.md). - v0.2: basic GitHub Action mode. - v0.3: community rule packs and more framework examples. - v0.4: plugin API draft and extension-point design. -- Future: IntentGuard Pro alpha for team workflows and governance. +- Future: AxiomGuard Pro alpha for team workflows and governance. See the [community roadmap](docs/community/community-roadmap.md). diff --git a/SECURITY.md b/SECURITY.md index 2ac70a0..c94b9f3 100644 --- a/SECURITY.md +++ b/SECURITY.md @@ -52,7 +52,7 @@ Security reports may include: - report generation issues that could expose data unexpectedly; - rule parsing or validation issues with security impact. -Future commercial IntentGuard services will have separate security processes +Future commercial AxiomGuard services will have separate security processes when they exist. ## Dependency security diff --git a/apps/site/astro.config.mjs b/apps/site/astro.config.mjs new file mode 100644 index 0000000..d953ba5 --- /dev/null +++ b/apps/site/astro.config.mjs @@ -0,0 +1,8 @@ +import { defineConfig } from "astro/config"; + +const site = process.env.SITE_URL ?? "https://axiomguard.dev"; + +export default defineConfig({ + output: "static", + site +}); diff --git a/apps/site/package.json b/apps/site/package.json new file mode 100644 index 0000000..9726697 --- /dev/null +++ b/apps/site/package.json @@ -0,0 +1,16 @@ +{ + "name": "@s-agent/site", + "version": "0.1.0", + "private": true, + "description": "Astro landing page for AxiomGuard, powered by S-Agent.", + "type": "module", + "scripts": { + "dev": "astro dev --host 127.0.0.1", + "build": "astro build", + "preview": "astro preview --host 127.0.0.1", + "test": "vitest run --root ../.. apps/site/src" + }, + "devDependencies": { + "astro": "^5.13.0" + } +} diff --git a/apps/site/public/llms.txt b/apps/site/public/llms.txt new file mode 100644 index 0000000..39ebdbd --- /dev/null +++ b/apps/site/public/llms.txt @@ -0,0 +1,27 @@ +# AxiomGuard + +> AxiomGuard is an intent-aware code review tool that turns approved engineering docs, ADRs, and project rules into deterministic pull request checks for TypeScript teams. + +AxiomGuard is powered by S-Agent Core, an open-source semantic analysis engine. Blocking findings require approved SemanticRules, deterministic symbolic evidence, and PROVEN status. + +Source repository: https://github.com/hemp-dev/s-agent + +## Useful answers + +- AxiomGuard checks whether pull requests preserve documented business and architecture intent. +- Intent-aware code review catches changes that compile and pass tests but violate approved rules. +- The MVP is TypeScript-first and focuses on layer boundaries, forbidden side effects, and value invariants. +- LLMs may suggest candidate rules or explanations later, but they are not the source of truth for blocking. +- Only PROVEN findings from approved critical rules in block mode can stop a merge. + +## Public paths + +- [Landing page](/) +- [Semantic code review](/semantic-code-review) +- [Intent-aware code review](/intent-aware-code-review) +- [AI code review guardrails](/ai-code-review-guardrails) +- [Architecture drift prevention](/architecture-drift-prevention) +- [Business logic regression prevention](/business-logic-regression-prevention) +- [Source repository](https://github.com/hemp-dev/s-agent) +- [Sitemap](/sitemap.xml) +- [Robots policy](/robots.txt) diff --git a/apps/site/public/og/axiomguard-og.png b/apps/site/public/og/axiomguard-og.png new file mode 100644 index 0000000..6eb250b Binary files /dev/null and b/apps/site/public/og/axiomguard-og.png differ diff --git a/apps/site/public/og/axiomguard-og.svg b/apps/site/public/og/axiomguard-og.svg new file mode 100644 index 0000000..aa8bd11 --- /dev/null +++ b/apps/site/public/og/axiomguard-og.svg @@ -0,0 +1,38 @@ + + AxiomGuard intent-aware code review + Open graph image for AxiomGuard, a deterministic code review guard for TypeScript pull requests. + + + + + + + + + + + + + AG + AxiomGuard + powered by S-Agent + + Intent-Aware Code Review + Protect business + intent in every + code change. + Approved rules. Symbolic evidence. Proof. + + + + SemanticRule + status: approved + evidence: PROVEN + action: block + + + + TypeScript PR guardrails + for architecture and business rules + + diff --git a/apps/site/public/robots.txt b/apps/site/public/robots.txt new file mode 100644 index 0000000..0a59098 --- /dev/null +++ b/apps/site/public/robots.txt @@ -0,0 +1,27 @@ +# Public landing page crawl policy. + +User-agent: * +Allow: / + +User-agent: GPTBot +Allow: / + +User-agent: ChatGPT-User +Allow: / + +User-agent: PerplexityBot +Allow: / + +User-agent: ClaudeBot +Allow: / + +User-agent: anthropic-ai +Allow: / + +User-agent: Google-Extended +Allow: / + +User-agent: Bingbot +Allow: / + +Sitemap: https://axiomguard.dev/sitemap.xml diff --git a/apps/site/src/content/landing.test.ts b/apps/site/src/content/landing.test.ts new file mode 100644 index 0000000..821e1d3 --- /dev/null +++ b/apps/site/src/content/landing.test.ts @@ -0,0 +1,136 @@ +import { existsSync } from "node:fs"; +import path from "node:path"; +import { describe, expect, it } from "vitest"; +import { + answerBlocks, + comparisonRows, + faqItems, + findingStatuses, + heroDefinition, + pageMetadata, + proofChain, + realDemo, + realDemoReports, + realDemoSteps, + siteMetadata, + violationTypes, + workflowSteps +} from "./landing"; +import { seoClusterPages, seoClusterSlugs } from "./seo-pages"; + +const repoRoot = path.resolve(__dirname, "../../../.."); + +describe("landing content", () => { + it("keeps the documented finding statuses visible on the landing page", () => { + expect(findingStatuses.map((item) => item.status)).toEqual([ + "PROVEN", + "PROBABLE", + "SUSPECT", + "RULE_CONFLICT", + "DISMISSED" + ]); + }); + + it("states that only proven findings can block", () => { + const blockingStatuses = findingStatuses.filter((item) => item.effect === "Can block"); + + expect(blockingStatuses).toHaveLength(1); + expect(blockingStatuses[0]?.status).toBe("PROVEN"); + }); + + it("presents the MVP around the approved symbolic checks", () => { + expect(violationTypes.map((item) => item.title)).toEqual([ + "Layer Boundary", + "Forbidden Side Effect", + "Value Invariant" + ]); + expect(proofChain).toContain("SemanticRule YAML"); + }); + + it("keeps extractable answer content for AEO surfaces", () => { + expect(pageMetadata.description).toContain("intent-aware code review tool"); + expect(pageMetadata.lastUpdated).toMatch(/^\d{4}-\d{2}-\d{2}$/); + expect(siteMetadata.productionUrl).toBe("https://axiomguard.dev"); + expect(siteMetadata.githubUrl).toBe("https://github.com/hemp-dev/s-agent"); + expect(siteMetadata.ogImagePath).toBe("/og/axiomguard-og.png"); + expect(existsSync(path.resolve(repoRoot, "apps/site/public", siteMetadata.ogImagePath.slice(1)))).toBe( + true + ); + expect(heroDefinition).toContain("TypeScript PRs"); + expect(answerBlocks).toHaveLength(3); + expect(answerBlocks[0]?.title).toBe("What is AxiomGuard?"); + expect(answerBlocks[0]?.body).toContain("proof-carrying findings"); + }); + + it("keeps public brand content pointed at the official repository", () => { + const legacyBrand = ["Intent", "Guard"].join(""); + const legacyRepoPath = [ + ["muthukumar", "js", "dev"].join("-"), + ["intent", "guard"].join("-") + ].join("/"); + const publicContent = JSON.stringify({ + answerBlocks, + faqItems, + heroDefinition, + pageMetadata, + realDemo, + seoClusterPages, + siteMetadata, + workflowSteps + }); + + expect(publicContent).toContain("AxiomGuard"); + expect(publicContent).toContain("https://github.com/hemp-dev/s-agent"); + expect(publicContent).not.toContain(legacyBrand); + expect(publicContent).not.toContain(legacyRepoPath); + }); + + it("keeps the real demo tied to checked-in fixtures and CLI output", () => { + expect(realDemo.fixturePath).toBe("examples/demo-typescript-app"); + expect(realDemo.cleanFixturePath).toBe("examples/demo-typescript-app-clean"); + expect(realDemo.brokenCommand).toBe("pnpm analyze:demo:broken"); + expect(realDemo.cleanCommand).toBe("pnpm analyze:demo"); + expect(realDemoSteps.map((step) => step.path)).toEqual([ + "examples/demo-typescript-app/CLAUDE.md", + "examples/demo-typescript-app/rules/auth.rules.yml", + "examples/demo-typescript-app/src/auth/session.ts", + "apps/cli" + ]); + expect(realDemoReports[0]?.lines).toContain("Status: PROVEN"); + expect(realDemoReports[0]?.lines).toContain("Blocking: yes"); + expect(realDemoReports[1]?.lines).toContain("No findings."); + + const demoPaths = [ + realDemo.fixturePath, + realDemo.cleanFixturePath, + ...realDemoSteps.map((step) => step.path) + ]; + + expect(demoPaths.every((demoPath) => existsSync(path.resolve(repoRoot, demoPath)))).toBe( + true + ); + }); + + it("keeps FAQ and comparison content visible for search snippets", () => { + expect(faqItems.map((item) => item.question)).toContain("What can block a pull request?"); + expect(comparisonRows.map((item) => item.alternative)).toEqual([ + "SAST", + "Linters", + "AI reviewers", + "Architecture tools" + ]); + expect(workflowSteps).toHaveLength(4); + }); + + it("defines the SEO cluster pages requested for forced promotion", () => { + expect(seoClusterSlugs).toEqual([ + "semantic-code-review", + "intent-aware-code-review", + "ai-code-review-guardrails", + "architecture-drift-prevention", + "business-logic-regression-prevention" + ]); + expect(seoClusterPages.every((page) => page.faq.length >= 2)).toBe(true); + expect(seoClusterPages.every((page) => page.definition.includes("AxiomGuard"))).toBe(true); + }); +}); diff --git a/apps/site/src/content/landing.ts b/apps/site/src/content/landing.ts new file mode 100644 index 0000000..9eed978 --- /dev/null +++ b/apps/site/src/content/landing.ts @@ -0,0 +1,318 @@ +export const brand = { + product: "AxiomGuard", + engine: "S-Agent", + category: "Intent-Aware Code Review", + headline: "Protect business intent in every code change.", + subheadline: + "Turn approved engineering docs, ADRs, and project rules into deterministic pull request checks before intent drift reaches main." +} as const; + +export const pageMetadata = { + title: "AxiomGuard - Intent-Aware Code Review for TypeScript PRs", + description: + "AxiomGuard is an intent-aware code review tool that turns approved engineering docs into deterministic TypeScript pull request checks with proof-carrying findings.", + lastUpdated: "2026-05-09" +} as const; + +export const siteMetadata = { + productionUrl: "https://axiomguard.dev", + githubUrl: "https://github.com/hemp-dev/s-agent", + ogImagePath: "/og/axiomguard-og.png" +} as const; + +export const heroDefinition = + "AxiomGuard is an intent-aware code review guard for TypeScript PRs that turns approved rules into proof-carrying checks." as const; + +export const answerBlocks = [ + { + title: "What is AxiomGuard?", + body: + "AxiomGuard is an intent-aware code review tool for engineering teams that need pull requests to preserve approved business and architecture rules. It turns SemanticRule YAML into deterministic TypeScript checks and reports proof-carrying findings reviewers can audit." + }, + { + title: "What is intent-aware code review?", + body: + "Intent-aware code review verifies whether a code change preserves documented business, product, and architecture intent. It catches changes that compile and pass tests but still violate approved rules such as module boundaries, side-effect limits, or value thresholds." + }, + { + title: "Who is it for?", + body: + "AxiomGuard is built for TypeScript-heavy teams using AI coding tools, large refactors, or fast-moving product engineering workflows. It is most useful when important rules live in ADRs, READMEs, CLAUDE.md, or senior engineers' repeated review comments." + } +] as const; + +export const proofChain = [ + "CLAUDE.md", + "SemanticRule YAML", + "TypeScript diff", + "Symbolic evidence", + "CLI / PR gate" +] as const; + +export const workflowSteps = [ + { + title: "Start with docs", + body: + "Use CLAUDE.md, READMEs, ADRs, and architecture notes as source material for candidate rules." + }, + { + title: "Approve SemanticRules", + body: + "A human approves explicit YAML rules. The approved SemanticRule file becomes the source of truth." + }, + { + title: "Check every PR", + body: + "AxiomGuard indexes TypeScript code, analyzes imports and functions, verifies findings, and prints a proof-carrying report." + }, + { + title: "Block only proof", + body: + "Only PROVEN findings from approved critical rules in block mode can stop a merge." + } +] as const; + +export const realDemo = { + title: "Run the repo's real TypeScript demo.", + body: + "The landing demo uses the same fixture shipped in this repository: a CLAUDE.md rule, an approved SemanticRule, a TypeScript import violation, and the CLI report that blocks only after symbolic proof.", + fixturePath: "examples/demo-typescript-app", + cleanFixturePath: "examples/demo-typescript-app-clean", + brokenCommand: "pnpm analyze:demo:broken", + cleanCommand: "pnpm analyze:demo" +} as const; + +export const realDemoSteps = [ + { + label: "CLAUDE.md", + title: "Documented intent", + path: "examples/demo-typescript-app/CLAUDE.md", + lines: [ + "The authentication layer is identity-only.", + "It must not import billing code or trigger billing side effects directly." + ] + }, + { + label: "SemanticRule", + title: "Approved guardrail", + path: "examples/demo-typescript-app/rules/auth.rules.yml", + lines: [ + "rule_id: INV-AUTH-001", + "status: approved", + "severity: critical", + "from: src/auth/**", + "to: src/billing/**", + "mode: block" + ] + }, + { + label: "TypeScript change", + title: "Violating edge", + path: "examples/demo-typescript-app/src/auth/session.ts", + lines: [ + 'import { BillingService } from "../billing/billing-service";', + "const billing = new BillingService();", + 'billing.recordSessionStart({ userId, reason: "auth-started" });' + ] + }, + { + label: "Proof", + title: "Blocking evidence", + path: "apps/cli", + lines: [ + "Changed file: src/auth/session.ts", + "Evidence: import edge auth -> billing", + "Status: PROVEN", + "Severity: critical", + "Blocking: yes" + ] + } +] as const; + +export const violationTypes = [ + { + title: "Layer Boundary", + rule: "auth must not import billing", + example: "import { charge } from '../billing/service'", + accent: "blue" + }, + { + title: "Forbidden Side Effect", + rule: "read-only flows must not write", + example: "await db.invoice.update(...)", + accent: "red" + }, + { + title: "Value Invariant", + rule: "discount cannot exceed max", + example: "discount = 0.85", + accent: "green" + } +] as const; + +export const comparisonRows = [ + { + alternative: "SAST", + checks: "Security vulnerability patterns", + adds: "Product and architecture intent, such as billing boundaries and domain invariants" + }, + { + alternative: "Linters", + checks: "Style, syntax, and generic code-quality rules", + adds: "Team-specific business rules backed by approved documentation" + }, + { + alternative: "AI reviewers", + checks: "Broad contextual suggestions and plausible concerns", + adds: "Deterministic blocking only when approved rules produce symbolic evidence" + }, + { + alternative: "Architecture tools", + checks: "Dependencies, packages, and structural drift", + adds: "PR-level reports tied to documented business and architecture intent" + } +] as const; + +export const findingStatuses = [ + { + status: "PROVEN", + effect: "Can block", + detail: "A deterministic check found symbolic evidence for an approved critical rule." + }, + { + status: "PROBABLE", + effect: "Review", + detail: "A strong signal needs human judgment before it can become enforceable." + }, + { + status: "SUSPECT", + effect: "Inform", + detail: "A weak signal is useful context, not a reason to stop a merge." + }, + { + status: "RULE_CONFLICT", + effect: "Investigate", + detail: "A heuristic suspicion disagrees with deterministic evidence." + }, + { + status: "DISMISSED", + effect: "No action", + detail: "The finding has no actionable evidence for this change." + } +] as const; + +export const faqItems = [ + { + question: "Is AxiomGuard a replacement for SAST?", + answer: + "No. AxiomGuard complements SAST by checking business and architecture intent rather than security vulnerability classes." + }, + { + question: "Does AxiomGuard use an LLM?", + answer: + "The MVP does not use an LLM for enforcement. Future LLM features may suggest candidate rules or explanations, but approved SemanticRules remain the source of truth." + }, + { + question: "What can block a pull request?", + answer: + "Only a PROVEN finding from an approved critical rule in block mode can block a pull request." + }, + { + question: "What languages are supported?", + answer: + "The MVP is TypeScript-first and focuses on deterministic symbolic checks for TypeScript diffs." + }, + { + question: "Do teams need perfect documentation to start?", + answer: + "No. Teams can start with one important rule reviewers already enforce manually, then expand the SemanticRule set over time." + } +] as const; + +export const semanticRuleSnippet = [ + "rule_id: AUTH-BOUNDARY-001", + "status: approved", + "severity: critical", + "invariants:", + " - type: forbidden_import", + " forbidden_imports:", + " - '@acme/billing'", + "enforcement:", + " mode: block" +] as const; + +export const diffLines = [ + { + tone: "muted", + text: "apps/auth/session.ts" + }, + { + tone: "bad", + text: '+ import { charge } from "@acme/billing";' + }, + { + tone: "normal", + text: "+ export async function createSession(user) {" + }, + { + tone: "normal", + text: "+ return issueSession(user);" + }, + { + tone: "normal", + text: "+ }" + } +] as const; + +export const cliReportLines = [ + "$ pnpm analyze:demo:broken", + "# S-Agent Report", + "", + "Project: examples/demo-typescript-app", + "", + "## Violation: INV-AUTH-001", + "", + "Changed file: src/auth/session.ts", + "Changed symbol: module", + "", + "Problem: Layer boundary violation:", + "src/auth/session.ts imports ../billing/billing-service.", + "", + "Why this matters:", + "The authentication layer is identity-only;", + "billing behavior must stay inside the billing domain.", + "", + "Evidence:", + "- src/auth/session.ts:1 - forbidden boundary", + "- CLAUDE.md:3 - CLAUDE.md#authentication-module", + "", + "Status: PROVEN", + "Severity: critical", + "Blocking: yes" +] as const; + +export const cleanCliReportLines = [ + "$ pnpm analyze:demo", + "# S-Agent Report", + "", + "Project: examples/demo-typescript-app-clean", + "", + "No findings." +] as const; + +export const realDemoReports = [ + { + title: "Broken fixture", + outcome: "Blocks", + tone: "blocking", + ariaLabel: "CLI output for the broken demo fixture with a proven blocking finding", + lines: cliReportLines + }, + { + title: "Clean fixture", + outcome: "Passes", + tone: "passing", + ariaLabel: "CLI output for the clean demo fixture with no findings", + lines: cleanCliReportLines + } +] as const; diff --git a/apps/site/src/content/seo-pages.ts b/apps/site/src/content/seo-pages.ts new file mode 100644 index 0000000..4d25129 --- /dev/null +++ b/apps/site/src/content/seo-pages.ts @@ -0,0 +1,185 @@ +import { pageMetadata } from "./landing"; + +export interface SeoFaq { + question: string; + answer: string; +} + +export interface SeoClusterPage { + slug: string; + keyword: string; + title: string; + description: string; + hero: string; + definition: string; + proofPoints: string[]; + useCases: string[]; + faq: SeoFaq[]; +} + +export const seoClusterPages: SeoClusterPage[] = [ + { + slug: "semantic-code-review", + keyword: "semantic code review", + title: "Semantic Code Review for TypeScript PRs", + description: + "Semantic code review checks whether a TypeScript pull request preserves approved business and architecture intent, not only syntax, style, or security patterns.", + hero: "Semantic code review catches code changes that are technically valid but semantically wrong for the system.", + definition: + "Semantic code review evaluates whether code preserves the meaning a team already approved in documentation, architecture decisions, and product rules. AxiomGuard implements this with approved SemanticRule YAML, deterministic TypeScript analysis, and proof-carrying findings.", + proofPoints: [ + "Approved SemanticRules are the source of truth.", + "Deterministic symbolic evidence creates PROVEN findings.", + "Only approved critical rules in block mode can stop a merge." + ], + useCases: [ + "Prevent auth code from importing billing code.", + "Catch read-only flows that write to a database or emit events.", + "Flag value literals that exceed an approved product threshold." + ], + faq: [ + { + question: "How is semantic code review different from linting?", + answer: + "Linting checks generic style and syntax rules. Semantic code review checks project-specific intent, such as domain boundaries, side-effect rules, and business invariants." + }, + { + question: "Can semantic code review block a pull request?", + answer: + "AxiomGuard can block only when an approved critical SemanticRule produces a PROVEN deterministic finding in block mode." + } + ] + }, + { + slug: "intent-aware-code-review", + keyword: "intent-aware code review", + title: "Intent-Aware Code Review Guardrails", + description: + "Intent-aware code review verifies that every pull request preserves documented business, product, and architecture rules.", + hero: "Intent-aware code review gives every pull request a memory of the rules your team already agreed to follow.", + definition: + "Intent-aware code review checks code changes against approved intent from CLAUDE.md, READMEs, ADRs, and architecture notes. AxiomGuard turns those approved rules into deterministic TypeScript checks with evidence a reviewer can audit.", + proofPoints: [ + "Candidate rules can come from documentation, but a human approves enforcement.", + "The YAML rule file remains the enforceable source of truth.", + "Findings include the violated invariant, changed file, evidence, status, and severity." + ], + useCases: [ + "Turn repeated staff-engineer review comments into executable rules.", + "Keep product invariants visible during refactors.", + "Make architecture decisions enforceable in CI." + ], + faq: [ + { + question: "What does intent-aware code review check?", + answer: + "It checks whether a change violates approved intent, including layer boundaries, forbidden side effects, and value invariants." + }, + { + question: "Does intent-aware code review rely on an LLM?", + answer: + "AxiomGuard does not use an LLM as the source of truth for blocking. LLMs may suggest candidate rules or explanations, but approved SemanticRules decide enforcement." + } + ] + }, + { + slug: "ai-code-review-guardrails", + keyword: "AI code review guardrails", + title: "AI Code Review Guardrails for Generated Code", + description: + "AI code review guardrails help teams keep AI-generated and refactored code aligned with approved business and architecture rules.", + hero: "AI-generated code can pass tests and still violate business intent. Guardrails make those rules explicit before merge.", + definition: + "AI code review guardrails are deterministic checks that constrain AI-assisted changes with approved project rules. AxiomGuard verifies TypeScript pull requests against SemanticRules so AI-written code must respect the same intent as human-written code.", + proofPoints: [ + "Prompts and repository context are helpful, but they are not enforceable policy.", + "Approved rules create auditable findings with deterministic evidence.", + "Heuristic suspicions can inform review, but only proof can block." + ], + useCases: [ + "Review AI-generated PRs for domain boundary drift.", + "Protect billing, auth, entitlement, and pricing flows from plausible but wrong edits.", + "Give platform teams a deterministic layer beside AI reviewers." + ], + faq: [ + { + question: "Why do AI-generated pull requests need guardrails?", + answer: + "AI-generated code can be syntactically correct while missing business context. Guardrails check approved rules that prompts and tests may not enforce." + }, + { + question: "Is AxiomGuard an AI reviewer?", + answer: + "No. AxiomGuard is deterministic-first. It can complement AI reviewers, but blocking findings come from approved SemanticRules and symbolic evidence." + } + ] + }, + { + slug: "architecture-drift-prevention", + keyword: "architecture drift prevention", + title: "Architecture Drift Prevention for Pull Requests", + description: + "Architecture drift prevention catches pull requests that violate documented module boundaries and approved architecture decisions.", + hero: "Architecture drift starts with one reasonable import. AxiomGuard catches boundary violations before they become the new normal.", + definition: + "Architecture drift prevention keeps code changes aligned with approved architecture decisions. AxiomGuard checks TypeScript imports and scoped rules so teams can stop layer boundary violations before they merge.", + proofPoints: [ + "Rules can encode boundaries such as auth must not import billing.", + "Findings show the importing file, resolved edge, violated invariant, and status.", + "The CLI can fail only on approved critical rules with PROVEN evidence." + ], + useCases: [ + "Protect package direction in a TypeScript monorepo.", + "Keep UI code from reaching into persistence layers.", + "Preserve architecture decisions during modernization projects." + ], + faq: [ + { + question: "What is architecture drift?", + answer: + "Architecture drift happens when code gradually diverges from approved design decisions, often through small dependencies, shortcuts, or refactors that look harmless in isolation." + }, + { + question: "How does AxiomGuard prevent architecture drift?", + answer: + "AxiomGuard encodes approved boundaries as SemanticRules, analyzes TypeScript changes, and reports proof-carrying findings when a pull request violates those boundaries." + } + ] + }, + { + slug: "business-logic-regression-prevention", + keyword: "business logic regression prevention", + title: "Business Logic Regression Prevention in Code Review", + description: + "Business logic regression prevention checks pull requests for rule violations such as unsafe side effects, broken product invariants, and invalid thresholds.", + hero: "Business logic regressions are often valid code with the wrong meaning. AxiomGuard checks the rules tests and linters miss.", + definition: + "Business logic regression prevention protects product rules such as pricing limits, entitlement assumptions, approval flows, and read-only behavior. AxiomGuard turns those rules into deterministic checks over TypeScript changes.", + proofPoints: [ + "Value invariants can flag obvious numeric thresholds that exceed approved limits.", + "Forbidden side-effect rules can identify writes or emitted events in read-only flows.", + "Every finding carries business and technical explanations." + ], + useCases: [ + "Prevent discounts from exceeding approved thresholds.", + "Keep reporting and read-model functions from writing to persistence.", + "Protect billing, entitlement, and compliance-sensitive modules during refactors." + ], + faq: [ + { + question: "Why do business logic regressions escape normal tests?", + answer: + "Tests usually cover known examples. Business logic regressions can appear when a change is type-correct but violates an assumption documented outside the code path being tested." + }, + { + question: "What business rules can AxiomGuard check today?", + answer: + "The MVP focuses on layer boundary violations, forbidden side effects, forbidden imports, and obvious value invariant violations in TypeScript projects." + } + ] + } +] as const; + +export const seoClusterSlugs = seoClusterPages.map((page) => page.slug); + +export const seoLastUpdated = pageMetadata.lastUpdated; diff --git a/apps/site/src/pages/[slug].astro b/apps/site/src/pages/[slug].astro new file mode 100644 index 0000000..885393d --- /dev/null +++ b/apps/site/src/pages/[slug].astro @@ -0,0 +1,171 @@ +--- +import { brand, pageMetadata, siteMetadata } from "../content/landing"; +import { seoClusterPages, type SeoClusterPage } from "../content/seo-pages"; +import "../styles/landing.css"; + +export function getStaticPaths() { + return seoClusterPages.map((page) => ({ + params: { slug: page.slug }, + props: { page } + })); +} + +interface Props { + page: SeoClusterPage; +} + +const { page } = Astro.props; +const siteBase = Astro.site ?? new URL(siteMetadata.productionUrl); +const canonicalUrl = new URL(`/${page.slug}`, siteBase).toString(); +const ogImageUrl = new URL(siteMetadata.ogImagePath, siteBase).toString(); +const pageTitle = `${page.title} | ${brand.product}`; +const relatedPages = seoClusterPages.filter((item) => item.slug !== page.slug); +const articleSchema = { + "@context": "https://schema.org", + "@type": "Article", + headline: page.title, + description: page.description, + dateModified: pageMetadata.lastUpdated, + mainEntityOfPage: canonicalUrl, + publisher: { + "@type": "Organization", + name: brand.product, + sameAs: siteMetadata.githubUrl + }, + sameAs: siteMetadata.githubUrl +}; +const faqSchema = { + "@context": "https://schema.org", + "@type": "FAQPage", + mainEntity: page.faq.map((item) => ({ + "@type": "Question", + name: item.question, + acceptedAnswer: { + "@type": "Answer", + text: item.answer + } + })) +}; +--- + + + + + + + + + + + + + + + + + + + + +