@archpilotlabs/archpilot 0.0.12 → 0.0.13

package/dist/archpilot-cli.js

@@ -215113,6 +215113,16 @@ async function writeFileIfMissing(filePath, contents) {
   await import_node_fs7.promises.writeFile(filePath, contents, { encoding: "utf8" });
   return true;
 }
+function labelTenantModel(model) {
+  switch (model) {
+    case "single_tenant":
+      return "Single tenant (one tenant per deployment)";
+    case "same_db_same_schema":
+      return "Multi-tenant: same DB, same schema (tenant_id discriminator)";
+    case "same_db_different_schema":
+      return "Multi-tenant: same DB, different schema per tenant";
+  }
+}
 function defaultArchitectureContractSections(config) {
   const apiEnabled = config?.apiStyle !== "none";
   const databaseEnabled = config?.database !== "none";
@@ -215420,6 +215430,157 @@ function buildDefaultModuleContractPath(moduleName, contract) {
   const safeModuleName = moduleName.replace(/\\/g, "/").split("/").map((segment) => segment.trim()).filter((segment) => segment.length > 0).join(".");
   return `${contractsRoot}/${safeModuleName}.contract.json`;
 }
+function buildDefaultModulePublicEntrypoints(moduleName, contract) {
+  const modulesRoot = resolveModulesRootFromContract(contract);
+  const adapter = resolvePrimaryAdapterFromContract(contract);
+  const moduleIndexFileName = adapter.scaffoldingDefaults?.moduleIndexFileName ?? "index.ts";
+  const entrypoints = [`${modulesRoot}/${moduleName}/${moduleIndexFileName}`];
+  const publicDirectoryName = adapter.publicEntrypointDirectoryNames[0];
+  if (publicDirectoryName && publicDirectoryName.trim().length > 0) {
+    entrypoints.push(`${modulesRoot}/${moduleName}/${publicDirectoryName}`);
+  }
+  return entrypoints;
+}
+function overviewTemplate(config) {
+  const stackSummary = [
+    config.stacks.backendStack ? `backend=${config.stacks.backendStack}` : void 0,
+    config.stacks.frontendStack ? `frontend=${config.stacks.frontendStack}` : void 0,
+    config.stacks.libraryStack ? `library=${config.stacks.libraryStack}` : void 0
+  ].filter((entry) => typeof entry === "string").join(", ");
+  return `# Architecture Overview
+
+## Summary
+- **Project**: ${config.projectName}
+- **Repository topology**: ${config.repoTopology}
+- **Project kinds**: ${config.projectKinds.join(", ")}
+- **Stacks**: ${stackSummary.length > 0 ? stackSummary : "not specified"}
+- **Architecture style**: ${config.architectureStyle}
+- **API style**: ${config.apiStyle}
+- **Auth style**: ${config.authStyle}
+- **Database**: ${config.database}
+- **Tenant model**: ${config.tenantModel} - ${labelTenantModel(config.tenantModel)}
+
+## Implementation notes
+- This repository was initialized by **ArchPilot** in offline mode.
+- Edit \`.archpilot/architecture.json\` to reflect future decisions.
+
+## Next steps
+- Add service/module boundaries (packages or folders) consistent with **${config.architectureStyle}**.
+- Expand the API contract in \`contracts/openapi.yaml\`.
+- Add additional ADRs as decisions are made.
+`;
+}
+function adrTenantModelTemplate(config) {
+  const decision = labelTenantModel(config.tenantModel);
+  const schemaNotes = config.tenantModel === "same_db_different_schema" ? "- Each tenant maps to a dedicated schema.\n- Cross-tenant access is prevented via schema isolation." : config.tenantModel === "same_db_same_schema" ? "- Shared schema with a required `tenant_id` discriminator on tenant-scoped tables.\n- Access control must filter by `tenant_id` at all data access boundaries." : "- Tenant isolation is achieved by separate deployments/environments.\n- Data separation is handled operationally rather than in-schema.";
+  return `# ADR-001: Tenant model
+
+Status: Accepted
+
+## Context
+${config.projectName} needs a tenant strategy that matches the product and operational model.
+
+Chosen inputs:
+- **Tenant model**: ${config.tenantModel}
+- **Database**: ${config.database}
+- **Architecture style**: ${config.architectureStyle}
+
+## Decision
+We will use: **${decision}**.
+
+## Consequences
+${schemaNotes}
+
+- We will document tenant boundaries in endpoints, data model, and operational runbooks.
+- We will revisit this decision if scaling, compliance, or customer isolation requirements change.
+
+## Alternatives Considered
+Optional.
+
+## Migration Plan
+Optional.
+
+## References
+Optional.
+`;
+}
+function openApiTemplate(config) {
+  const paths = config.apiStyle === "graphql" ? `  /graphql:
+    post:
+      summary: GraphQL endpoint
+      requestBody:
+        required: true
+        content:
+          application/json:
+            schema:
+              type: object
+              properties:
+                query:
+                  type: string
+      responses:
+        '200':
+          description: OK
+` : `  /health:
+    get:
+      summary: Health check
+      responses:
+        '200':
+          description: OK
+`;
+  const securitySchemes = config.authStyle === "jwt" ? `    bearerAuth:
+      type: http
+      scheme: bearer
+      bearerFormat: JWT
+` : `    cookieAuth:
+      type: apiKey
+      in: cookie
+      name: session
+`;
+  return `openapi: 3.0.3
+info:
+  title: ${config.projectName} API
+  version: 0.1.0
+servers:
+  - url: http://localhost:3000
+paths:
+${paths}components:
+  securitySchemes:
+${securitySchemes}`;
+}
+function sqlTemplate(config) {
+  const tenantColumnsSameSchema = config.tenantModel === "same_db_same_schema" ? config.database === "postgresql" ? `  tenant_id UUID NOT NULL,
+` : `  tenant_id CHAR(36) NOT NULL,
+` : "";
+  const idColumn = config.database === "postgresql" ? `id UUID PRIMARY KEY` : `id CHAR(36) PRIMARY KEY`;
+  const createdAtColumn = config.database === "postgresql" ? `created_at TIMESTAMPTZ NOT NULL DEFAULT NOW()` : `created_at TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP`;
+  if (config.database === "postgresql") {
+    return `-- ArchPilot initialization SQL (PostgreSQL)
+
+CREATE TABLE IF NOT EXISTS app_user (
+  ${idColumn},
+${tenantColumnsSameSchema}  email TEXT NOT NULL UNIQUE,
+  ${createdAtColumn}
+);
+`;
+  }
+  return `-- ArchPilot initialization SQL (MySQL)
+
+CREATE TABLE IF NOT EXISTS app_user (
+  ${idColumn},
+${tenantColumnsSameSchema}  email VARCHAR(320) NOT NULL UNIQUE,
+  ${createdAtColumn}
+);
+`;
+}
+var defaultLayerRulesTemplate = `{
+  "layers": ["api", "service", "domain", "infrastructure"],
+  "moduleLayers": {}
+}
+`;
+var defaultDependencyRulesTemplate = `{
+  "modules": {}
+}
+`;
 async function loadArchitectureContract(workspaceRoot) {
   const configPath = path8.join(workspaceRoot, ".archpilot", "architecture.json");
   const contents = await import_node_fs7.promises.readFile(configPath, { encoding: "utf8" }).catch(() => void 0);
@@ -215469,12 +215630,115 @@ async function saveArchitectureContract(workspaceRoot, contract) {
     encoding: "utf8"
   });
 }
