@kaddo/cli 3.35.0 → 3.36.0

package/README.md

@@ -531,6 +531,7 @@ create --from roadmap → owners → guard → explain`.
 | v3.33 | Open questions resolution tracking: mark questions `[open]`/`[resolved]`/`[assumed]`/`[deferred]` (EN+ES); only `open` blocks readiness, so assumed/resolved/deferred decisions stop false blocks. `kaddo questions` shows status counts + `resolution_status` in JSON |
 | v3.34 | Pre-AI onboarding: `kaddo onboarding` (alias `onboard`) / `kaddo report onboarding` — read-only diagnosis of an existing project's readiness (scan/understand/knowledge/questions/roadmap/work-items/adapters) with a single recommended next step; `--json` |
 | v3.35 | Folded onboarding into `kaddo explain`: removed `kaddo onboarding`/`onboard`/`report onboarding`; project readiness + single recommended next step now live in `kaddo explain` (human `## Project Readiness` + `readiness` in agent JSON) |
+| v3.36 | State-aware bootstrap: `kaddo bootstrap` creates the full knowledge baseline for any `project.state` (new/pre-ai/legacy) with state-specific templates — no more new-only warning; idempotent, never overwrites, ensures `tech/decisions/` and `delivery/work-items/` |
 
 **Optional modules (installed with `kaddo add`):**
 

package/dist/index.js

@@ -6230,7 +6230,7 @@ ${items.map((i) => `- ${i}`).join("\n")}
 `;
 }
 function renderCapsuleMarkdown(c) {
-  const fm = [
+  const fm2 = [
     "---",
     "type: knowledge-capsule",
     `system: ${c.system}`,
@@ -6242,7 +6242,7 @@ function renderCapsuleMarkdown(c) {
     "---"
   ].join("\n");
   const parts = [
-    fm,
+    fm2,
     "",
     `# ${c.system} \u2014 Knowledge Capsule`,
     "",
@@ -6723,9 +6723,9 @@ var QUALITY_NOTE = {
   sparse: "The graph has many nodes but few meaningful edges.",
   empty: "The graph has almost no relationships."
 };
