geo-ai-search-optimization 1.0.3 → 1.0.4

package/README.md

@@ -29,6 +29,8 @@ geo-ai-search-optimization install --target ./tmp/custom-skills --json
 geo-ai-search-optimization where
 geo-ai-search-optimization doctor
 geo-ai-search-optimization init-llms ./site --site-name "Acme Docs" --site-url "https://example.com"
+geo-ai-search-optimization init-schema organization ./site --site-url "https://example.com"
+geo-ai-search-optimization init-schema faq-page ./site --json
 geo-ai-search-optimization audit ./my-site --type saas
 geo-ai-search-optimization audit ./my-site --json --out ./reports/geo-audit.json
 geo-ai-search-optimization scan ./my-site --max-file-size 500000 --max-examples 3
@@ -37,6 +39,16 @@ geo-ai-search-optimization version
 geo-ai-search-optimization help
 ```
 
+## New in 1.0.4
+
+- `init-schema` command for generating JSON-LD starter files
+- supported schema templates:
+  - `organization`
+  - `article`
+  - `faq-page`
+  - `product`
+  - `breadcrumb-list`
+
 ## New in 1.0.3
 
 - `audit` command with a GEO score, blockers, high-impact fixes, SEO support fixes, and experiments

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "geo-ai-search-optimization",
-  "version": "1.0.3",
+  "version": "1.0.4",
   "description": "Install and run a GEO-first, SEO-supported Codex skill for AI search optimization.",
   "type": "module",
   "bin": {

package/src/cli.js

@@ -7,6 +7,7 @@ import { renderScanMarkdown, scanProject, writeScanOutput } from "./scan.js";
 import { renderDoctorMarkdown, runDoctor } from "./doctor.js";
 import { createLlmsTxt } from "./llms-txt.js";
 import { auditProject, renderAuditMarkdown, writeAuditOutput } from "./audit.js";
+import { createSchemaTemplate } from "./schema.js";
 
 let cachedVersion;
 
@@ -32,6 +33,7 @@ function printHelp() {
       "  geo-ai-search-optimization where",
       "  geo-ai-search-optimization doctor [--json]",
       "  geo-ai-search-optimization init-llms [target-dir] [--site-name <name>] [--site-url <url>] [--overwrite] [--json]",
+      "  geo-ai-search-optimization init-schema <type> [target-dir] [--site-url <url>] [--overwrite] [--json]",
       "  geo-ai-search-optimization audit <project-path> [--type <site-type>] [--json] [--out <file>] [--max-file-size <bytes>] [--max-examples <count>]",
       "  geo-ai-search-optimization scan <project-path> [--json] [--out <file>] [--max-file-size <bytes>] [--max-examples <count>]",
       "  geo-ai-search-optimization version",
@@ -145,6 +147,29 @@ async function handleInitLlms(args) {
   process.stdout.write(`Created llms.txt at ${result.outputPath}\n`);
 }
 
+async function handleInitSchema(args) {
+  const [schemaType, ...rest] = args;
+  if (!schemaType || schemaType.startsWith("-")) {
+    throw new Error("init-schema requires a schema type");
+  }
+
+  const targetDir = rest.find((value) => !value.startsWith("-")) || ".";
+  const outputJson = hasFlag(rest, "--json");
+  const result = await createSchemaTemplate({
+    schemaType,
+    targetDir,
+    siteUrl: getFlagValue(rest, "--site-url"),
+    overwrite: hasFlag(rest, "--overwrite")
+  });
+
+  if (outputJson) {
+    process.stdout.write(`${JSON.stringify(result, null, 2)}\n`);
+    return;
+  }
+
+  process.stdout.write(`Created ${result.schemaType} schema template at ${result.outputPath}\n`);
+}
+
 async function handleAudit(args) {
   const projectPath = args.find((value) => !value.startsWith("-"));
   if (!projectPath) {
@@ -209,6 +234,11 @@ export async function runCli(args = []) {
     return;
   }
 
+  if (command === "init-schema") {
+    await handleInitSchema(rest);
+    return;
+  }
+
   if (command === "audit") {
     await handleAudit(rest);
     return;

package/src/index.js

@@ -3,4 +3,5 @@ export { installSkill } from "./install-skill.js";
 export { runCli } from "./cli.js";
 export { runDoctor, renderDoctorMarkdown } from "./doctor.js";
 export { createLlmsTxt } from "./llms-txt.js";
+export { createSchemaTemplate } from "./schema.js";
 export { scanProject, renderScanMarkdown, writeScanOutput } from "./scan.js";

package/src/schema.js

@@ -0,0 +1,180 @@
+import fs from "node:fs/promises";
+import path from "node:path";
+
+const TEMPLATE_TYPES = new Set([
+  "organization",
+  "article",
+  "faq-page",
+  "product",
+  "breadcrumb-list"
+]);
+
+async function pathExists(targetPath) {
+  try {
+    await fs.access(targetPath);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+function normalizeSchemaType(schemaType) {
+  const resolved = (schemaType || "").toLowerCase();
+  if (!TEMPLATE_TYPES.has(resolved)) {
+    throw new Error(
+      `Unsupported schema type: ${schemaType}. Valid values: ${Array.from(TEMPLATE_TYPES).join(", ")}`
+    );
+  }
+  return resolved;
+}
+
+function buildOrganizationTemplate(siteUrl) {
+  return {
+    "@context": "https://schema.org",
+    "@type": "Organization",
+    name: "Your Organization",
+    url: siteUrl,
+    logo: `${siteUrl}/logo.png`,
+    sameAs: [
+      "https://www.linkedin.com/company/your-company",
+      "https://x.com/your-brand"
+    ]
+  };
+}
+
+function buildArticleTemplate(siteUrl) {
+  return {
+    "@context": "https://schema.org",
+    "@type": "Article",
+    headline: "Your article headline",
+    description: "Summarize the article in one clear sentence.",
+    author: {
+      "@type": "Person",
+      name: "Author Name"
+    },
+    publisher: {
+      "@type": "Organization",
+      name: "Your Organization",
+      url: siteUrl
+    },
+    datePublished: "2026-03-12",
+    dateModified: "2026-03-12",
+    mainEntityOfPage: `${siteUrl}/blog/your-article-slug`
+  };
+}
+
+function buildFaqPageTemplate() {
+  return {
+    "@context": "https://schema.org",
+    "@type": "FAQPage",
+    mainEntity: [
+      {
+        "@type": "Question",
+        name: "What problem does this page answer?",
+        acceptedAnswer: {
+          "@type": "Answer",
+          text: "Replace this with the direct answer visible on the page."
+        }
+      },
+      {
+        "@type": "Question",
+        name: "Who is this for?",
+        acceptedAnswer: {
+          "@type": "Answer",
+          text: "Replace this with a concise, factual answer."
+        }
+      }
+    ]
+  };
+}
+
+function buildProductTemplate(siteUrl) {
+  return {
+    "@context": "https://schema.org",
+    "@type": "Product",
+    name: "Your Product",
+    description: "Describe the product with factual, user-facing language.",
+    brand: {
+      "@type": "Brand",
+      name: "Your Brand"
+    },
+    offers: {
+      "@type": "Offer",
+      url: `${siteUrl}/pricing`,
+      priceCurrency: "USD",
+      price: "99",
+      availability: "https://schema.org/InStock"
+    }
+  };
+}
+
+function buildBreadcrumbListTemplate(siteUrl) {
+  return {
+    "@context": "https://schema.org",
+    "@type": "BreadcrumbList",
+    itemListElement: [
+      {
+        "@type": "ListItem",
+        position: 1,
+        name: "Home",
+        item: siteUrl
+      },
+      {
+        "@type": "ListItem",
+        position: 2,
+        name: "Section",
+        item: `${siteUrl}/section`
+      },
+      {
+        "@type": "ListItem",
+        position: 3,
+        name: "Current Page",
+        item: `${siteUrl}/section/current-page`
+      }
+    ]
+  };
+}
+
+function buildSchemaTemplate(schemaType, siteUrl) {
+  switch (schemaType) {
+    case "organization":
+      return buildOrganizationTemplate(siteUrl);
+    case "article":
+      return buildArticleTemplate(siteUrl);
+    case "faq-page":
+      return buildFaqPageTemplate();
+    case "product":
+      return buildProductTemplate(siteUrl);
+    case "breadcrumb-list":
+      return buildBreadcrumbListTemplate(siteUrl);
+    default:
+      throw new Error(`Unsupported schema type: ${schemaType}`);
+  }
+}
+
+function buildFileName(schemaType) {
+  return `${schemaType}.schema.json`;
+}
+
+export async function createSchemaTemplate(options = {}) {
+  const schemaType = normalizeSchemaType(options.schemaType);
+  const targetDir = path.resolve(options.targetDir || ".");
+  const siteUrl = options.siteUrl || "https://example.com";
+  const outputPath = path.join(targetDir, buildFileName(schemaType));
+  const overwrite = Boolean(options.overwrite);
+
+  if (!overwrite && (await pathExists(outputPath))) {
+    throw new Error(`${path.basename(outputPath)} already exists at ${outputPath}. Use --overwrite to replace it.`);
+  }
+
+  await fs.mkdir(targetDir, { recursive: true });
+
+  const schema = buildSchemaTemplate(schemaType, siteUrl);
+  await fs.writeFile(outputPath, `${JSON.stringify(schema, null, 2)}\n`, "utf8");
+
+  return {
+    schemaType,
+    outputPath,
+    siteUrl
+  };
+}