+async function writeArchitectureConfig(workspaceRoot, inputs) {
+  const baseConfig = {
+    version: 1,
+    ...inputs,
+    rbac: false,
+    createdAtUtc: nowUtcIso()
+  };
+  const configDir = path8.join(workspaceRoot, ".archpilot");
+  const configPath = path8.join(configDir, "architecture.json");
+  await ensureDir(configDir);
+  let config = buildArchitectureContract(baseConfig);
+  const existingContract = await loadArchitectureContract(workspaceRoot);
+  if (existingContract) {
+    config = buildArchitectureContract(baseConfig, existingContract);
+  }
+  const normalizedModulesRoot = typeof inputs.modulesRoot === "string" ? inputs.modulesRoot.trim() : "";
+  if (normalizedModulesRoot.length > 0) {
+    config.structure.modulesRoot = normalizedModulesRoot;
+  }
+  const normalizedModules = Array.isArray(inputs.modules) ? inputs.modules.map((entry) => typeof entry === "string" ? entry.trim() : "").filter((entry) => entry.length > 0).filter((entry, index, array) => array.indexOf(entry) === index) : [];
+  if (normalizedModules.length > 0) {
+    const moduleRegistry = {};
+    for (const moduleName of normalizedModules) {
+      moduleRegistry[moduleName] = {
+        path: `${resolveModulesRootFromContract(config)}/${moduleName}`,
+        contract: buildDefaultModuleContractPath(moduleName, config),
+        publicEntrypoints: buildDefaultModulePublicEntrypoints(moduleName, config)
+      };
+    }
+    config.modules = moduleRegistry;
+  }
+  const components = normalizeArchitectureComponents(inputs.components);
+  if (components) {
+    config.components = components;
+  }
+  const resources = normalizeArchitectureResources(inputs.resources);
+  if (resources) {
+    config.resources = resources;
+  }
+  await saveArchitectureContract(workspaceRoot, config);
+  return config;
+}
+async function generateDocs(workspaceRoot, config) {
+  await writeFileIfMissing(
+    path8.join(workspaceRoot, "docs", "architecture", "overview.md"),
+    overviewTemplate(config)
+  );
+  await writeFileIfMissing(
+    path8.join(workspaceRoot, "docs", "adrs", ADR_TEMPLATE_FILE_NAME),
+    canonicalAdrTemplate
+  );
+  await writeFileIfMissing(
+    path8.join(workspaceRoot, "docs", "adrs", "adr-001-tenant-model.md"),
+    adrTenantModelTemplate(config)
+  );
+}
+async function generateContracts(workspaceRoot, config) {
+  if (!hasConfiguredApi(config)) {
+    return;
+  }
+  await writeFileIfMissing(
+    path8.join(workspaceRoot, "contracts", "openapi.yaml"),
+    openApiTemplate(config)
+  );
+}
+async function generateDatabaseFiles(workspaceRoot, config) {
+  if (!hasConfiguredDatabase(config)) {
+    return;
+  }
+  await writeFileIfMissing(
+    path8.join(workspaceRoot, "db", "sql", "001_init.sql"),
+    sqlTemplate(config)
+  );
+}
+async function generateArchpilotConfigFiles(workspaceRoot) {
+  await writeFileIfMissing(
+    path8.join(workspaceRoot, ".archpilot", "layer-rules.json"),
+    defaultLayerRulesTemplate
+  );
+  await writeFileIfMissing(
+    path8.join(workspaceRoot, ".archpilot", "dependency-rules.json"),
+    defaultDependencyRulesTemplate
+  );
+  await writeFileIfMissing(
+    path8.join(workspaceRoot, ".archpilot", "suppressions.json"),
+    '{\n  "suppressions": []\n}\n'
+  );
+}
 async function ensureArchpilotIgnoreFile(workspaceRoot) {
   return writeFileIfMissing(
     path8.join(workspaceRoot, archpilotIgnoreFileName),
     defaultArchpilotIgnoreContent
   );
 }
