idcmd 0.0.5 → 0.0.7

package/src/search/server-page.ts

@@ -10,7 +10,7 @@ import {
 } from "../site/config";
 import { resolveCanonicalUrl } from "../site/urls";
 import { loadSearchIndex, search as runSearch } from "./index";
-import { renderSearchPageContent } from "./page";
+import { getRenderSearchPageContent } from "./search-page-loader";
 
 export interface SearchPageHandlerEnv {
   cacheHeaders: HeadersInit;
@@ -37,40 +37,74 @@ const getResults = (
     ? runSearch(index, query, scope).slice(0, env.maxResults)
     : [];
 
+const getSearchQuery = (url: URL): string =>
+  url.searchParams.get("q")?.trim() ?? "";
+
+const loadSearchPageDependencies = async (options: {
+  isDev: boolean;
+  siteConfig: Awaited<ReturnType<typeof loadSiteConfig>>;
+}): Promise<{
+  navigation: Awaited<ReturnType<typeof getNavigation>>;
+  index: Awaited<ReturnType<typeof loadSearchIndex>>;
+  renderSearchPageContent: Awaited<
+    ReturnType<typeof getRenderSearchPageContent>
+  >;
+}> => {
+  const [navigation, index, renderSearchPageContent] = await Promise.all([
+    getNavigation(options.isDev),
+    loadSearchIndex({
+      forceRefresh: options.isDev,
+      siteConfig: options.siteConfig,
+    }),
+    getRenderSearchPageContent(),
+  ]);
+
+  return { index, navigation, renderSearchPageContent };
+};
+
+const getCanonicalSearchPageUrl = (options: {
+  baseUrl?: string;
+  env: SearchPageHandlerEnv;
+  url: URL;
+}): string | undefined =>
+  resolveCanonicalUrl(
+    {
+      configuredBaseUrl: options.baseUrl,
+      isDev: options.env.isDev,
+      requestOrigin: options.url.origin,
+    },
+    "/search/"
+  );
+
 const buildSearchPageHtml = async (
   url: URL,
   env: SearchPageHandlerEnv
 ): Promise<string> => {
   const siteConfig = await loadSiteConfig();
   const scope = getSearchScope(siteConfig);
-  const query = url.searchParams.get("q")?.trim() ?? "";
+  const query = getSearchQuery(url);
   const rightRail = resolveRightRailConfig(siteConfig.rightRail);
 
-  const [navigation, index] = await Promise.all([
-    getNavigation(env.isDev),
-    loadSearchIndex({ forceRefresh: env.isDev, siteConfig }),
-  ]);
+  const { index, navigation, renderSearchPageContent } =
+    await loadSearchPageDependencies({
+      isDev: env.isDev,
+      siteConfig,
+    });
 
   const results = getResults(index, query, scope, env);
-  const topPages = getTopPages(navigation);
   const content = renderSearchPageContent({
     minQueryLength: env.minQueryLength,
     query,
     results,
-    topPages,
+    topPages: getTopPages(navigation),
   });
 
-  const canonicalUrl = resolveCanonicalUrl(
-    {
-      configuredBaseUrl: siteConfig.baseUrl,
-      isDev: env.isDev,
-      requestOrigin: url.origin,
-    },
-    "/search/"
-  );
-
   return renderDocument({
-    canonicalUrl,
+    canonicalUrl: getCanonicalSearchPageUrl({
+      baseUrl: siteConfig.baseUrl,
+      env,
+      url,
+    }),
     contentHtml: content,
     currentPath: "/search/",
     description: siteConfig.description,

package/src/server/live-reload.ts

@@ -59,7 +59,7 @@ export const createLiveReload = (env: LiveReloadEnv): LiveReloadController => {
       return;
     }
 
-    console.log("Watching content/ for changes...");
+    console.log("Watching site/content/ for changes...");
     let snapshot = await getContentSnapshot();
 
     const poll = async (): Promise<void> => {
@@ -85,11 +85,7 @@ export const createLiveReload = (env: LiveReloadEnv): LiveReloadController => {
     server: ServerInstance,
     pathname: string
   ): "handled" | Response | undefined => {
-    // Backward compatible: accept both legacy and new websocket paths.
-    if (
-      !env.isDev ||
-      (pathname !== env.websocketPath && pathname !== "/__live-reload")
-    ) {
+    if (!env.isDev || pathname !== env.websocketPath) {
       return undefined;
     }
 

package/src/server/static.ts

@@ -46,7 +46,7 @@ export const serveStaticFile = async (
   pathname: string,
   env: ServeStaticEnv
 ): Promise<Response | null> => {
-  const roots = env.isDev ? [env.publicDir] : [env.distDir, env.publicDir];
+  const roots = [env.distDir, env.publicDir];
 
   for (const root of roots) {
     const served = await tryServeFileFromRoot(root, pathname, env);

package/src/server.ts

@@ -155,7 +155,6 @@ const maybeHandleCanonicalRedirect = (url: URL): Response | undefined => {
   const { pathname } = url;
 
   if (
-    pathname === "/__live-reload" ||
     pathname === `${project.assetPrefix}/live-reload` ||
     pathname.startsWith("/api/")
   ) {

package/src/site/config.ts

@@ -91,8 +91,7 @@ export interface ResolvedRightRailConfig {
   };
 }
 
-const LEGACY_SITE_CONFIG_PATH = "site.jsonc";
-const NEW_SITE_CONFIG_PATH = "site/site.jsonc";
+const SITE_CONFIG_PATH = "site/site.jsonc";
 const LOCALHOST_HOSTNAMES = new Set(["localhost", "127.0.0.1", "::1"]);
 
 const DEFAULT_RIGHT_RAIL_CONFIG: ResolvedRightRailConfig = {
@@ -220,15 +219,8 @@ const parseSiteConfigUnknown = (
   }
 };
 
-const resolveSiteConfigPath = async (): Promise<string> => {
-  if (await Bun.file(NEW_SITE_CONFIG_PATH).exists()) {
-    return NEW_SITE_CONFIG_PATH;
-  }
-  return LEGACY_SITE_CONFIG_PATH;
-};
-
 export const loadSiteConfig = async (): Promise<SiteConfig> => {
-  const configPath = await resolveSiteConfigPath();
+  const configPath = SITE_CONFIG_PATH;
   const file = Bun.file(configPath);
   if (!(await file.exists())) {
     return DEFAULT_SITE_CONFIG;

package/templates/default/.github/workflows/ci.yml

@@ -0,0 +1,24 @@
+name: CI
+
+on:
+  push:
+  pull_request:
+  workflow_dispatch:
+
+jobs:
+  ci:
+    runs-on: ubuntu-22.04
+    env:
+      CI: true
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v4
+      - name: Setup Bun
+        uses: oven-sh/setup-bun@v2
+      - name: Install dependencies
+        run: bun install
+      - name: Run checks
+        run: bun run check
+      - name: Run smoke
+        timeout-minutes: 15
+        run: bun run smoke

package/templates/default/README.md

@@ -2,6 +2,8 @@
 
 Everything you edit lives in `site/`.
 
+This starter is intentionally opinionated for AI-friendly markdown sites.
+
 ## Quickstart
 
 ```bash
@@ -9,13 +11,37 @@ bun install
 bun run dev
 ```
 
+## CI Smoke
+
+```bash
+bun run check
+bun run smoke
+```
+
 ## Layout
 
-- `site/content/` markdown pages (`index.md` -> `/`, `about.md` -> `/about/`)
-- `site/styles/tailwind.css` Tailwind entrypoint (compiled to `site/public/styles.css`)
-- `site/public/` static assets
-- `site/server/routes/` file-based server routes (dev/server-host only)
-- `site/site.jsonc` site configuration
+- Content: `site/content/` markdown pages (`index.md` -> `/`, `about.md` -> `/about/`)
+- Code: `site/code/ui/` (`layout.tsx`, `right-rail.tsx`, `search-page.tsx`)
+- Code: `site/code/runtime/` browser runtime TS (`*_idcmd` scripts compile from here)
+- Code: `site/code/routes/` file-based server routes (dev/server-host only)
+- Assets: `site/assets/` static files you own (icons, images, favicon, etc.)
+- Styles source: `site/styles/tailwind.css`
+- Config: `site/site.jsonc`
+- Generated output: `dist/` (`dist/styles.css`, `dist/_idcmd/*.js`, built pages)
+
+The mental model is simple: edit `site/content` and `site/code`, treat `dist/` as generated output.
+
+## Sync Local Client Files
+
+```bash
+idcmd client add all
+idcmd client update all --dry-run
+idcmd client update layout --yes
+idcmd client update runtime --yes
+```
+
+These commands copy the latest baseline implementations from `idcmd` into `site/code/ui/` and `site/code/runtime/`.
+Runtime files in `site/code/runtime/` are compiled automatically by `idcmd dev` and `idcmd build`.
 
 ## Deploy (Vercel static)
 

package/templates/default/package.json

@@ -7,7 +7,8 @@
     "build": "idcmd build",
     "preview": "idcmd preview",
     "deploy": "idcmd deploy",
-    "check": "ultracite check && bun run typecheck && bun run test",
+    "check": "bun run scripts/check.ts",
+    "smoke": "bun run scripts/smoke.ts",
     "test": "bun test",
     "typecheck": "tsc --noEmit -p tsconfig.json",
     "fix": "ultracite fix"

package/templates/default/scripts/check-internal.ts

@@ -0,0 +1,56 @@
+interface InternalCheck {
+  description: string;
+  run: () => Promise<boolean>;
+}
+
+const fileExists = (path: string): Promise<boolean> => Bun.file(path).exists();
+
+const checks: InternalCheck[] = [
+  {
+    description: "package.json must exist at the project root",
+    run: () => fileExists("package.json"),
+  },
+  {
+    description: "site config must exist (site/site.jsonc)",
+    run: () => fileExists("site/site.jsonc"),
+  },
+  {
+    description: "tailwind input must exist (site/styles/tailwind.css)",
+    run: () => fileExists("site/styles/tailwind.css"),
+  },
+  {
+    description: "site code UI entry must exist (site/code/ui/layout.tsx)",
+    run: () => fileExists("site/code/ui/layout.tsx"),
+  },
+];
+
+const runInternalChecks = async (): Promise<string[]> => {
+  const failures: string[] = [];
+
+  for (const check of checks) {
+    // eslint-disable-next-line no-await-in-loop
+    const ok = await check.run();
+    if (!ok) {
+      failures.push(check.description);
+    }
+  }
+
+  return failures;
+};
+
+const main = async (): Promise<number> => {
+  const failures = await runInternalChecks();
+  if (failures.length === 0) {
+    console.log("Internal checks passed.");
+    return 0;
+  }
+
+  console.error("Internal checks failed:");
+  for (const failure of failures) {
+    console.error(`- ${failure}`);
+  }
+  return 1;
+};
+
+const code = await main();
+process.exit(code);

package/templates/default/scripts/check.ts

@@ -0,0 +1,332 @@
+type StepStatus = "pass" | "fail";
+
+export interface CheckStep {
+  command: string[];
+  id: string;
+  name: string;
+}
+
+export interface StepResult {
+  durationMs: number;
+  output: string;
+  status: StepStatus;
+  step: CheckStep;
+}
+
+interface TruncatedOutput {
+  omittedLines: number;
+  text: string;
+}
+
+interface StepCounts {
+  failed: number;
+  passed: number;
+  status: StepStatus;
+}
+
+const LINT_CONFIG_ERROR =
+  "No linter configuration found. Run `bun x ultracite init` once in this project.";
+const NO_TESTS_MESSAGE = "No tests found; skipping test step.";
+const MAX_OUTPUT_LINES = 120;
+const LINT_TARGETS = [
+  "README.md",
+  "package.json",
+  "tsconfig.json",
+  "vercel.json",
+  ".oxlintrc.json",
+  ".oxfmtrc.jsonc",
+  "scripts",
+  "site/code",
+  "site/content",
+  "site/assets",
+  "site/styles",
+  "site/site.jsonc",
+];
+const ROOT_TEST_FILE_PATTERNS = [
+  "*.test.ts",
+  "*.test.tsx",
+  "*.test.js",
+  "*.test.jsx",
+  "*_test_*.ts",
+  "*_test_*.tsx",
+  "*_test_*.js",
+  "*_test_*.jsx",
+  "*.spec.ts",
+  "*.spec.tsx",
+  "*.spec.js",
+  "*.spec.jsx",
+  "*_spec_*.ts",
+  "*_spec_*.tsx",
+  "*_spec_*.js",
+  "*_spec_*.jsx",
+];
+const NESTED_TEST_FILE_PATTERNS = [
+  "**/*.test.ts",
+  "**/*.test.tsx",
+  "**/*.test.js",
+  "**/*.test.jsx",
+  "**/*_test_*.ts",
+  "**/*_test_*.tsx",
+  "**/*_test_*.js",
+  "**/*_test_*.jsx",
+  "**/*.spec.ts",
+  "**/*.spec.tsx",
+  "**/*.spec.js",
+  "**/*.spec.jsx",
+  "**/*_spec_*.ts",
+  "**/*_spec_*.tsx",
+  "**/*_spec_*.js",
+  "**/*_spec_*.jsx",
+];
+const TEST_SOURCE_DIRS = ["site", "scripts", "src", "tests"];
+
+const buildScopedTestFilePatterns = (): string[] => {
+  const patterns = [...ROOT_TEST_FILE_PATTERNS];
+
+  for (const dir of TEST_SOURCE_DIRS) {
+    for (const nestedPattern of NESTED_TEST_FILE_PATTERNS) {
+      patterns.push(`${dir}/${nestedPattern}`);
+    }
+  }
+
+  return patterns;
+};
+const SCOPED_TEST_FILE_PATTERNS = buildScopedTestFilePatterns();
+
+const steps: CheckStep[] = [
+  {
+    command: [process.execPath, "scripts/check-internal.ts"],
+    id: "internal",
+    name: "Internal",
+  },
+  {
+    command: [process.execPath, "x", "ultracite", "check", ...LINT_TARGETS],
+    id: "lint",
+    name: "Lint",
+  },
+  {
+    command: [process.execPath, "run", "typecheck"],
+    id: "typecheck",
+    name: "Typecheck",
+  },
+  {
+    command: [process.execPath, "run", "test"],
+    id: "tests",
+    name: "Tests",
+  },
+];
+
+const hasAnyLinterConfig = async (): Promise<boolean> => {
+  const candidates = [
+    ".oxlintrc.json",
+    "eslint.config.js",
+    "eslint.config.cjs",
+    "eslint.config.mjs",
+    "eslint.config.ts",
+    "eslint.config.cts",
+    "eslint.config.mts",
+  ];
+
+  for (const file of candidates) {
+    // eslint-disable-next-line no-await-in-loop
+    if (await Bun.file(file).exists()) {
+      return true;
+    }
+  }
+
+  return false;
+};
+
+const hasAnyFilesMatching = async (pattern: string): Promise<boolean> => {
+  const glob = new Bun.Glob(pattern);
+  for await (const _path of glob.scan(".")) {
+    return true;
+  }
+  return false;
+};
+
+const hasAnyTestFiles = async (): Promise<boolean> => {
+  for (const pattern of SCOPED_TEST_FILE_PATTERNS) {
+    // eslint-disable-next-line no-await-in-loop
+    if (await hasAnyFilesMatching(pattern)) {
+      return true;
+    }
+  }
+  return false;
+};
+
+const isFailure = (result: StepResult): boolean => result.status === "fail";
+
+const runCommandStep = async (step: CheckStep): Promise<StepResult> => {
+  const startedAt = performance.now();
+  const child = Bun.spawn(step.command, {
+    cwd: process.cwd(),
+    stderr: "pipe",
+    stdout: "pipe",
+  });
+
+  const [stdout, stderr, exitCode] = await Promise.all([
+    new Response(child.stdout).text(),
+    new Response(child.stderr).text(),
+    child.exited,
+  ]);
+
+  return {
+    durationMs: Math.round(performance.now() - startedAt),
+    output: `${stdout}${stderr}`.trim(),
+    status: exitCode === 0 ? "pass" : "fail",
+    step,
+  };
+};
+
+const lintConfigFailure = (step: CheckStep): StepResult => ({
+  durationMs: 0,
+  output: LINT_CONFIG_ERROR,
+  status: "fail",
+  step,
+});
+
+const skippedTestsResult = (step: CheckStep): StepResult => ({
+  durationMs: 0,
+  output: NO_TESTS_MESSAGE,
+  status: "pass",
+  step,
+});
+
+const runStep = async (step: CheckStep): Promise<StepResult> => {
+  if (step.id === "lint" && !(await hasAnyLinterConfig())) {
+    return lintConfigFailure(step);
+  }
+  if (step.id === "tests" && !(await hasAnyTestFiles())) {
+    return skippedTestsResult(step);
+  }
+
+  return runCommandStep(step);
+};
+
+const runSteps = async (): Promise<StepResult[]> => {
+  const results: StepResult[] = [];
+
+  for (const step of steps) {
+    // eslint-disable-next-line no-await-in-loop
+    const result = await runStep(step);
+    results.push(result);
+
+    if (isFailure(result)) {
+      break;
+    }
+  }
+
+  return results;
+};
+
+export const truncateOutput = (
+  output: string,
+  maxLines = MAX_OUTPUT_LINES
+): TruncatedOutput => {
+  const normalized = output.trim();
+  if (normalized.length === 0) {
+    return { omittedLines: 0, text: "" };
+  }
+
+  const lines = normalized.split("\n");
+  if (lines.length <= maxLines) {
+    return { omittedLines: 0, text: normalized };
+  }
+
+  return {
+    omittedLines: lines.length - maxLines,
+    text: lines.slice(0, maxLines).join("\n"),
+  };
+};
+
+const getCounts = (results: StepResult[]): StepCounts => {
+  const failed = results.filter(isFailure).length;
+  const passed = results.length - failed;
+  return {
+    failed,
+    passed,
+    status: failed === 0 ? "pass" : "fail",
+  };
+};
+
+const buildHeaderLines = (results: StepResult[]): string[] => {
+  const counts = getCounts(results);
+  return [
+    "# Check Report",
+    "",
+    `- status: ${counts.status}`,
+    `- steps_total: ${results.length}`,
+    `- steps_passed: ${counts.passed}`,
+    `- steps_failed: ${counts.failed}`,
+    "",
+  ];
+};
+
+const buildFailureOutputLines = (output: string): string[] => {
+  if (output.length === 0) {
+    return [];
+  }
+
+  const truncated = truncateOutput(output);
+  const lines = ["", "### Output", "", "```text", truncated.text];
+
+  if (truncated.omittedLines > 0) {
+    lines.push(`[truncated: omitted ${truncated.omittedLines} lines]`);
+  }
+
+  lines.push("```");
+  return lines;
+};
+
+const buildStepLines = (result: StepResult): string[] => {
+  const lines = [
+    `## ${result.step.name}`,
+    "",
+    `- status: ${result.status}`,
+    `- duration_ms: ${result.durationMs}`,
+  ];
+
+  if (isFailure(result)) {
+    lines.push(...buildFailureOutputLines(result.output));
+  }
+
+  lines.push("");
+  return lines;
+};
+
+const buildSummaryRows = (results: StepResult[]): string[] =>
+  results.map(
+    (result) =>
+      `| ${result.step.name} | ${result.status.toUpperCase()} | ${String(
+        result.durationMs
+      )} |`
+  );
+
+const buildSummaryLines = (results: StepResult[]): string[] => [
+  "## Summary",
+  "",
+  "| Step | Status | Duration (ms) |",
+  "| --- | --- | ---: |",
+  ...buildSummaryRows(results),
+];
+
+export const renderReport = (results: StepResult[]): string => {
+  const lines = [
+    ...buildHeaderLines(results),
+    ...results.flatMap(buildStepLines),
+    ...buildSummaryLines(results),
+  ];
+  return `${lines.join("\n")}\n`;
+};
+
+const runCheck = async (): Promise<number> => {
+  const results = await runSteps();
+  process.stdout.write(renderReport(results));
+  return results.some(isFailure) ? 1 : 0;
+};
+
+if (import.meta.main) {
+  const code = await runCheck();
+  process.exit(code);
+}