@lukoweb/apitogo 0.1.16 → 0.1.17

package/dist/cli/cli.js

@@ -131,7 +131,7 @@ import { stat } from "node:fs/promises";
 var fileExists;
 var init_file_exists = __esm({
   "src/config/file-exists.ts"() {
-    fileExists = (path32) => stat(path32).then(() => true).catch(() => false);
+    fileExists = (path33) => stat(path33).then(() => true).catch(() => false);
   }
 });
 
@@ -3822,7 +3822,7 @@ import {
 // package.json
 var package_default = {
   name: "@lukoweb/apitogo",
-  version: "0.1.16",
+  version: "0.1.17",
   type: "module",
   sideEffects: [
     "**/*.css",
@@ -4533,14 +4533,14 @@ var flattenAllOf = (schema2) => {
 };
 
 // src/lib/util/traverse.ts
-var traverse = (specification, transform, path32 = []) => {
-  const transformed = transform(specification, path32);
+var traverse = (specification, transform, path33 = []) => {
+  const transformed = transform(specification, path33);
   if (typeof transformed !== "object" || transformed === null) {
     return transformed;
   }
   const result = Array.isArray(transformed) ? [] : {};
   for (const [key, value] of Object.entries(transformed)) {
-    const currentPath = [...path32, key];
+    const currentPath = [...path33, key];
     if (Array.isArray(value)) {
       result[key] = value.map(
         (item, index) => typeof item === "object" && item != null ? traverse(item, transform, [...currentPath, index.toString()]) : item
@@ -4568,9 +4568,9 @@ var resolveLocalRef = (schema2, ref) => {
   if (schemaCache?.has(ref)) {
     return schemaCache.get(ref);
   }
-  const path32 = ref.split("/").slice(1);
+  const path33 = ref.split("/").slice(1);
   let current = schema2;
-  for (const segment of path32) {
+  for (const segment of path33) {
     if (!current || typeof current !== "object") {
       current = null;
     }
@@ -4589,7 +4589,7 @@ var dereference = async (schema2, resolvers = []) => {
   }
   const cloned = structuredClone(schema2);
   const visited = /* @__PURE__ */ new Set();
-  const resolve = async (current, path32) => {
+  const resolve = async (current, path33) => {
     if (isIndexableObject(current)) {
       if (visited.has(current)) {
         return CIRCULAR_REF;
@@ -4597,7 +4597,7 @@ var dereference = async (schema2, resolvers = []) => {
       visited.add(current);
       if (Array.isArray(current)) {
         for (let index = 0; index < current.length; index++) {
-          current[index] = await resolve(current[index], `${path32}/${index}`);
+          current[index] = await resolve(current[index], `${path33}/${index}`);
         }
       } else {
         if ("$ref" in current && typeof current.$ref === "string") {
@@ -4608,13 +4608,13 @@ var dereference = async (schema2, resolvers = []) => {
           for (const resolver of resolvers) {
             const resolved = await resolver($ref);
             if (resolved) {
-              result2 = await resolve(resolved, path32);
+              result2 = await resolve(resolved, path33);
               break;
             }
           }
           if (result2 === void 0) {
             const resolved = await resolveLocalRef(cloned, $ref);
-            result2 = await resolve(resolved, path32);
+            result2 = await resolve(resolved, path33);
           }
           if (hasSiblings) {
             if (result2 === CIRCULAR_REF) {
@@ -4627,7 +4627,7 @@ var dereference = async (schema2, resolvers = []) => {
           return result2;
         }
         for (const key in current) {
-          current[key] = await resolve(current[key], `${path32}/${key}`);
+          current[key] = await resolve(current[key], `${path33}/${key}`);
         }
       }
       visited.delete(current);
@@ -4666,9 +4666,9 @@ var upgradeSchema = (schema2) => {
     }
     return sub;
   });
-  schema2 = traverse(schema2, (sub, path32) => {
+  schema2 = traverse(schema2, (sub, path33) => {
     if (sub.example !== void 0) {
-      if (isSchemaPath(path32 ?? [])) {
+      if (isSchemaPath(path33 ?? [])) {
         sub.examples = [sub.example];
       } else {
         sub.examples = {
@@ -4681,11 +4681,11 @@ var upgradeSchema = (schema2) => {
     }
     return sub;
   });
-  schema2 = traverse(schema2, (schema3, path32) => {
+  schema2 = traverse(schema2, (schema3, path33) => {
     if (schema3.type === "object" && schema3.properties !== void 0) {
-      const parentPath = path32?.slice(0, -1);
+      const parentPath = path33?.slice(0, -1);
       const isMultipart = parentPath?.some((segment, index) => {
-        return segment === "content" && path32?.[index + 1] === "multipart/form-data";
+        return segment === "content" && path33?.[index + 1] === "multipart/form-data";
       });
       if (isMultipart) {
         const entries = Object.entries(schema3.properties);
@@ -4699,8 +4699,8 @@ var upgradeSchema = (schema2) => {
     }
     return schema3;
   });
-  schema2 = traverse(schema2, (schema3, path32) => {
-    if (path32?.includes("content") && path32.includes("application/octet-stream")) {
+  schema2 = traverse(schema2, (schema3, path33) => {
+    if (path33?.includes("content") && path33.includes("application/octet-stream")) {
       return {};
     }
     if (schema3.type === "string" && schema3.format === "binary") {
@@ -4726,11 +4726,11 @@ var upgradeSchema = (schema2) => {
     }
     return sub;
   });
-  schema2 = traverse(schema2, (schema3, path32) => {
+  schema2 = traverse(schema2, (schema3, path33) => {
     if (schema3.type === "string" && schema3.format === "byte") {
-      const parentPath = path32?.slice(0, -1);
+      const parentPath = path33?.slice(0, -1);
       const contentMediaType = parentPath?.find(
-        (_, index) => path32?.[index - 1] === "content"
+        (_, index) => path33?.[index - 1] === "content"
       );
       return {
         type: "string",
@@ -4742,7 +4742,7 @@ var upgradeSchema = (schema2) => {
   });
   return schema2;
 };
-function isSchemaPath(path32) {
+function isSchemaPath(path33) {
   const schemaLocations = [
     ["components", "schemas"],
     "properties",
@@ -4755,10 +4755,10 @@ function isSchemaPath(path32) {
   ];
   return schemaLocations.some((location) => {
     if (Array.isArray(location)) {
-      return location.every((segment, index) => path32[index] === segment);
+      return location.every((segment, index) => path33[index] === segment);
     }
-    return path32.includes(location);
-  }) || path32.includes("schema") || path32.some((segment) => segment.endsWith("Schema"));
+    return path33.includes(location);
+  }) || path33.includes("schema") || path33.some((segment) => segment.endsWith("Schema"));
 }
 
 // src/lib/oas/parser/index.ts
@@ -4840,13 +4840,13 @@ var OPENAPI_PROPS = /* @__PURE__ */ new Set([
   "anyOf",
   "oneOf"
 ]);
-var handleCircularRefs = (obj, currentPath = /* @__PURE__ */ new WeakSet(), refs = /* @__PURE__ */ new WeakMap(), path32 = [], currentRefPaths = /* @__PURE__ */ new Set()) => {
+var handleCircularRefs = (obj, currentPath = /* @__PURE__ */ new WeakSet(), refs = /* @__PURE__ */ new WeakMap(), path33 = [], currentRefPaths = /* @__PURE__ */ new Set()) => {
   if (obj === null || typeof obj !== "object") return obj;
   const refPath = obj.__$ref;
   const isCircular = currentPath.has(obj) || typeof refPath === "string" && currentRefPaths.has(refPath);
   if (isCircular) {
     if (typeof refPath === "string") return SCHEMA_REF_PREFIX + refPath;
-    const circularProp = path32.find((p) => !OPENAPI_PROPS.has(p)) || path32[0];
+    const circularProp = path33.find((p) => !OPENAPI_PROPS.has(p)) || path33[0];
     return [CIRCULAR_REF, circularProp].filter(Boolean).join(":");
   }
   if (refs.has(obj)) return refs.get(obj);
@@ -4856,7 +4856,7 @@ var handleCircularRefs = (obj, currentPath = /* @__PURE__ */ new WeakSet(), refs
     value,
     currentPath,
     refs,
-    [...path32, key],
+    [...path33, key],
     currentRefPaths
   );
   const result = Array.isArray(obj) ? obj.map((item, i) => recurse(item, i.toString())) : Object.fromEntries(
@@ -4891,7 +4891,7 @@ var resolveExtensions = (obj) => Object.fromEntries(
 var getAllTags = (schema2) => {
   const rootTags = schema2.tags ?? [];
   const operations = Object.values(schema2.paths ?? {}).flatMap(
-    (path32) => HttpMethods.map((k) => path32?.[k]).filter((op) => op != null)
+    (path33) => HttpMethods.map((k) => path33?.[k]).filter((op) => op != null)
   );
   const operationTags = new Set(operations.flatMap((op) => op.tags ?? []));
   const hasUntaggedOperations = operations.some(
@@ -4946,7 +4946,7 @@ var getAllSlugs = (ops, schemaTags = []) => {
 var getOperationSlugKey = (op) => [op.path, op.method, op.operationId, op.summary].filter(Boolean).join("-");
 var getAllOperations = (paths) => {
   const operations = Object.entries(paths ?? {}).flatMap(
-    ([path32, value]) => HttpMethods.flatMap((method) => {
+    ([path33, value]) => HttpMethods.flatMap((method) => {
       if (!value?.[method]) return [];
       const operation = value[method];
       const pathParameters = value.parameters ?? [];
@@ -4966,7 +4966,7 @@ var getAllOperations = (paths) => {
       return {
         ...operation,
         method,
-        path: path32,
+        path: path33,
         parameters,
         servers,
         tags: operation.tags ?? []
@@ -5324,8 +5324,8 @@ var Schema = builder.objectRef("Schema").implement({
     }),
     paths: t.field({
       type: [PathItem],
-      resolve: (root) => Object.entries(root.paths ?? {}).map(([path32, value]) => ({
-        path: path32,
+      resolve: (root) => Object.entries(root.paths ?? {}).map(([path33, value]) => ({
+        path: path33,
         // biome-ignore lint/style/noNonNullAssertion: value is guaranteed to be defined
         methods: Object.keys(value)
       }))
@@ -5472,7 +5472,7 @@ init_joinUrl();
 
 // src/vite/api/schema-codegen.ts
 var unescapeJsonPointer = (uri) => decodeURIComponent(uri.replace(/~1/g, "/").replace(/~0/g, "~"));
-var getSegmentsFromPath = (path32) => path32.split("/").slice(1).map(unescapeJsonPointer);
+var getSegmentsFromPath = (path33) => path33.split("/").slice(1).map(unescapeJsonPointer);
 var createLocalRefMap = (obj) => {
   const refMap = /* @__PURE__ */ new Map();
   const siblingsMap = /* @__PURE__ */ new Map();
@@ -5503,16 +5503,16 @@ var replaceMarkers = (code, mergedRefs) => code.replace(/"__refMap:(.*?)"/g, '__
   /"__refMap\+Siblings:(.*?)"/g,
   (_, key) => mergedRefs.get(key) ?? `__refMap["${key}"]`
 );
-var lookup = (schema2, path32, filePath) => {
-  const parts = getSegmentsFromPath(path32);
+var lookup = (schema2, path33, filePath) => {
+  const parts = getSegmentsFromPath(path33);
   let val = schema2;
   for (const part of parts) {
     while (val.$ref?.startsWith("#/")) {
-      val = val.$ref === path32 ? val : lookup(schema2, val.$ref, filePath);
+      val = val.$ref === path33 ? val : lookup(schema2, val.$ref, filePath);
     }
     if (val[part] === void 0) {
       throw new Error(
-        `Error in ${filePath ?? "code generation"}: Could not find path segment ${part} in path: ${path32}`
+        `Error in ${filePath ?? "code generation"}: Could not find path segment ${part} in path: ${path33}`
       );
     }
     val = val[part];
@@ -5757,8 +5757,8 @@ var SchemaManager = class {
       }
     }
   };
-  getLatestSchema = (path32) => this.processedSchemas[path32]?.at(0);
-  getSchemasForPath = (path32) => this.processedSchemas[path32];
+  getLatestSchema = (path33) => this.processedSchemas[path33]?.at(0);
+  getSchemasForPath = (path33) => this.processedSchemas[path33];
   getSchemaImports = () => Object.values(this.processedSchemas).flat().filter((s) => s.importKey);
   getUrlToFilePathMap = () => {
     const map = /* @__PURE__ */ new Map();
@@ -7847,14 +7847,14 @@ async function generateSitemap({
 
 // src/vite/prerender/utils.ts
 init_joinUrl();
-var resolveRoutePath = (path32) => {
-  const segments = path32.split("/");
+var resolveRoutePath = (path33) => {
+  const segments = path33.split("/");
   if (segments.some((s) => s.startsWith(":") && !s.endsWith("?"))) {
     return void 0;
   }
   return segments.filter((s) => !s.startsWith(":")).join("/") || void 0;
 };
-var isSkipped = (path32) => path32.includes("*") || /^\d+$/.test(path32);
+var isSkipped = (path33) => path33.includes("*") || /^\d+$/.test(path33);
 var resolveRoutes = (routes, parentPath = "") => routes.flatMap((route) => {
   if (route.path && isSkipped(route.path)) return [];
   const routePath = route.path ? resolveRoutePath(route.path) : void 0;
@@ -9145,9 +9145,230 @@ var dev_default = {
 };
 
 // src/cli/make-config/handler.ts
-import { readFile as readFile5, writeFile as writeFile7 } from "node:fs/promises";
+import { readFile as readFile6, writeFile as writeFile8 } from "node:fs/promises";
+import path31 from "node:path";
+import { glob as glob5 } from "glob";
+
+// src/cli/make-config/scaffold-project.ts
+init_package_json();
+import { access as access3, readFile as readFile5, writeFile as writeFile7 } from "node:fs/promises";
+import { constants as constants2 } from "node:fs";
 import path30 from "node:path";
 import { glob as glob4 } from "glob";
+var OPENAPI_GLOBS = [
+  "apis/openapi.json",
+  "apis/openapi.yaml",
+  "apis/openapi.yml",
+  "openapi.json",
+  "openapi.yaml",
+  "openapi.yml"
+];
+var findMatchingCurly = (source, startIndex) => {
+  let depth = 0;
+  let inSingleQuote = false;
+  let inDoubleQuote = false;
+  let inTemplate = false;
+  let inLineComment = false;
+  let inBlockComment = false;
+  for (let index = startIndex; index < source.length; index++) {
+    const char = source[index];
+    const next = source[index + 1];
+    const prev = source[index - 1];
+    if (inLineComment) {
+      if (char === "\n") inLineComment = false;
+      continue;
+    }
+    if (inBlockComment) {
+      if (prev === "*" && char === "/") inBlockComment = false;
+      continue;
+    }
+    if (!inSingleQuote && !inDoubleQuote && !inTemplate) {
+      if (char === "/" && next === "/") {
+        inLineComment = true;
+        index++;
+        continue;
+      }
+      if (char === "/" && next === "*") {
+        inBlockComment = true;
+        index++;
+        continue;
+      }
+    }
+    if (!inDoubleQuote && !inTemplate && char === "'" && prev !== "\\") {
+      inSingleQuote = !inSingleQuote;
+      continue;
+    }
+    if (!inSingleQuote && !inTemplate && char === '"' && prev !== "\\") {
+      inDoubleQuote = !inDoubleQuote;
+      continue;
+    }
+    if (!inSingleQuote && !inDoubleQuote && char === "`" && prev !== "\\") {
+      inTemplate = !inTemplate;
+      continue;
+    }
+    if (inSingleQuote || inDoubleQuote || inTemplate) continue;
+    if (char === "{") depth++;
+    if (char === "}") depth--;
+    if (depth === 0) return index;
+  }
+  throw new Error("Could not find matching closing brace for object.");
+};
+var toPosix = (p) => p.split(path30.sep).join("/");
+var sanitizePackageName = (dir) => {
+  const base = path30.basename(path30.resolve(dir));
+  const s = base.toLowerCase().replace(/[^a-z0-9-_.]/g, "-").replace(/^-+|-+$/g, "");
+  return s || "apitogo-site";
+};
+var apitogoVersionRange = () => {
+  const v = getZudokuPackageJson()?.version;
+  return v ? `^${v}` : "latest";
+};
+async function findOpenApiSpecPath(dir) {
+  for (const rel of OPENAPI_GLOBS) {
+    const full = path30.join(dir, rel);
+    try {
+      await access3(full, constants2.R_OK);
+      return toPosix(rel);
+    } catch {
+    }
+  }
+  const extra = await glob4("apis/**/*.{json,yaml,yml}", {
+    cwd: dir,
+    posix: true,
+    ignore: ["**/node_modules/**"]
+  });
+  return extra[0] ? toPosix(extra[0]) : null;
+}
+async function ensurePackageJson(dir) {
+  const pkgPath = path30.join(dir, "package.json");
+  const apitogoVer = apitogoVersionRange();
+  const baseDeps = {
+    react: ">=19.0.0",
+    "react-dom": ">=19.0.0",
+    "@lukoweb/apitogo": apitogoVer
+  };
+  const baseScripts = {
+    dev: "apitogo dev",
+    build: "apitogo build",
+    preview: "apitogo preview"
+  };
+  try {
+    await access3(pkgPath, constants2.R_OK);
+  } catch (err) {
+    const code = err.code;
+    if (code !== "ENOENT") throw err;
+    const pkg2 = {
+      name: sanitizePackageName(dir),
+      version: "0.1.0",
+      private: true,
+      type: "module",
+      scripts: baseScripts,
+      dependencies: baseDeps,
+      devDependencies: {
+        "@types/node": "^22",
+        "@types/react": "^19",
+        "@types/react-dom": "^19",
+        typescript: "^5"
+      }
+    };
+    await writeFile7(pkgPath, `${JSON.stringify(pkg2, null, 2)}
+`, "utf8");
+    return true;
+  }
+  const raw = await readFile5(pkgPath, "utf8");
+  let pkg;
+  try {
+    pkg = JSON.parse(raw);
+  } catch {
+    throw new Error("package.json exists but is not valid JSON; fix or remove it and run again.");
+  }
+  pkg.scripts = {
+    ...typeof pkg.scripts === "object" && pkg.scripts !== null ? pkg.scripts : {}
+  };
+  const scripts = pkg.scripts;
+  for (const [k, v] of Object.entries(baseScripts)) {
+    if (!scripts[k]) scripts[k] = v;
+  }
+  pkg.dependencies = {
+    ...typeof pkg.dependencies === "object" && pkg.dependencies !== null ? pkg.dependencies : {}
+  };
+  const deps = pkg.dependencies;
+  for (const [k, v] of Object.entries(baseDeps)) {
+    if (!deps[k]) deps[k] = v;
+  }
+  await writeFile7(pkgPath, `${JSON.stringify(pkg, null, 2)}
+`, "utf8");
+  return false;
+}
+async function ensureTsconfigJson(dir) {
+  const tsPath = path30.join(dir, "tsconfig.json");
+  try {
+    await access3(tsPath, constants2.R_OK);
+    return false;
+  } catch {
+    const tsconfig = {
+      compilerOptions: {
+        target: "ES2022",
+        lib: ["ESNext", "DOM", "DOM.Iterable", "WebWorker"],
+        module: "ESNext",
+        moduleResolution: "Bundler",
+        useDefineForClassFields: true,
+        skipLibCheck: true,
+        skipDefaultLibCheck: true,
+        resolveJsonModule: true,
+        isolatedModules: true,
+        useUnknownInCatchVariables: false,
+        jsx: "react-jsx"
+      },
+      include: [
+        "*.config.ts",
+        "*.config.tsx",
+        "*.config.jsx",
+        "*.config.js",
+        "*.config.mjs",
+        "pages"
+      ]
+    };
+    await writeFile7(tsPath, `${JSON.stringify(tsconfig, null, 2)}
+`, "utf8");
+    return true;
+  }
+}
+function insertApisIfMissing(source, openapiInput) {
+  if (/\bapis\s*:/.test(source)) return source;
+  const apisBlock = [
+    "  apis: {",
+    '    type: "file",',
+    `    input: "${openapiInput.replace(/"/g, '\\"')}",`,
+    '    path: "api",',
+    "  },"
+  ].join("\n");
+  const docsMatch = source.match(/\bdocs\s*:\s*\{/);
+  if (!docsMatch || docsMatch.index === void 0) {
+    const m = source.match(/(const\s+config\s*:\s*ApitogoConfig\s*=\s*\{)/);
+    if (!m || m.index === void 0) {
+      return source;
+    }
+    const open = m.index + m[0].length;
+    return `${source.slice(0, open)}
+${apisBlock}
+${source.slice(open)}`;
+  }
+  const openBrace = source.indexOf("{", docsMatch.index);
+  const closeBrace = findMatchingCurly(source, openBrace);
+  let p = closeBrace + 1;
+  while (p < source.length && /\s/.test(source[p])) p++;
+  if (source[p] === ",") p++;
+  while (p < source.length && /\s/.test(source[p])) p++;
+  return `${source.slice(0, p)}${apisBlock}
+${source.slice(p)}`;
+}
+function openapiInputForConfig(specRelativePosix) {
+  if (specRelativePosix.startsWith("./")) return specRelativePosix;
+  return `./${specRelativePosix}`;
+}
+
+// src/cli/make-config/handler.ts
 var CONFIG_FILENAMES = [
   "apitogo.config.tsx",
   "apitogo.config.ts",
@@ -9162,7 +9383,7 @@ var CONFIG_FILENAMES = [
 ];
 var DEFAULT_NEW_CONFIG_FILENAME = "apitogo.config.tsx";
 var createTreeNode = () => ({ docs: [], children: /* @__PURE__ */ new Map() });
-var toPosixPath2 = (value) => value.split(path30.sep).join(path30.posix.sep);
+var toPosixPath2 = (value) => value.split(path31.sep).join(path31.posix.sep);
 var toRoutePath = (relativeFile, pagesDir) => {
   const relativeNoExt = relativeFile.replace(/\.mdx?$/, "");
   const withoutPagesPrefix = relativeNoExt.replace(
@@ -9384,14 +9605,20 @@ var ensureNavigationAndRedirectsForUpdate = (source) => {
     "Found 'redirects' but not 'navigation'. Add a navigation: [...] array manually."
   );
 };
-var buildNewConfigContents = (pagesDir) => {
-  const filesGlob = `/${pagesDir}/**/*.mdx`;
+var buildNewConfigContents = (pagesDir, openApiSpecRelative) => {
+  const filesGlob = `/${pagesDir}/**/*.{md,mdx}`;
+  const apisSection = openApiSpecRelative == null ? "" : `
+  apis: {
+    type: "file",
+    input: "${openapiInputForConfig(openApiSpecRelative)}",
+    path: "api",
+  },`;
   return `import type { ApitogoConfig } from "@lukoweb/apitogo";
 
 const config: ApitogoConfig = {
   docs: {
     files: "${filesGlob}",
-  },
+  },${apisSection}
   navigation: [],
   redirects: [],
 };
@@ -9401,9 +9628,9 @@ export default config;
 };
 var findExistingConfigPath = async (dir) => {
   for (const filename of CONFIG_FILENAMES) {
-    const fullPath = path30.join(dir, filename);
+    const fullPath = path31.join(dir, filename);
     try {
-      await readFile5(fullPath, "utf8");
+      await readFile6(fullPath, "utf8");
       return fullPath;
     } catch {
     }
@@ -9411,20 +9638,33 @@ var findExistingConfigPath = async (dir) => {
   return null;
 };
 async function makeConfig(argv) {
-  const dir = path30.resolve(process.cwd(), argv.dir);
+  const dir = path31.resolve(process.cwd(), argv.dir);
   const pagesDir = toPosixPath2(
     argv.pagesDir.replace(/^[./]+/, "").replace(/\/+$/, "")
   );
   try {
+    const openApiSpecPath = await findOpenApiSpecPath(dir);
+    const createdPackageJson = await ensurePackageJson(dir);
+    const createdTsconfig = await ensureTsconfigJson(dir);
+    if (createdPackageJson) {
+      printDiagnosticsToConsole("Created package.json with dev, build, and preview scripts.");
+    }
+    if (createdTsconfig) {
+      printDiagnosticsToConsole("Created tsconfig.json.");
+    }
     let configPath = await findExistingConfigPath(dir);
     let createdNew = false;
     if (!configPath) {
-      configPath = path30.join(dir, DEFAULT_NEW_CONFIG_FILENAME);
-      await writeFile7(configPath, buildNewConfigContents(pagesDir), "utf8");
+      configPath = path31.join(dir, DEFAULT_NEW_CONFIG_FILENAME);
+      await writeFile8(
+        configPath,
+        buildNewConfigContents(pagesDir, openApiSpecPath),
+        "utf8"
+      );
       createdNew = true;
       printDiagnosticsToConsole(`Created ${DEFAULT_NEW_CONFIG_FILENAME}`);
     }
-    const pageFiles = await glob4(`${pagesDir}/**/*.{md,mdx}`, {
+    const pageFiles = await glob5(`${pagesDir}/**/*.{md,mdx}`, {
       cwd: dir,
       ignore: ["**/node_modules/**", "**/.git/**", "**/dist/**"],
       posix: true
@@ -9435,7 +9675,13 @@ async function makeConfig(argv) {
     if (routePaths.length === 0) {
       throw new Error(`No .md or .mdx files found under '${pagesDir}'.`);
     }
-    let originalConfig = await readFile5(configPath, "utf8");
+    let originalConfig = await readFile6(configPath, "utf8");
+    if (!createdNew && openApiSpecPath) {
+      originalConfig = insertApisIfMissing(
+        originalConfig,
+        openapiInputForConfig(openApiSpecPath)
+      );
+    }
     originalConfig = ensureNavigationAndRedirectsForUpdate(originalConfig);
     const withNavigation = replaceArrayProperty(
       originalConfig,
@@ -9447,11 +9693,16 @@ async function makeConfig(argv) {
       "redirects",
       buildRedirectsCode(routePaths[0])
     );
-    await writeFile7(configPath, withRedirects, "utf8");
+    await writeFile8(configPath, withRedirects, "utf8");
     const action = createdNew ? "Initialized" : "Updated";
     printResultToConsole(
-      `${action} ${path30.basename(configPath)} from ${pagesDir}/ (navigation and redirects only; other settings unchanged)`
+      `${action} ${path31.basename(configPath)} from ${pagesDir}/ (navigation and redirects; other top-level settings preserved unless newly scaffolded).`
     );
+    if (createdPackageJson) {
+      printDiagnosticsToConsole(
+        "Next: run npm install (or pnpm install / yarn) in this directory, then npm run dev."
+      );
+    }
   } catch (error) {
     await printCriticalFailureToConsoleAndExit(
       error instanceof Error ? error.message : String(error)
@@ -9504,7 +9755,7 @@ var preview_default = previewCommand;
 
 // src/cli/common/outdated.ts
 import { existsSync as existsSync2, mkdirSync } from "node:fs";
-import { readFile as readFile6, writeFile as writeFile8 } from "node:fs/promises";
+import { readFile as readFile7, writeFile as writeFile9 } from "node:fs/promises";
 import { join } from "node:path";
 import colors10 from "picocolors";
 import { gt } from "semver";
@@ -9554,12 +9805,12 @@ function box(message, {
 
 // src/cli/common/xdg/lib.ts
 import { homedir } from "node:os";
-import path31 from "node:path";
+import path32 from "node:path";
 function defineDirectoryWithFallback(xdgName, fallback) {
   if (process.env[xdgName]) {
     return process.env[xdgName];
   } else {
-    return path31.join(homedir(), fallback);
+    return path32.join(homedir(), fallback);
   }
 }
 var XDG_CONFIG_HOME = defineDirectoryWithFallback(
@@ -9574,15 +9825,15 @@ var XDG_STATE_HOME = defineDirectoryWithFallback(
   "XDG_DATA_HOME",
   ".local/state"
 );
-var ZUDOKU_XDG_CONFIG_HOME = path31.join(
+var ZUDOKU_XDG_CONFIG_HOME = path32.join(
   XDG_CONFIG_HOME,
   CLI_XDG_FOLDER_NAME
 );
-var ZUDOKU_XDG_DATA_HOME = path31.join(
+var ZUDOKU_XDG_DATA_HOME = path32.join(
   XDG_DATA_HOME,
   CLI_XDG_FOLDER_NAME
 );
-var ZUDOKU_XDG_STATE_HOME = path31.join(
+var ZUDOKU_XDG_STATE_HOME = path32.join(
   XDG_STATE_HOME,
   CLI_XDG_FOLDER_NAME
 );
@@ -9634,7 +9885,7 @@ async function getVersionCheckInfo() {
   let versionCheckInfo;
   if (existsSync2(versionCheckPath)) {
     try {
-      versionCheckInfo = await readFile6(versionCheckPath, "utf-8").then(
+      versionCheckInfo = await readFile7(versionCheckPath, "utf-8").then(
         JSON.parse
       );
     } catch {
@@ -9659,7 +9910,7 @@ async function getVersionCheckInfo() {
       lastCheck: Date.now(),
       latestVersion
     };
-    await writeFile8(
+    await writeFile9(
       versionCheckPath,
       JSON.stringify(versionCheckInfo),
       "utf-8"

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lukoweb/apitogo",
-  "version": "0.1.16",
+  "version": "0.1.17",
   "type": "module",
   "sideEffects": [
     "**/*.css",