@akm1923main/init-project 1.0.0

package/QUICKSTART_CREATE_AI_PROJECT.md

@@ -0,0 +1,52 @@
+# create-ai-project — Quickstart (AI-OS)
+
+## 1) Local development (you on this machine)
+
+```bash
+cd "C:\Users\hp\Desktop\New folder\create-ai-project"
+npm link
+create-ai-project my-greenfield-project
+```
+
+## 2) Publish + use via npx (your target)
+
+### A) Publish to npm
+1) Create an npm account and login:
+
+```bash
+npm login
+```
+
+2) Publish:
+
+```bash
+npm publish
+```
+
+> If the name `create-ai-project` is already taken on npm, rename the package (e.g., `@akm/create-ai-project`) and then use:
+> 
+> - `npx @akm/create-ai-project my-project`
+
+### B) Use anywhere with one command
+
+```bash
+npx create-ai-project my-project
+```
+
+## 3) Standard Skills are bundled
+
+This CLI ships the canonical skills at:
+
+- `templates/02_Skills/`
+
+On init, it copies them into your new project at:
+
+- `<project>/02_Skills/`
+
+No external paths.
+
+## 4) Notes
+- Generated projects ignore `02_Skills/` via `.gitignore` (your preference)
+- State folder is `07_state/`
+- Python workflow recommendation is `uv` (see `05_Project/README.md`)
+- `03_Project_Info/` + `06_Documentation/` files are generated later by agents (folders only at init)

package/README.md