-function yamlBlock(fm) {
+function yamlBlock(fm2) {
   const lines = ["```yaml"];
-  for (const [k, vals] of Object.entries(fm)) {
+  for (const [k, vals] of Object.entries(fm2)) {
     lines.push(`${k}:`);
     for (const v of vals) lines.push(`  - ${v}`);
   }
@@ -8240,9 +8240,9 @@ function readConfig(dir) {
 }
 function filterBySince(artifacts, since) {
   return artifacts.filter((a) => {
-    const fm = a;
-    if (!fm.created_at) return true;
-    return fm.created_at >= since;
+    const fm2 = a;
+    if (!fm2.created_at) return true;
+    return fm2.created_at >= since;
   });
 }
 function filterByScope(artifacts, scope) {
@@ -9102,6 +9102,12 @@ function runUnderstand() {
   if (assessment.nextStep) {
     console.log(`Next step: ${assessment.nextStep}`);
   }
+  const readiness = exp.readiness;
+  if (readiness.overall === "initialized" || readiness.overall === "bootstrap-incomplete") {
+    console.log("");
+    console.log(`Project readiness: ${readiness.overall}.`);
+    console.log(`  \u2192 ${readiness.recommended_next_step.label}`);
+  }
   const installedSkills = discoverInstalledSkills(dir);
   if (installedSkills.length > 0 && assessment.recommendedAgents.length > 0) {
     const recSkills = skillsForAgents(installedSkills, assessment.recommendedAgents);
@@ -11835,48 +11841,429 @@ function runModulesList(dir = cwd()) {
   console.log("");
 }
 
+// src/core/bootstrap-templates.ts
+function fm(type, state) {
+  return `---
+type: ${type}
+project_state: ${state}
+---
+
+`;
+}
+var T = {
+  business: {
+    new: `# Business Context
+
+## Problem
+
+_What problem are we solving?_
+
+## Users
+
+_Who will use this product?_
+
+## Business goals
+
+_What outcomes matter?_
+
+## Constraints
+
+_Business, operational or regulatory constraints._
+`,
+    "pre-ai": `# Business Context
+
+## What this product appears to support
+
+_Describe the business purpose based on confirmed knowledge._
+
+## Users or roles
+
+_List known users or roles. Mark unknowns explicitly._
+
+## Existing business rules
+
+_Document confirmed business rules._
+
+## Open questions
+
+- [open] _What business context still needs confirmation?_
+`,
+    legacy: `# Business Context
+
+## Critical business purpose
+
+_What critical business process does this system support?_
+
+## Users and operational dependency
+
+_Who depends on this system?_
+
+## Business continuity constraints
+
+_What cannot be interrupted?_
+
+## Open questions
+
+- [open] _What business risk still needs confirmation?_
+`
+  },
+  product: {
+    new: `# Product Context
+
+## Product vision
+
+_What are we building?_
+
+## User journeys
+
+_Main user journeys._
+
+## Scope
+
+_What is in scope and out of scope?_
+
+## Success criteria
+
+_How will we know this product is working?_
+`,
+    "pre-ai": `# Product Context
+
+## Existing product behavior
+
+_Describe what the product currently does._
+
+## Main flows
+
+_List confirmed user or system flows._
+
+## Inferred or uncertain behavior
+
+_Document uncertain behavior as assumptions, not facts._
+
+## Open questions
+
+- [open] _What product behavior still needs confirmation?_
+`,
+    legacy: `# Product Context
+
+## Existing behavior
+
+_What does the legacy system do today?_
+
+## Critical flows
+
+_Which flows are business-critical?_
+
+## Known pain points
+
+_What problems are known?_
+
+## Out of scope
+
+_What should not be changed yet?_
+`
+  },
+  capabilities: {
+    new: `# Capabilities
+
+## Planned capabilities
+
+- [planned] _Capability name_
+
+## Capability map
+
+_Document the product capabilities that should exist._
+
+## Open questions
+
+- [open] _What capability decisions are still unclear?_
+`,
+    "pre-ai": `# Existing Capabilities
+
+## Observed capabilities
+
+- [observed] _Capability observed in the existing system._
+
+## Partial capabilities
+
+- [partial] _Capability that appears incomplete or uncertain._
+
+## Assumptions
+
+- [assumed] _Safe assumption to confirm later._
+
+## Open questions
+
+- [open] _What capability is unclear?_
+`,
+    legacy: `# Legacy Capabilities
+
+## Critical capabilities
+
+- [critical] _Capability that must keep working._
+
+## Risky capabilities
+
+- [risky] _Capability that is hard to change or poorly understood._
+
+## Replacement candidates
+
+- [candidate] _Capability that may be modernized later._
+
+## Open questions
+
+- [open] _What capability risk is unclear?_
+`
+  },
+  codebase: {
+    new: `# Codebase Map
+
+## Repository structure
+
+_No production code yet. Describe the intended structure as it emerges._
+
+## Entry points
+
+_To be defined._
+
+## How to run
+
+_To be defined._
+
+## How to test
+
+_To be defined._
+
+## Open questions
+
+- [open] _What structural decisions are still open?_
+`,
+    "pre-ai": `# Codebase Map
+
+## Repository structure
+
+_Describe the main folders and their purpose._
+
+## Entry points
+
+_List known entry points._
+
+## Important modules
+
+_List modules or areas that appear important._
+
+## How to run
+
+_Document commands to run the project._
+
+## How to test
+
+_Document how this project is tested. If unknown, mark as open._
+
+## Open questions
+
+- [open] _What part of the codebase still needs explanation?_
+`,
+    legacy: `# Codebase Map
+
+## Repository structure
+
+_Describe the main folders and their purpose._
+
+## Entry points
+
+_List known entry points._
+
+## Fragile / delicate areas
+
+_List modules that are risky to change._
+
+## How to run
+
+_Document commands to run the project._
+
+## How to test
+
+_Document how this project is tested. If unknown, mark as open._
+
+## Open questions
+
+- [open] _What part of the codebase still needs explanation?_
+`
+  },
+  "current-state": {
+    new: `# Current State
+
+## Initial technical direction
+
+_What technical direction has been decided?_
+
+## Known constraints
+
+_What constraints shape implementation?_
+
+## Unknowns
+
+- [open] _What technical questions remain open?_
+`,
+    "pre-ai": `# Current State
+
+## What exists today
+
+_Describe the confirmed current state of the system._
+
+## Observed technical signals
+
+_Use \`kaddo scan\` output to document language, framework, package manager, source directories and infrastructure._
+
+## Inferred architecture
+
+_Document inferred architecture carefully. Mark uncertainty._
+
+## Known constraints
+
+_List technical, operational, business or infrastructure constraints._
+
+## Risks of interpretation
+
+_What could an agent misunderstand?_
+
+## Open questions
+
+- [open] _What technical decisions still need confirmation?_
+`,
+    legacy: `# Legacy Current State
+
+## Current architecture
+
+_Describe the existing architecture._
+
+## Critical dependencies
+
+_List systems, databases, integrations or manual operations this system depends on._
+
+## Known risks
+
+_List known technical or operational risks._
+
+## Change constraints
+
+_What should not be changed without validation?_
+
+## Modernization notes
+
+_Initial notes about possible modernization paths._
+
+## Open questions
+
+- [open] _What legacy risk still needs confirmation?_
+`
+  },
+  roadmap: {
+    new: `# Roadmap
+
+## Now
+
+_First outcomes to pursue._
+
+## Next
+
+_What comes after._
+
+## Later
+
+_Deferred ideas._
+`,
+    "pre-ai": `# Roadmap
+
+## Now
+
+_First outcomes to pursue for this existing project._
+
+## Next
+
+_What comes after._
+
+## Later
+
+_Deferred ideas._
+`,
+    legacy: `# Modernization Roadmap
+
+## Stabilize
+
+_What must be made safe first._
+
+## Modernize
+
+_Controlled modernization steps._
+
+## Later
+
+_Deferred modernization ideas._
+`
+  }
+};
+function baselineTemplate(kind, state) {
+  const st = state === "pre-ai" || state === "legacy" ? state : "new";
+  return fm(kind, st) + T[kind][st];
+}
+
 // src/commands/bootstrap.ts
 var CONFIG_PATH8 = ".kaddo/config.yml";
-var TARGETS = [
-  // Minimum sufficient knowledge: one consolidated file per layer. Specialized
-  // artifacts (problem.md, users.md, capabilities.md, …) appear later, as the project
-  // matures, via agents and refinement — not at bootstrap.
-  { layer: "Business", path: "knowledge/business/business.md", templateId: "business" },
-  { layer: "Product", path: "knowledge/product/product.md", templateId: "product" },
-  { layer: "Tech", path: "knowledge/tech/codebase.md", templateId: "codebase" }
+var FILE_TARGETS = [
+  { path: "knowledge/business/business.md", kind: "business" },
+  { path: "knowledge/product/product.md", kind: "product" },
+  { path: "knowledge/product/capabilities.md", kind: "capabilities" },
+  { path: "knowledge/tech/codebase.md", kind: "codebase" },
+  { path: "knowledge/tech/current-state.md", kind: "current-state" },
+  { path: "knowledge/delivery/roadmap.md", kind: "roadmap" }
 ];
-var BOOTSTRAP_LAYERS = ["Business", "Product", "Tech"];
+var DIR_TARGETS = ["knowledge/tech/decisions", "knowledge/delivery/work-items"];
+function withLanguageDirective(content, language) {
+  if (language !== "es") return content;
+  const note = "> Idioma del proyecto: **espa\xF1ol**. Escribe este conocimiento en espa\xF1ol. Mant\xE9n en ingl\xE9s el c\xF3digo, los nombres de archivo, los comandos y las claves de configuraci\xF3n.\n";
+  const fm2 = content.match(/^---\n[\s\S]*?\n---\n/);
+  if (fm2) return content.slice(0, fm2[0].length) + "\n" + note + content.slice(fm2[0].length);
+  return `${note}
+${content}`;
+}
 function bootstrap(dir) {
   const written = [];
   const skipped = [];
+  const createdDirs = [];
+  let state = "new";
   let language = "en";
   try {
     const config = loadConfig(dir);
-    if (config) language = projectLanguage(config);
+    if (config) {
+      state = config.project.state;
+      language = projectLanguage(config);
+    }
   } catch {
   }
-  for (const target of TARGETS) {
+  for (const target of FILE_TARGETS) {
     const full = join(dir, target.path);
     if (exists(full)) {
       skipped.push(target.path);
       continue;
     }
-    const tpl = getTemplate(target.templateId);
-    const base = tpl ? tpl.content : "";
-    const content = withLanguageDirective(base, language);
+    const content = withLanguageDirective(baselineTemplate(target.kind, state), language);
     writeFile(full, content.endsWith("\n") ? content : `${content}
 `);
     written.push(target.path);
   }
-  return { written, skipped, layers: BOOTSTRAP_LAYERS };
-}
-function withLanguageDirective(content, language) {
-  if (language !== "es") return content;
-  const note = "> Idioma del proyecto: **espa\xF1ol**. Escribe este conocimiento en espa\xF1ol. Mant\xE9n en ingl\xE9s el c\xF3digo, los nombres de archivo, los comandos y las claves de configuraci\xF3n.\n";
-  const fm = content.match(/^---\n[\s\S]*?\n---\n/);
-  if (fm) return content.slice(0, fm[0].length) + "\n" + note + content.slice(fm[0].length);
-  return `${note}
-${content}`;
+  for (const d of DIR_TARGETS) {
+    const full = join(dir, d);
+    if (exists(full)) {
+      skipped.push(`${d}/`);
+      continue;
+    }
+    ensureDir(full);
+    writeFile(join(full, ".gitkeep"), "");
+    createdDirs.push(`${d}/`);
+  }
+  return { state, written, skipped, createdDirs };
 }
 async function runBootstrap(dir = cwd()) {
   intro2("kaddo bootstrap");
@@ -11885,46 +12272,37 @@ async function runBootstrap(dir = cwd()) {
     console.error("Run `kaddo init` first.");
     process.exit(1);
   }
-  let state = "unknown";
+  let state = "new";
   try {
     const config = loadConfig(dir);
-    state = config?.project.state ?? "unknown";
+    state = config?.project.state ?? "new";
   } catch (err) {
-    const message = err instanceof ConfigError ? err.message : String(err);
-    console.error(message);
+    console.error(err instanceof ConfigError ? err.message : String(err));
     process.exit(1);
   }
-  log2.info(`Project state: ${state}`);
-  log2.info("Base layers: Business \u2192 Product \u2192 Tech \u2192 Delivery");
-  if (state !== "new") {
-    log2.warn("This project is not marked as new. Bootstrap is designed for new projects.");
-    const ok = await confirm2({ message: "Continue anyway?", initialValue: false });
-    if (!ok) {
-      outro2("Bootstrap cancelled.");
-      return;
-    }
-  }
+  const stateLabel3 = state === "pre-ai" ? "pre-ai" : state;
+  log2.info(`Project state: ${stateLabel3}`);
+  log2.info(`Creating ${stateLabel3} knowledge baseline.`);
+  log2.info("Existing files will not be overwritten.");
   const result = bootstrap(dir);
   console.log("");
-  console.log("Bootstrap layers:");
-  for (const layer2 of result.layers) console.log(`  \u2713 ${layer2}`);
-  console.log("");
-  if (result.written.length > 0) {
+  if (result.written.length > 0 || result.createdDirs.length > 0) {
     console.log("Created:");
     for (const p2 of result.written) console.log(`  - ${p2}`);
+    for (const d of result.createdDirs) console.log(`  - ${d}`);
   }
   if (result.skipped.length > 0) {
     console.log("");
-    console.log("Kept existing (skipped):");
+    console.log("Skipped (kept existing):");
     for (const p2 of result.skipped) console.log(`  - ${p2}`);
   }
   console.log("");
-  console.log("");
   log2.info(
     "When you pass the context pack to your LLM/coding agent, it must never commit, push or merge without your confirmation \u2014 and create a branch before implementing."
   );
+  printCommandFooter("bootstrap");
   outro2(
-    "Minimal knowledge base ready (Business \u2192 Product \u2192 Tech). Run `kaddo context` and `kaddo add agents`, then refine with the business-agent, bootstrap-agent and codebase-agent. Roadmap and work items come next under knowledge/delivery/."
+    `${stateLabel3} knowledge baseline ready. Next: \`kaddo add agents\` (then \`kaddo add skills\`), and refine the knowledge with the relevant agents.`
   );
 }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kaddo/cli",
-  "version": "3.35.0",
+  "version": "3.36.0",
   "description": "Knowledge Driven Development toolkit",
   "license": "MIT",
   "repository": {