@cursor/july 0.1.41 → 0.1.43

package/src/internal/init-project.ts

@@ -3,13 +3,14 @@
  */
 
 import { spawn } from "node:child_process";
-import { existsSync } from "node:fs";
-import { mkdir, writeFile } from "node:fs/promises";
+import { existsSync, readdirSync, readFileSync } from "node:fs";
+import { mkdir, readdir, readFile, writeFile } from "node:fs/promises";
 import { basename, dirname, join, relative, resolve } from "node:path";
 import type { ModelSetting } from "../types.js";
 import {
   CLI_COMMAND_NAME,
   PACKAGE_NAME,
+  packageRootDir,
   packageVersion,
 } from "./distribution.js";
 import {
@@ -25,6 +26,7 @@ export interface InitProjectOptions {
   name?: string;
   /** Model id override written into agent.ts. */
   model?: string;
+  templateDir?: string;
 }
 
 export type InitFileAction = "create" | "exist";
@@ -44,6 +46,99 @@ export interface InitProjectResult {
   skipped: string[];
 }
 
+export function availableTemplates(): string[] {
+  const templatesDir = join(packageRootDir(), "templates");
+  try {
+    return readdirSync(templatesDir, { withFileTypes: true })
+      .filter((entry) => entry.isDirectory())
+      .map((entry) => entry.name)
+      .sort();
+  } catch (error) {
+    if (hasErrorCode(error, "ENOENT")) {
+      return [];
+    }
+    throw error;
+  }
+}
+
+export type TemplateResolution =
+  | { ok: true; name: string; dir: string }
+  | { ok: false; message: string };
+
+export function resolveTemplate(name: string): TemplateResolution {
+  if (!/^[a-z][a-z0-9-]*$/.test(name)) {
+    return {
+      ok: false,
+      message: "template name must match /^[a-z][a-z0-9-]*$/",
+    };
+  }
+  const available = availableTemplates();
+  if (!available.includes(name)) {
+    const detail =
+      available.length === 0
+        ? "no templates ship with this build"
+        : `available: ${available.join(", ")}`;
+    return {
+      ok: false,
+      message: `unknown template "${name}" (${detail})`,
+    };
+  }
+  return {
+    ok: true,
+    name,
+    dir: join(packageRootDir(), "templates", name),
+  };
+}
+
+export type InitTargetCheck = { ok: true } | { ok: false; message: string };
+
+/**
+ * Re-init must keep the mode the project was scaffolded with: template
+ * scaffolds stamp `cursorAgentTemplate` into package.json, and a mismatch
+ * here would silently mix default-scaffold files into a template project
+ * (or the reverse).
+ */
+export function checkInitTarget(
+  rootDir: string,
+  template: string | undefined
+): InitTargetCheck {
+  const pkgPath = join(rootDir, "package.json");
+  if (!existsSync(pkgPath)) {
+    return { ok: true };
+  }
+  let marker: string | undefined;
+  try {
+    const pkg = JSON.parse(readFileSync(pkgPath, "utf8")) as {
+      cursorAgentTemplate?: unknown;
+    };
+    marker =
+      typeof pkg.cursorAgentTemplate === "string"
+        ? pkg.cursorAgentTemplate
+        : undefined;
+  } catch {
+    marker = undefined;
+  }
+  if (marker === template) {
+    return { ok: true };
+  }
+  if (template === undefined) {
+    return {
+      ok: false,
+      message: `${rootDir} was scaffolded from the "${marker}" template; re-run with --template ${marker}`,
+    };
+  }
+  if (marker === undefined) {
+    return {
+      ok: false,
+      message: `${rootDir} already has a package.json without template provenance; re-run init without --template, or scaffold into a fresh directory`,
+    };
+  }
+  return {
+    ok: false,
+    message: `${rootDir} was scaffolded from the "${marker}" template, not "${template}"`,
+  };
+}
+
 const DEFAULT_MODEL: ModelSetting = {
   id: "grok-4.5",
   params: [
@@ -73,13 +168,15 @@ export async function initProject(
   options: InitProjectOptions
 ): Promise<InitProjectResult> {
   const rootDir = resolve(options.dir);
-  const name = options.name ?? basename(rootDir);
+  const projectName = basename(rootDir);
+  const name = options.name ?? projectName;
   const model = formatModelLiteral(options.model ?? DEFAULT_MODEL);
-  const agentDir = join(rootDir, "agent");
-  await mkdir(agentDir, { recursive: true });
 
   const files: InitFileEntry[] = [];
-  const write = async (rel: string, contents: string): Promise<void> => {
+  const write = async (
+    rel: string,
+    contents: string | Uint8Array
+  ): Promise<void> => {
     const abs = join(rootDir, rel);
     await mkdir(dirname(abs), { recursive: true });
     try {
@@ -95,6 +192,47 @@ export async function initProject(
     }
   };
 
+  if (options.templateDir !== undefined) {
+    const templateDir = options.templateDir;
+    const entries = await readdir(templateDir, {
+      recursive: true,
+      withFileTypes: true,
+    });
+    const relativePaths = entries
+      .filter((entry) => entry.isFile())
+      .map((entry) => relative(templateDir, join(entry.parentPath, entry.name)))
+      .sort();
+    for (const rel of relativePaths) {
+      const source = join(templateDir, rel);
+      if (rel === "package.json") {
+        const packageJson: {
+          name: string;
+          dependencies: Record<string, string>;
+          [key: string]: unknown;
+        } = JSON.parse(await readFile(source, "utf8"));
+        packageJson.name = projectName;
+        packageJson.dependencies[PACKAGE_NAME] = `^${packageVersion()}`;
+        packageJson.cursorAgentTemplate = basename(templateDir);
+        await write(rel, `${JSON.stringify(packageJson, null, 2)}\n`);
+      } else {
+        await write(rel, await readFile(source));
+      }
+    }
+    return {
+      rootDir,
+      files,
+      created: files
+        .filter((entry) => entry.action === "create")
+        .map((entry) => entry.path),
+      skipped: files
+        .filter((entry) => entry.action === "exist")
+        .map((entry) => entry.path),
+    };
+  }
+
+  const agentDir = join(rootDir, "agent");
+  await mkdir(agentDir, { recursive: true });
+
   await write(
     "package.json",
     `${JSON.stringify(
@@ -209,11 +347,15 @@ export default memoryHook();
 }
 
 export function isEexist(error: unknown): boolean {
+  return hasErrorCode(error, "EEXIST");
+}
+
+function hasErrorCode(error: unknown, code: string): boolean {
   return (
     error !== null &&
     typeof error === "object" &&
     "code" in error &&
-    (error as { code: string }).code === "EEXIST"
+    error.code === code
   );
 }
 
@@ -598,6 +740,7 @@ export function printInitGuide(): void {
 
 Scaffold a project, then open the playground:
   npx ${PACKAGE_NAME} init ./my-agent   # installs deps + puts agent-sdk on PATH
+  npx ${PACKAGE_NAME} init ./my-triage --template triage   # start from a template (agent-sdk templates: triage)
   cd ./my-agent && ${CLI_COMMAND_NAME} dev
 
 Recommended loop once the project exists (from the project directory):

package/src/internal/otel/attrs.ts

@@ -0,0 +1,18 @@
+/**
+ * Build OTel attribute maps without conditional spreads. `undefined` values
+ * are dropped (the OTel API rejects them).
+ */
+
+export type AttrValue = string | number | boolean;
+
+export function attrs(
+  input: Record<string, AttrValue | undefined>
+): Record<string, AttrValue> {
+  const out: Record<string, AttrValue> = {};
+  for (const [key, value] of Object.entries(input)) {
+    if (value !== undefined) {
+      out[key] = value;
+    }
+  }
+  return out;
+}