@@ -0,0 +1,48 @@
+# create-ai-project
+
+A CLI that scaffolds an **AI-OS** project structure.
+
+## Key guarantee (your requirement)
+
+When you initialize a project, the generated project will contain **02_Skills/** with the **exact same files and content** that ship inside this CLI package.
+
+- No external copy paths
+- No tiny placeholders
+- The standard skills are bundled under: `templates/02_Skills/`
+
+> Note: By your preference, generated projects include `02_Skills/` in `.gitignore`.
+
+## Usage (local dev)
+
+```bash
+cd "C:\Users\hp\Desktop\New folder\create-ai-project"
+npm link
+create-ai-project my-project
+```
+
+## Usage (npx — the way you want)
+
+After you publish this package to npm:
+
+```bash
+npx create-ai-project my-project
+```
+
+## Options
+
+```bash
+create-ai-project <project-name> [--path <targetDir>] [--force]
+```
+
+## What gets created at init
+- Folder skeleton (AI-OS)
+- `PROJECT_STATE.md`, `.gitignore`, `.env.example`, `VERSION.md`
+- `04_Tasks/*` and `07_state/*`
+- **02_Skills/** copied from bundled templates
+
+### Empty docs behavior (by design)
+Initializer creates folders but does NOT create empty markdown files under:
+- `03_Project_Info/*` (folders only)
+- `06_Documentation/*` (folder only)
+
+Agents/workflows generate/update those later.

package/index.js

@@ -0,0 +1,219 @@
+#!/usr/bin/env node
+
+/**
+ * create-ai-project
+ * AI-OS project initializer.
+ *
+ * GOALS (as requested):
+ * - Preserve command interface
+ * - Preserve npm link behavior (package.json bin)
+ * - Ship a STANDARD, bundled 02_Skills/ inside this CLI package (no external copy paths)
+ * - 02_Skills in generated projects must match the bundled version EXACTLY (no tiny placeholders)
+ * - Keep 02_Skills ignored in generated project's .gitignore (user preference)
+ * - Rename state/ -> 07_state/
+ * - Recommend uv as default Python tooling
+ * - Do NOT create empty Project_Info/Documentation markdown files at init (folders only)
+ *
+ * Usage:
+ *   create-ai-project <project-name> [--path <targetDir>] [--force]
+ */
+
+const fs = require('fs');
+const path = require('path');
+
+function die(msg, code = 1) {
+  console.error(msg);
+  process.exit(code);
+}
+
+function parseArgs(argv) {
+  const args = { name: null, targetDir: process.cwd(), force: false };
+
+  const positionals = [];
+  for (let i = 2; i < argv.length; i++) {
+    const a = argv[i];
+    if (a === '--path' || a === '-p') {
+      const v = argv[++i];
+      if (!v) die('❌ Missing value for --path');
+      args.targetDir = v;
+    } else if (a === '--force' || a === '-f') {
+      args.force = true;
+    } else if (a === '--help' || a === '-h') {
+      args.help = true;
+    } else {
+      positionals.push(a);
+    }
+  }
+
+  args.name = positionals[0] || null;
+  return args;
+}
+
+function ensureDir(p) {
+  fs.mkdirSync(p, { recursive: true });
+}
+
+function writeFileIfNotExists(filePath, content) {
+  if (fs.existsSync(filePath)) return;
+  ensureDir(path.dirname(filePath));
+  fs.writeFileSync(filePath, content, 'utf8');
+}
+
+function copyRecursiveNoClobber(src, dest) {
+  const stat = fs.statSync(src);
+  if (stat.isDirectory()) {
+    ensureDir(dest);
+    for (const entry of fs.readdirSync(src)) {
+      copyRecursiveNoClobber(path.join(src, entry), path.join(dest, entry));
+    }
+    return;
+  }
+
+  // file
+  if (fs.existsSync(dest)) return;
+  ensureDir(path.dirname(dest));
+  fs.copyFileSync(src, dest);
+}
+
+function safeCreateProjectRoot(projectPath, force) {
+  if (fs.existsSync(projectPath)) {
+    if (!force) die('❌ Folder already exists. Use --force to proceed.');
+  } else {
+    fs.mkdirSync(projectPath, { recursive: true });
+  }
+}
+
+function normalizeLines(s) {
+  return (s || '').replace(/\r\n/g, '\n');
+}
+
+function main() {
+  const args = parseArgs(process.argv);
+
+  if (args.help || !args.name) {
+    console.log(
+      normalizeLines(
+        `create-ai-project - AI-OS project initializer\n\n` +
+          `Usage:\n  create-ai-project <project-name> [--path <targetDir>] [--force]\n\n` +
+          `Options:\n` +
+          `  --path, -p   Target directory (default: current directory)\n` +
+          `  --force, -f  Allow existing folder (will only add missing items)\n` +
+          `  --help, -h   Show help\n`
+      )
+    );
+    process.exit(args.help ? 0 : 1);
+  }
+
+  const projectName = args.name;
+  const targetDir = path.resolve(args.targetDir);
+  const projectPath = path.join(targetDir, projectName);
+
+  safeCreateProjectRoot(projectPath, args.force);
+
+  // Bundled skills source (ships with the CLI)
+  const SKILLS_TEMPLATE_SOURCE = path.join(__dirname, 'templates', '02_Skills');
+
+  // Folder skeleton
+  const folders = [
+    '01_Knowledge',
+    '02_Skills',
+
+    '03_Project_Info',
+    '03_Project_Info/Idea_Analyst',
+    '03_Project_Info/Business_Analyst',
+    '03_Project_Info/Product_Manager',
+    '03_Project_Info/Architect',
+    '03_Project_Info/Testing_Engineer',
+    '03_Project_Info/Performance_Engineer',
+    '03_Project_Info/Security_Engineer',
+    '03_Project_Info/DevOps_Engineer',
+
+    '04_Tasks',
+    '04_Tasks/TASKS',
+    '04_Tasks/ARCHIVE',
+
+    '05_Project',
+
+    '06_Documentation',
+
+    '07_state'
+  ];
+
+  for (const f of folders) ensureDir(path.join(projectPath, f));
+
+  const now = new Date().toISOString();
+
+  // Root files
+  writeFileIfNotExists(path.join(projectPath, 'VERSION.md'), `# VERSION\n\n0.1.0\n`);
+
+  writeFileIfNotExists(
+    path.join(projectPath, 'PROJECT_STATE.md'),
+    `# PROJECT_STATE\n\nCreated: ${now}\n\n## Purpose\n- \n\n## Current status\n- Phase: discovery / build / test / ship\n\n## Top priorities\n- [ ]\n\n## Key decisions\n- See: 07_state/DECISIONS.md\n- See: 07_state/ADR.md\n`
+  );
+
+  // You explicitly want skills ignored in generated projects.
+  writeFileIfNotExists(
+    path.join(projectPath, '.gitignore'),
+    `# Node\nnode_modules\n\n# Python\n.venv\n__pycache__\n\n# uv\n.uv\n\n# Secrets\n.env\n\n# Logs\n*.log\n\n# AI-OS (user preference)\n02_Skills/\n\n# OS\n.DS_Store\nThumbs.db\n`
+  );
+
+  writeFileIfNotExists(
+    path.join(projectPath, '.env.example'),
+    `# Copy to .env and fill values\n# Never commit .env with secrets\n\n# EXAMPLE_KEY=\n`
+  );
+
+  // Tasks + state (these are useful even if empty)
+  writeFileIfNotExists(
+    path.join(projectPath, '04_Tasks', 'TASK_PLAN.md'),
+    `# TASK_PLAN\n\n## Milestones\n\n## Tasks\n- [ ]\n\nCreated: ${now}\n`
+  );
+  writeFileIfNotExists(
+    path.join(projectPath, '04_Tasks', 'DEVELOPMENT_CHECKLIST.md'),
+    `# DEVELOPMENT_CHECKLIST\n\n- [ ] Repo initialized (git)\n- [ ] Build/run instructions exist\n- [ ] Tests added\n- [ ] Lint/format configured\n- [ ] Security basics (secrets, deps)\n`
+  );
+  writeFileIfNotExists(
+    path.join(projectPath, '04_Tasks', 'PROGRESS_LOG.md'),
+    `# PROGRESS_LOG\n\n## ${now}\n- Project created\n`
+  );
+  writeFileIfNotExists(
+    path.join(projectPath, '04_Tasks', 'RISK_REGISTER.md'),
+    `# RISK_REGISTER\n\n| Risk | Impact | Likelihood | Mitigation | Owner | Status |\n|---|---|---|---|---|---|\n|  |  |  |  |  |  |\n`
+  );
+  writeFileIfNotExists(
+    path.join(projectPath, '04_Tasks', 'TASKS', 'TEMPLATE_TASK.md'),
+    `# TASK: <title>\n\n## Goal\n\n## Acceptance criteria\n\n## Steps\n\n## Notes\n`
+  );
+
+  writeFileIfNotExists(path.join(projectPath, '07_state', 'CHANGELOG.md'), `# CHANGELOG\n\n## Unreleased\n-\n`);
+  writeFileIfNotExists(path.join(projectPath, '07_state', 'DECISIONS.md'), `# DECISIONS\n\n## ${now}\n- Initial scaffold\n`);
+  writeFileIfNotExists(
+    path.join(projectPath, '07_state', 'ADR.md'),
+    `# ADR (Architecture Decision Records)\n\n### ADR-0001: <Title>\n- Date: ${now}\n- Status: Proposed | Accepted | Superseded\n\n#### Context\n\n#### Decision\n\n#### Consequences\n\n---\n`
+  );
+  writeFileIfNotExists(path.join(projectPath, '07_state', 'KNOWN_ISSUES.md'), `# KNOWN_ISSUES\n\n-\n`);
+  writeFileIfNotExists(path.join(projectPath, '07_state', 'INCIDENT_LOG.md'), `# INCIDENT_LOG\n\n-\n`);
+
+  // Copy bundled 02_Skills (actual full content) into the project.
+  if (!fs.existsSync(SKILLS_TEMPLATE_SOURCE)) {
+    die(
+      `❌ Missing bundled skills templates. Expected at:\n${SKILLS_TEMPLATE_SOURCE}\n\nFix: ensure templates/02_Skills is included in the package.`,
+      2
+    );
+  }
+  copyRecursiveNoClobber(SKILLS_TEMPLATE_SOURCE, path.join(projectPath, '02_Skills'));
+
+  // README
+  writeFileIfNotExists(
+    path.join(projectPath, 'README.md'),
+    `# ${projectName}\n\nGenerated by **create-ai-project** (AI-OS).\n\n## Quickstart\n\n\`\`\`bash\ncd \"${projectName}\"\n\`\`\`\n\n## Where things go\n\n- \`02_Skills/\` — standard skills shipped with initializer (ignored by git in this scaffold)\n- \`03_Project_Info/\` — role folders (agents will generate/update docs later)\n- \`06_Documentation/\` — system docs (generated later)\n- \`04_Tasks/\` — task plans + logs\n- \`07_state/\` — decisions + ADR + changelog\n\n## Python default: uv\n\n\`\`\`bash\ncd 05_Project\nuv venv\nuv pip install <pkg>\n\`\`\`\n\nGenerated: ${now}\n`
+  );
+
+  writeFileIfNotExists(
+    path.join(projectPath, '05_Project', 'README.md'),
+    `# Implementation\n\nPut the actual code here.\n\n## Python (default: uv)\n\n\`\`\`bash\ncd 05_Project\nuv venv\nuv pip install <pkg>\n\`\`\`\n`
+  );
+
+  console.log(`✅ AI project "${projectName}" initialized successfully at:\n${projectPath}`);
+}
+
+main();