+async function applyArchitectureInitialization(workspaceRoot, inputs) {
+  const config = await writeArchitectureConfig(workspaceRoot, inputs);
+  await generateDocs(workspaceRoot, config);
+  await generateContracts(workspaceRoot, config);
+  await generateDatabaseFiles(workspaceRoot, config);
+  await generateArchpilotConfigFiles(workspaceRoot);
+  const archpilotIgnoreFileCreated = await ensureArchpilotIgnoreFile(workspaceRoot);
+  const policyInitResult = await ensureRiskPolicyFile(workspaceRoot);
+  await refreshSetupNextStepsForWorkspace({ workspaceRoot });
+  return {
+    config,
+    policyFileCreated: policyInitResult.created,
+    archpilotIgnoreFileCreated
+  };
+}
 
 // ../core/src/architectureDriftDetection.ts
 var driftAreaOrder = [
@@ -238052,7 +238316,7 @@ function renderGovernanceUploadSkippedByPlan() {
   ].join("\n");
 }
 function printUsage() {
-  console.error("Usage: archpilot init");
+  console.error("Usage: archpilot init [--yes]");
   console.error("Usage: archpilot validate [--ci] [--json] [--changed] [--diff] [--base <branch>]");
   console.error("       archpilot impact <file-or-module> [--json] [--stdout] [--module] [--force]");
   console.error("       archpilot fix <RULE_ID>");
@@ -238127,7 +238391,10 @@ var cliHelpTopics = [
   {
     commandPath: ["init"],
     lines: [
-      "Usage: archpilot init"
+      "Usage: archpilot init [--yes]",
+      "",
+      "Options:",
+      "  --yes                accept detected Smart Init defaults without prompts"
     ]
   },
   {
@@ -238703,6 +238970,430 @@ function parseCloudConnectFlags(args) {
     ...readFlagValue(args, "--server") ? { server: readFlagValue(args, "--server") } : {}
   };
 }
+var initWizardSteps = [
+  { id: "detection", title: "Detection Summary" },
+  { id: "project", title: "Repository Profile" },
+  { id: "components", title: "Components" },
+  { id: "modules", title: "Modules and API" },
+  { id: "resources", title: "Resources" },
+  { id: "review", title: "Review" }
+];
+function parseInitFlags(args) {
+  if (args.some((argument) => argument !== "--yes" && argument !== "-y")) {
+    return void 0;
+  }
+  return { yes: args.includes("--yes") || args.includes("-y") };
+}
+function isValidRepoTopology(value) {
+  return value === "single_project" || value === "monorepo";
+}
+function isValidProjectKind(value) {
+  return value === "backend" || value === "frontend" || value === "library";
+}
+function isValidArchitectureStyle(value) {
+  return value === "modular_monolith" || value === "microservices";
+}
+function isValidDatabaseChoice(value) {
+  return value === "none" || value === "postgresql" || value === "mysql";
+}
+function isValidApiStyle(value) {
+  return value === "none" || value === "rest" || value === "graphql";
+}
+function isValidAuthStyle(value) {
+  return value === "jwt" || value === "session";
+}
+function isValidTenantModel(value) {
+  return value === "single_tenant" || value === "same_db_same_schema" || value === "same_db_different_schema";
+}
+function normalizeProjectKindsForInit(value) {
+  const kinds = Array.isArray(value) ? value.filter((entry) => typeof entry === "string" && isValidProjectKind(entry)) : [];
+  return kinds.length > 0 ? [...new Set(kinds)].sort((left, right) => left.localeCompare(right)) : ["backend"];
+}
+function normalizeCanonicalStackId(value) {
+  const validStacks = /* @__PURE__ */ new Set([
+    "node_typescript",
+    "express",
+    "nestjs",
+    "java",
+    "spring",
+    "fastapi",
+    "django",
+    "flask",
+    "python",
+    "php",
+    "laravel",
+    "go",
+    "dotnet",
+    "ruby_rails",
+    "kotlin",
+    "kotlin_spring",
+    "rust",
+    "react",
+    "angular",
+    "vue",
+    "nextjs",
+    "terraform",
+    "ansible",
+    "library_generic",
+    "other"
+  ]);
+  return typeof value === "string" && validStacks.has(value) ? value : void 0;
+}
+function normalizeStackSlotsForInit(proposal, projectKinds) {
+  const selections = proposal.stackSelections ?? {};
+  const backendStack = normalizeCanonicalStackId(selections.backend);
+  const frontendStack = normalizeCanonicalStackId(selections.frontend);
+  const libraryStack = normalizeCanonicalStackId(selections.library);
+  const fallbackStack = normalizeCanonicalStackId(
+    proposal.detectedComponents?.find((component) => normalizeCanonicalStackId(component.stack))?.stack
+  );
+  return {
+    ...projectKinds.includes("backend") ? { backendStack: backendStack ?? fallbackStack ?? "other" } : {},
+    ...projectKinds.includes("frontend") ? { frontendStack: frontendStack ?? fallbackStack ?? "other" } : {},
+    ...projectKinds.includes("library") ? { libraryStack: libraryStack ?? fallbackStack ?? "library_generic" } : {}
+  };
+}
+function sanitizeArchitectureComponentsForInit(components) {
+  if (!Array.isArray(components)) {
+    return void 0;
+  }
+  const sanitized = components.map((component, index) => ({
+    ...component,
+    id: typeof component.id === "string" && component.id.trim().length > 0 ? component.id.trim() : `component-${index + 1}`,
+    name: typeof component.name === "string" && component.name.trim().length > 0 ? component.name.trim() : typeof component.id === "string" ? component.id : `Component ${index + 1}`
+  })).filter((component) => typeof component.id === "string" && component.id.length > 0);
+  return sanitized.length > 0 ? sanitized : void 0;
+}
+function sanitizeArchitectureResourcesForInit(resources) {
+  if (!Array.isArray(resources)) {
+    return void 0;
+  }
+  const sanitized = resources.map((resource, index) => ({
+    ...resource,
+    id: typeof resource.id === "string" && resource.id.trim().length > 0 ? resource.id.trim() : `resource-${index + 1}`,
+    name: typeof resource.name === "string" && resource.name.trim().length > 0 ? resource.name.trim() : typeof resource.id === "string" ? resource.id : `Resource ${index + 1}`
+  })).filter((resource) => typeof resource.id === "string" && resource.id.length > 0);
+  return sanitized.length > 0 ? sanitized : void 0;
+}
+function inferDatabaseFromResources(resources) {
+  const databaseResource = resources?.find((resource) => resource.type === "database");
+  const provider = databaseResource?.provider;
+  return provider === "postgresql" || provider === "mysql" ? provider : void 0;
+}
+function buildArchitectureInputsFromSmartInit(workspaceRoot, proposal) {
+  const projectKinds = normalizeProjectKindsForInit(proposal.projectKinds);
+  const resources = sanitizeArchitectureResourcesForInit(proposal.resources);
+  const database = typeof proposal.database === "string" && isValidDatabaseChoice(proposal.database) ? proposal.database : inferDatabaseFromResources(resources) ?? "none";
+  const apiStyle = typeof proposal.apiStyle === "string" && isValidApiStyle(proposal.apiStyle) ? proposal.apiStyle : projectKinds.includes("backend") ? "rest" : "none";
+  const authStyle = typeof proposal.authStyle === "string" && isValidAuthStyle(proposal.authStyle) ? proposal.authStyle : "jwt";
+  return {
+    projectName: path62.basename(workspaceRoot),
+    repoTopology: "single_project",
+    projectKinds,
+    stacks: normalizeStackSlotsForInit(proposal, projectKinds),
+    architectureStyle: typeof proposal.architectureStyle === "string" && isValidArchitectureStyle(proposal.architectureStyle) ? proposal.architectureStyle : projectKinds.includes("backend") && projectKinds.includes("frontend") ? "microservices" : "modular_monolith",
+    database,
+    tenantModel: database === "none" ? "single_tenant" : "single_tenant",
+    apiStyle,
+    authStyle,
+    implementationProfile: typeof proposal.implementationProfile === "string" && proposal.implementationProfile.trim().length > 0 ? proposal.implementationProfile.trim() : "typescript-backend",
+    ...typeof proposal.modulesRoot === "string" && proposal.modulesRoot.trim().length > 0 ? { modulesRoot: proposal.modulesRoot.trim() } : {},
+    ...Array.isArray(proposal.modules) && proposal.modules.length > 0 ? {
+      modules: proposal.modules.map((entry) => entry.trim()).filter((entry, index, array) => entry.length > 0 && array.indexOf(entry) === index)
+    } : {},
+    ...sanitizeArchitectureComponentsForInit(proposal.components) ? { components: sanitizeArchitectureComponentsForInit(proposal.components) } : {},
+    ...resources ? { resources } : {}
+  };
+}
+function renderSmartInitDetectionSummary(detection, inputs) {
+  const proposal = detection.proposal ?? buildArchitectureProposal(detection);
+  const lines = [];
+  lines.push("ArchPilot Init - Smart Init Detection Summary");
+  lines.push("");
+  lines.push(`Repository topology: ${detection.topology.topology}`);
+  lines.push(`Project kinds: ${(proposal.projectKinds ?? detection.projectKinds?.kinds ?? []).join(", ") || "(none)"}`);
+  lines.push(`Detected stacks: ${detection.stacks.selectedAdapterId ?? "(none)"}`);
+  lines.push(`Module roots: ${proposal.modulesRoot ?? inputs.modulesRoot ?? "(default)"}`);
+  lines.push(`API style: ${proposal.apiStyle ?? inputs.apiStyle}`);
+  lines.push(`Database: ${proposal.database ?? inputs.database}`);
+  lines.push(`Components: ${Array.isArray(proposal.components) && proposal.components.length > 0 ? proposal.components.map((component) => `${component.id ?? "(unnamed)"}:${component.path ?? "(root)"}`).join(", ") : "(none)"}`);
+  lines.push(`Resources: ${Array.isArray(proposal.resources) && proposal.resources.length > 0 ? proposal.resources.map((resource) => `${resource.id ?? "(unnamed)"}:${resource.type ?? "resource"}:${resource.provider ?? "unknown"}`).join(", ") : "(none)"}`);
+  lines.push("");
+  lines.push("Detected values are preselected. You can edit them before anything is written.");
+  return lines.join("\n");
+}
+function renderArchitectureInputsSummary(inputs) {
+  return JSON.stringify(
+    {
+      projectName: inputs.projectName,
+      repoTopology: inputs.repoTopology,
+      projectKinds: inputs.projectKinds,
+      stacks: inputs.stacks,
+      architectureStyle: inputs.architectureStyle,
+      database: inputs.database,
+      tenantModel: inputs.tenantModel,
+      apiStyle: inputs.apiStyle,
+      authStyle: inputs.authStyle,
+      implementationProfile: inputs.implementationProfile,
+      modulesRoot: inputs.modulesRoot,
+      modules: inputs.modules,
+      components: inputs.components,
+      resources: inputs.resources
+    },
+    null,
+    2
+  );
+}
+async function askInitQuestion(rl, prompt) {
+  const answer = await rl.question(prompt);
+  return answer.trim();
+}
+async function askInitValue(rl, label, current, isValid) {
+  while (true) {
+    const answer = await askInitQuestion(rl, `${label} [${current}]: `);
+    if (answer.length === 0) {
+      return current;
+    }
+    if (answer === "back" || answer === "cancel") {
+      return answer;
+    }
+    if (isValid(answer)) {
+      return answer;
+    }
+    process.stdout.write(`Valid values only. Type "back" to return or "cancel" to exit.
+`);
+  }
+}
+function parseCommaList(value) {
+  return value.split(",").map((entry) => entry.trim()).filter((entry, index, array) => entry.length > 0 && array.indexOf(entry) === index);
+}
+async function editProjectProfile(rl, inputs) {
+  const projectName = await askInitQuestion(rl, `Project name [${inputs.projectName}]: `);
+  if (projectName === "back" || projectName === "cancel") {
+    return projectName;
+  }
+  if (projectName.length > 0) {
+    inputs.projectName = projectName;
+  }
+  const repoTopology = await askInitValue(rl, "Repo topology (single_project, monorepo)", inputs.repoTopology, isValidRepoTopology);
+  if (repoTopology === "back" || repoTopology === "cancel") {
+    return repoTopology;
+  }
+  inputs.repoTopology = repoTopology;
+  const projectKinds = await askInitQuestion(rl, `Project kinds comma-list [${inputs.projectKinds.join(", ")}]: `);
+  if (projectKinds === "back" || projectKinds === "cancel") {
+    return projectKinds;
+  }
+  if (projectKinds.length > 0) {
+    const normalized = parseCommaList(projectKinds).filter(isValidProjectKind);
+    if (normalized.length > 0) {
+      inputs.projectKinds = [...new Set(normalized)].sort((left, right) => left.localeCompare(right));
+    }
+  }
+  const architectureStyle = await askInitValue(
+    rl,
+    "Architecture style (modular_monolith, microservices)",
+    inputs.architectureStyle,
+    isValidArchitectureStyle
+  );
+  if (architectureStyle === "back" || architectureStyle === "cancel") {
+    return architectureStyle;
+  }
+  inputs.architectureStyle = architectureStyle;
+  return "next";
+}
+async function editModulesAndApi(rl, inputs) {
+  const modulesRoot = await askInitQuestion(rl, `Modules root [${inputs.modulesRoot ?? ""}]: `);
+  if (modulesRoot === "back" || modulesRoot === "cancel") {
+    return modulesRoot;
+  }
+  if (modulesRoot.length > 0) {
+    inputs.modulesRoot = modulesRoot;
+  }
+  const modules = await askInitQuestion(rl, `Modules comma-list [${inputs.modules?.join(", ") ?? ""}]: `);
+  if (modules === "back" || modules === "cancel") {
+    return modules;
+  }
+  if (modules.length > 0) {
+    inputs.modules = parseCommaList(modules);
+  }
+  const apiStyle = await askInitValue(rl, "API style (none, rest, graphql)", inputs.apiStyle, isValidApiStyle);
+  if (apiStyle === "back" || apiStyle === "cancel") {
+    return apiStyle;
+  }
+  inputs.apiStyle = apiStyle;
+  const authStyle = await askInitValue(rl, "Auth style (jwt, session)", inputs.authStyle, isValidAuthStyle);
+  if (authStyle === "back" || authStyle === "cancel") {
+    return authStyle;
+  }
+  inputs.authStyle = authStyle;
+  const database = await askInitValue(rl, "Legacy database field (none, postgresql, mysql)", inputs.database, isValidDatabaseChoice);
+  if (database === "back" || database === "cancel") {
+    return database;
+  }
+  inputs.database = database;
+  const tenantModel = await askInitValue(
+    rl,
+    "Tenant model (single_tenant, same_db_same_schema, same_db_different_schema)",
+    inputs.tenantModel,
+    isValidTenantModel
+  );
+  if (tenantModel === "back" || tenantModel === "cancel") {
+    return tenantModel;
+  }
+  inputs.tenantModel = tenantModel;
+  return "next";
+}
+async function editJsonSection(rl, label, current, onValid) {
+  process.stdout.write(`${label} JSON. Press Enter to keep current value.
+`);
+  process.stdout.write(`${JSON.stringify(current ?? [], null, 2)}
+`);
+  const answer = await askInitQuestion(rl, `${label}: `);
+  if (answer.length === 0) {
+    return current;
+  }
+  if (answer === "back" || answer === "cancel") {
+    return answer;
+  }
+  try {
+    return onValid(JSON.parse(answer));
+  } catch {
+    process.stdout.write("Invalid JSON. Keeping current value.\n");
+    return current;
+  }
+}
+async function editComponents(rl, inputs) {
+  const edited = await editJsonSection(
+    rl,
+    "Components",
+    Array.isArray(inputs.components) ? inputs.components : void 0,
+    (value) => sanitizeArchitectureComponentsForInit(Array.isArray(value) ? value : void 0)
+  );
+  if (edited === "back" || edited === "cancel") {
+    return edited;
+  }
+  inputs.components = edited;
+  return "next";
+}
+async function editResources(rl, inputs) {
+  const edited = await editJsonSection(
+    rl,
+    "Resources",
+    Array.isArray(inputs.resources) ? inputs.resources : void 0,
+    (value) => sanitizeArchitectureResourcesForInit(Array.isArray(value) ? value : void 0)
+  );
+  if (edited === "back" || edited === "cancel") {
+    return edited;
+  }
+  inputs.resources = edited;
+  const inferredDatabase = inferDatabaseFromResources(edited);
+  if (inferredDatabase && inputs.database === "none") {
+    inputs.database = inferredDatabase;
+  }
+  return "next";
+}
+async function createInitQuestioner() {
+  if (process.env.ARCHPILOT_INIT_ALLOW_STDIN === "1" && (!process.stdin.isTTY || !process.stdout.isTTY)) {
+    const chunks = [];
+    process.stdin.setEncoding("utf8");
+    for await (const chunk of process.stdin) {
+      chunks.push(String(chunk));
+    }
+    const answers = chunks.join("").split(/\r?\n/u);
+    return {
+      async question(prompt) {
+        process.stdout.write(prompt);
+        return answers.shift() ?? "";
+      }
+    };
+  }
+  return (0, import_promises2.createInterface)({ input: import_node_process.stdin, output: import_node_process.stdout });
+}
+function hasEditableDetectedInitValues(detection, inputs) {
+  const proposal = detection.proposal ?? buildArchitectureProposal(detection);
+  return !!proposal.architectureStyle || !!proposal.apiStyle || !!proposal.database || !!proposal.implementationProfile || !!proposal.modulesRoot || inputs.projectKinds.length > 0 || Object.keys(inputs.stacks).length > 0 || Array.isArray(inputs.components) && inputs.components.length > 0 || Array.isArray(inputs.resources) && inputs.resources.length > 0;
+}
+function isEditableInitStep(step, detection, inputs) {
+  if (step.id === "detection") {
+    return hasEditableDetectedInitValues(detection, inputs);
+  }
+  if (step.id === "project" || step.id === "modules") {
+    return true;
+  }
+  if (step.id === "components") {
+    return Array.isArray(inputs.components) && inputs.components.length > 0;
+  }
+  if (step.id === "resources") {
+    return Array.isArray(inputs.resources) && inputs.resources.length > 0;
+  }
+  return false;
+}
+function renderInitStepPrompt(options) {
+  const actions = ["Continue"];
+  if (options.canEdit) {
+    actions.push("Edit");
+  }
+  if (options.canBack) {
+    actions.push("Back");
+  }
+  actions.push("Cancel");
+  return `Press Enter to continue, or type ${actions.slice(1).map((entry) => entry.toLowerCase()).join("/")}: `;
+}
+async function runInitWizard(detection, inputs) {
+  const rl = await createInitQuestioner();
+  try {
+    let stepIndex = 0;
+    while (stepIndex < initWizardSteps.length) {
+      const step = initWizardSteps[stepIndex];
+      process.stdout.write(`
+[${stepIndex + 1}/${initWizardSteps.length}] ${step.title}
+`);
+      if (step.id === "detection") {
+        process.stdout.write(`${renderSmartInitDetectionSummary(detection, inputs)}
+`);
+      } else {
+        process.stdout.write(`${renderArchitectureInputsSummary(inputs)}
+`);
+      }
+      if (step.id === "review") {
+        const answer = await askInitQuestion(rl, "Confirm and write .archpilot/architecture.json? [confirm/back/cancel]: ");
+        if (answer === "confirm" || answer === "y" || answer === "yes") {
+          return inputs;
+        }
+        if (answer === "back") {
+          stepIndex = Math.max(0, stepIndex - 1);
+          continue;
+        }
+        return void 0;
+      }
+      const canBack = stepIndex > 0;
+      const canEdit = isEditableInitStep(step, detection, inputs);
+      const action = await askInitQuestion(rl, renderInitStepPrompt({ canBack, canEdit }));
+      if (action === "cancel") {
+        return void 0;
+      }
+      if (action === "back" && canBack) {
+        stepIndex = Math.max(0, stepIndex - 1);
+        continue;
+      }
+      if (action === "edit" && canEdit) {
+        const result = step.id === "detection" ? await editProjectProfile(rl, inputs) : step.id === "project" ? await editProjectProfile(rl, inputs) : step.id === "components" ? await editComponents(rl, inputs) : step.id === "modules" ? await editModulesAndApi(rl, inputs) : step.id === "resources" ? await editResources(rl, inputs) : "next";
+        if (result === "cancel") {
+          return void 0;
+        }
+        if (result === "back") {
+          stepIndex = Math.max(0, stepIndex - 1);
+          continue;
+        }
+      }
+      stepIndex += 1;
+    }
+    return inputs;
+  } finally {
+    rl.close?.();
+  }
+}
 function requiresInitializedArchitectureForCommand(command, args) {
   if (command === "init") {
     return false;
@@ -238740,27 +239431,68 @@ function requiresInitializedArchitectureForCommand(command, args) {
   return command === "validate" || command === "impact" || command === "fix" || command === "map" || command === "baseline" || command === "report" || command === "review" || command === "ci" || command === "docs" || command === "diagrams" || command === "badges" || command === "adr" || command === "history" || command === "health" || command === "suppressions" || command === "compliance" || command === "contracts";
 }
 async function runInitCommand(args) {
-  if (args.length > 0) {
-    console.error("Usage: archpilot init");
+  const flags = parseInitFlags(args);
+  if (!flags) {
+    console.error("Usage: archpilot init [--yes]");
+    return 1;
+  }
+  const workspaceRoot = process.cwd();
+  const configPath = path62.join(workspaceRoot, ".archpilot", "architecture.json");
+  try {
+    await import_node_fs44.promises.access(configPath);
+    process.stderr.write(
+      "ArchPilot is already initialized for this repository. Existing .archpilot/architecture.json was preserved.\n"
+    );
+    process.stderr.write(
+      "Edit the existing file, or remove it intentionally before running `archpilot init` again.\n"
+    );
+    return 1;
+  } catch {
+  }
+  if (!flags.yes && (!process.stdin.isTTY || !process.stdout.isTTY) && process.env.ARCHPILOT_INIT_ALLOW_STDIN !== "1") {
+    process.stderr.write(
+      "archpilot init is interactive. Run it in a terminal, or use `archpilot init --yes` to accept Smart Init defaults without prompts.\n"
+    );
     return 1;
   }
   try {
-    await ensureArchpilotIgnoreFile(process.cwd());
+    const detection = detectSmartInit(workspaceRoot);
+    const proposal = detection.proposal ?? buildArchitectureProposal(detection);
+    let inputs = buildArchitectureInputsFromSmartInit(workspaceRoot, proposal);
+    if (isValidRepoTopology(detection.topology.topology)) {
+      inputs.repoTopology = detection.topology.topology;
+    }
+    if (!flags.yes) {
+      const wizardInputs = await runInitWizard(detection, inputs);
+      if (!wizardInputs) {
+        process.stdout.write("ArchPilot initialization cancelled. No files were written.\n");
+        return 1;
+      }
+      inputs = wizardInputs;
+    } else {
+      process.stdout.write(`${renderSmartInitDetectionSummary(detection, inputs)}
+
+`);
+      process.stdout.write("Accepted Smart Init defaults with --yes.\n");
+    }
+    const result = await applyArchitectureInitialization(workspaceRoot, inputs);
+    process.stdout.write("\nArchPilot initialized.\n");
+    process.stdout.write("Created .archpilot/architecture.json and baseline setup artifacts.\n");
+    process.stdout.write(
+      result.policyFileCreated ? "Created .archpilot/policy.json.\n" : "Preserved existing .archpilot/policy.json.\n"
+    );
+    process.stdout.write(
+      result.archpilotIgnoreFileCreated ? "Created .archpilotignore.\n\n" : "Preserved existing .archpilotignore.\n\n"
+    );
+    process.stdout.write(`${renderGettingStartedChecklist()}
+`);
+    return 0;
   } catch (error) {
     console.error(
-      error instanceof Error ? error.message : "Unable to create .archpilotignore."
+      error instanceof Error ? error.message : "Unable to initialize ArchPilot."
     );
     return 1;
   }
-  process.stdout.write(
-    "ArchPilot initialization is Inspector-first in the VS Code extension.\n"
-  );
-  process.stdout.write(
-    "Open `ArchPilot: Open Architecture Inspector`, complete the initialization wizard, then confirm on the Review step to create `.archpilot/architecture.json` and baseline artifacts.\n\n"
-  );
-  process.stdout.write(`${renderGettingStartedChecklist()}
-`);
-  return 0;
 }
 var architectureBadgeMarkdownSnippet = "[![ArchPilot Score](badges/architecture-score.svg)](.archpilot/reports/architecture-review.md)";
 var architectureBadgeRenderedRegex = /\[\!\[(?:ArchPilot Score|Architecture Score)\]\(badges\/architecture-score\.svg\)\]\(\.archpilot\/reports\/architecture-review\.md\)/;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@archpilotlabs/archpilot",
-  "version": "0.0.12",
+  "version": "0.0.13",
   "description": "Executable architecture governance CLI",
   "homepage": "https://archpilot.org",
   "bugs": {