package/package.json

@@ -0,0 +1,24 @@
+{
+  "name": "@akm1923main/init-project",
+  "version": "1.0.0",
+  "description": "AI-OS project initializer CLI",
+  "main": "index.js",
+  "type": "commonjs",
+  "license": "MIT",
+  "bin": {
+    "init-project": "index.js"
+  },
+  "files": [
+    "index.js",
+    "README.md",
+    "QUICKSTART_CREATE_AI_PROJECT.md",
+    "templates/**"
+  ],
+  "keywords": [
+    "scaffold",
+    "initializer",
+    "cli",
+    "ai",
+    "project"
+  ]
+}

package/templates/02_Skills/Legacy_Prompts/Architecture.md

@@ -0,0 +1,72 @@
+# 🏗️ ENTERPRISE ARCHITECTURE DOCUMENT GENERATION TEMPLATE (GOD MODE V3 ULTRA)
+
+You are a **Distinguished Systems Architect + Distributed Systems Expert + Security Architect**.
+
+I will provide a finalized PRD.
+
+Your task is to generate a complete, production-grade `ARCHITECTURE.md` document.
+
+This document must be suitable for:
+
+- Architecture Review Board (ARB)
+- CTO approval
+- Security & Compliance review
+- DevOps planning
+- Capacity planning
+- Production readiness certification
+
+⚠️ NON-NEGOTIABLE RULES
+
+1. Translate requirements → architectural decisions.
+2. Make concrete technology choices.
+3. Justify every major decision.
+4. Include Mermaid diagrams (MANDATORY).
+5. Explicitly define scaling, failure, and recovery behavior.
+6. No vague language.
+7. No implementation code.
+
+---
+
+# INPUT
+
+(Wait for PRD)
+
+---
+
+# OUTPUT STRUCTURE (STRICT)
+
+# 1️⃣ Document Metadata
+
+| Attribute            | Value                        |
+| -------------------- | ---------------------------- |
+| System Name          |                              |
+| Architecture Version | 1.0                          |
+| Based on PRD Version |                              |
+| Status               | Draft / Review               |
+| Author               | Distinguished Architect      |
+| Reviewers            | Eng Lead / Security / DevOps |
+| Last Updated         |                              |
+
+---
+
+# 2️⃣ Architectural Vision & Strategy
+
+- Architectural Style (Monolith / Modular Monolith / Microservices / Event-Driven / Hybrid)
+- Rationale for style selection
+- System constraints from PRD
+- Key architectural principles
+- Trade-offs accepted
+- Non-goals in architecture
+
+---
+
+# 3️⃣ C4 Model
+
+## 3.1 C4 Level 1 — System Context
+
+```mermaid
+graph TD
+    User --> System
+    System --> ExternalAPI
+    System --> IdentityProvider
+```

package/templates/02_Skills/Legacy_Prompts/Coding_Discipline.md

@@ -0,0 +1,283 @@
+---
+# 🧠 ENTERPRISE EXECUTION-AWARE PRODUCTION CODING STANDARD (GOD MODE V3)
+
+You are a **Staff Software Engineer + Principal Backend Architect**.
+
+You are implementing a real production system based on:
+
+- PRD
+- ARCHITECTURE.md
+- TASK_PLAN.md
+- DEVELOPMENT_CHECKLIST.md
+- Individual TASK_xxx.md files
+
+You are NOT writing isolated code.
+
+You are executing a structured development plan.
+
+This code must survive production.
+---
+# 🔴 EXECUTION ALIGNMENT REQUIREMENT (MANDATORY)
+
+Before writing any code:
+
+1. Identify which TASK_xxx.md you are implementing.
+2. Read and understand:
+   - Objective
+   - Architecture Mapping
+   - Deliverables
+   - Dependencies (Hard/Soft)
+   - Acceptance Criteria
+   - Definition of Done
+3. Confirm all Hard Dependencies are completed.
+4. Confirm task status is 🔲 Not Started.
+5. Change task status to 🟡 In Progress before coding.
+6. Implement ONLY what is within the scope of this task.
+7. Do NOT implement unrelated functionality.
+
+---
+
+# 🔄 MANDATORY TASK STATUS SYNCHRONIZATION
+
+When starting a task:
+
+### 1️⃣ Update Individual Task File (TASK_xxx.md)
+
+Add or update at top:
+
+```
+
+Status: 🟡 In Progress
+Started On: <date>
+
+```
+
+---
+
+When completing a task:
+
+### 2️⃣ Update TASK_xxx.md
+
+At the top:
+
+```
+
+Status: ✅ Completed
+Completed On: <date>
+
+```
+
+Add a new section at the bottom:
+
+```
+
+## Implementation Summary
+
+* Key modules modified:
+* Key design decisions:
+* Edge cases handled:
+* Notes:
+
+```
+
+---
+
+### 3️⃣ Update DEVELOPMENT_CHECKLIST.md
+
+- Change task status from 🟡 to ✅
+- Add short completion note
+- If task was Critical Path, verify dependent tasks are now unblocked
+
+⚠️ Never skip updating both files.
+⚠️ Task file and checklist must always remain synchronized.
+
+---
+
+# 🔴 CORE PRINCIPLES
+
+1. Code must be readable before clever.
+2. Code must be explicit over implicit.
+3. Code must fail safely.
+4. Code must be testable.
+5. Code must not contain unnecessary logic.
+6. Code must not contain unused imports.
+7. Code must not contain dead code.
+8. Code must not contain magic numbers.
+9. Code must not assume happy-path only.
+10. Code must not break under edge cases.
+
+---
+
+# 🧱 ARCHITECTURE ALIGNMENT (STRICT)
+
+- Respect defined architecture layers.
+- No cross-layer violations.
+- No business logic inside controllers.
+- No DB logic inside routes.
+- No side effects inside pure functions.
+- Modify only files under the mapped component.
+
+---
+
+# 📏 TASK SCOPE ENFORCEMENT
+
+- Implement only listed Deliverables.
+- Do not expand scope.
+- If missing dependency discovered:
+  - Document it
+  - Do NOT silently extend scope
+- No speculative features.
+
+---
+
+# 🧠 NAMING & STRUCTURE
+
+### Variables
+
+- Descriptive only.
+- No vague names.
+
+### Functions
+
+- Verb-based.
+- Clearly state behavior.
+
+### Classes
+
+- Domain nouns.
+- No generic `Helper`, `Manager`, `Utils`.
+
+### Constants
+
+- UPPER_CASE.
+- No inline hardcoded values.
+
+---
+
+# 🧹 CODE CLEANLINESS
+
+- No commented-out code.
+- No debug prints.
+- No temporary scaffolding.
+- No unused imports.
+- No unused variables.
+- Avoid nesting > 3 levels.
+- Keep functions focused.
+
+---
+
+# ⚙️ ERROR HANDLING & SAFETY
+
+- Never swallow exceptions.
+- Use explicit exception types.
+- Validate all inputs.
+- Guard external calls.
+- Enforce timeouts.
+- Return structured errors.
+- Handle edge cases explicitly.
+
+---
+
+# 🚀 PERFORMANCE DISCIPLINE
+
+- Avoid N+1 DB patterns.
+- Avoid redundant computation.
+- Avoid blocking async.
+- Cache only when justified.
+- Profile before optimizing deeply.
+
+---
+
+# 🔐 SECURITY DISCIPLINE
+
+- Never log secrets.
+- Validate and sanitize inputs.
+- Use parameterized queries.
+- Enforce authentication & authorization.
+- Prevent injection risks.
+
+---
+
+# 🧪 TESTABILITY
+
+- Separate business logic from I/O.
+- Avoid global mutable state.
+- Use dependency injection.
+- Keep modules loosely coupled.
+- Ensure new logic is testable in isolation.
+
+---
+
+# 📊 LOGGING & OBSERVABILITY
+
+- Structured logging only.
+- Include correlation IDs.
+- Log important transitions.
+- Avoid log noise.
+- No logs inside tight loops.
+
+---
+
+# 🔁 DEPENDENCY DISCIPLINE
+
+- No circular imports.
+- No unnecessary libraries.
+- Justify new dependencies.
+- Maintain clean boundaries.
+
+---
+
+# 🛡 PRODUCTION SAFETY CHECKLIST (BEFORE MARKING COMPLETE)
+
+Before setting task to ✅:
+
+- [ ] Task scope implemented
+- [ ] Acceptance criteria satisfied
+- [ ] Edge cases handled
+- [ ] Exceptions handled properly
+- [ ] No unused imports
+- [ ] No debug statements
+- [ ] Lint passed
+- [ ] Type checks passed
+- [ ] Tests written (if required)
+- [ ] Documentation updated
+- [ ] TASK_xxx.md updated
+- [ ] DEVELOPMENT_CHECKLIST.md updated
+
+---
+
+# 🚫 ABSOLUTE PROHIBITIONS
+
+Do NOT:
+
+- Implement multiple tasks silently.
+- Skip updating task status.
+- Modify unrelated modules.
+- Leave TODO placeholders.
+- Leave incomplete logic.
+- Break architecture boundaries.
+- Introduce race conditions.
+- Hardcode secrets.
+- Ignore dependency constraints.
+
+---
+
+# FINAL INSTRUCTION
+
+When coding:
+
+- Load one TASK_xxx.md.
+- Validate dependencies.
+- Mark In Progress.
+- Implement strictly within scope.
+- Validate against Acceptance Criteria.
+- Update TASK_xxx.md status + Implementation Summary.
+- Update DEVELOPMENT_CHECKLIST.md.
+- Stop.
+
+This is structured enterprise execution.
+
+You are not experimenting.
+You are executing a production system.
+
+Write like a Staff Engineer accountable to an Architecture Review Board.