gaslighting-engine 0.1.0

package/dist/core/generateOtherMarkdown.js

@@ -0,0 +1,529 @@
+import { bullets, decisionDate, missingInfoTable, stackSummary } from "./content.js";
+import { generateGaslightingMarkdown } from "./generateGaslightingMarkdown.js";
+import { generatePrdMarkdown } from "./generatePrdMarkdown.js";
+export function generateAssumptionsMarkdown(analysis) {
+    return `# ASSUMPTIONS.md
+
+${analysis.assumptions
+        .map((assumption, index) => `## Assumption: ${titleFromAssumption(assumption, index)}
+
+Status: Active
+Confidence: ${analysis.confidence === "high" ? "High" : analysis.confidence === "medium" ? "Medium" : "Low"}
+Impact: ${index === 0 ? "High" : "Medium"}
+
+### Why this assumption was made
+
+${assumption}
+
+The user did not provide enough confirmed detail to treat this as fact.
+
+### What could make this wrong
+
+The user provides a different business model, vertical, stack, audience, market, or production constraint.
+
+### What changes if this assumption is wrong
+
+The PRD, page list, data model, implementation priorities, and copy may need to change.
+
+### How to replace this assumption
+
+Provide confirmed information and run \`gaslighting update "new information here"\`.
+`)
+        .join("\n")}
+`;
+}
+export function generateMissingInfoMarkdown(analysis) {
+    return `# MISSING_INFO.md
+
+Missing information must be classified honestly.
+
+Most missing information is not blocking.
+
+If information is missing but implementation can proceed with a practical assumption, document it and continue.
+
+${missingInfoTable(analysis.missingInfo)}
+`;
+}
+export function generateDecisionLogMarkdown(input, analysis) {
+    return `# DECISION_LOG.md
+
+## Decision: Initialize Gaslighting documents
+
+Date: ${decisionDate()}
+
+### Decision
+
+Generate strict Gaslighting-engine project-control documents for the request:
+
+> ${input.rawUserRequest}
+
+### Reason
+
+The project needs AI-agent discipline before implementation so the agent does not drift, shrink scope, leave TODOs, or fake completion.
+
+### Alternatives Considered
+
+- Start coding without discipline documents.
+- Ask the user a long list of questions before making progress.
+- Use an LLM API to generate custom documents.
+
+### Why Alternatives Were Not Chosen
+
+- Coding without control documents increases fake-completion risk.
+- Most missing information can be assumed and documented.
+- MVP must be deterministic and must not call an LLM API.
+
+### Risk
+
+The initial project type or assumptions may be wrong.
+
+### Revisit When
+
+The user provides confirmed business details, stack choices, scope changes, or production constraints.
+
+## Decision: Project type classification
+
+Date: ${decisionDate()}
+
+### Decision
+
+Classified project type as \`${analysis.projectType}\` with \`${analysis.confidence}\` confidence.
+
+### Reason
+
+Keyword-based classification is deterministic and enough for MVP.
+
+### Alternatives Considered
+
+- Ask the user to classify the project manually.
+- Use an external LLM API.
+
+### Why Alternatives Were Not Chosen
+
+- Manual classification slows progress.
+- External LLM APIs are excluded from MVP.
+
+### Risk
+
+Low-confidence classification can create the wrong project-specific template.
+
+### Revisit When
+
+The user says the project type is different or adds a clearer project description.
+
+## Decision: Stack policy
+
+Date: ${decisionDate()}
+
+### Decision
+
+${stackSummary(analysis)}
+
+### Reason
+
+Technology must serve the product purpose and avoid over-engineering.
+
+### Alternatives Considered
+
+- Introduce advanced infrastructure up front.
+- Leave stack completely undefined.
+
+### Why Alternatives Were Not Chosen
+
+- Advanced infrastructure is forbidden by default.
+- Undefined stack choices allow drift and inconsistent agent behavior.
+
+### Risk
+
+Production needs may require a provider change later.
+
+### Revisit When
+
+Deployment provider, database provider, storage, analytics, email, or payment requirements are confirmed.
+`;
+}
+export function generateStackPolicyMarkdown(analysis) {
+    return `# STACK_POLICY.md
+
+## Detected Stack Hints
+
+${analysis.detectedStackHints.length ? bullets(analysis.detectedStackHints) : "- No stack hints detected."}
+
+If detected stack hints conflict with the project purpose, the project purpose wins.
+
+## Default Web Stack
+
+- Framework: Next.js latest stable version
+- Language: TypeScript
+- Styling: Tailwind CSS
+- UI: shadcn/ui
+- Database: PostgreSQL
+- DB Provider: NeonDB first, Supabase alternative
+- Hosting: Vercel
+- File Storage: Vercel Blob or Cloudflare R2
+- Analytics: GA4 + Google Tag Manager
+- Email: Resend or equivalent
+- ORM: Prisma or Drizzle
+
+## Stack Selection Rules
+
+### Choose NeonDB when
+
+- The project needs PostgreSQL.
+- The project is deployed on Vercel.
+- Serverless-friendly PostgreSQL is useful.
+- A clean MVP database is enough.
+
+### Choose Supabase when
+
+- Auth, DB, and storage should be bundled.
+- Admin/user accounts are likely.
+- The project benefits from Supabase dashboard operations.
+- Storage and database need to live together.
+
+### Choose Vercel Blob when
+
+- The project is Vercel-centered.
+- File uploads are simple.
+- Operational simplicity matters.
+
+### Choose Cloudflare R2 when
+
+- Storage volume may grow.
+- CDN/cost strategy matters.
+- Cloudflare DNS/cache is already part of the plan.
+
+## Forbidden by Default
+
+Do not introduce the following unless explicitly required:
+
+- Kubernetes
+- Kafka
+- RabbitMQ
+- Microservices
+- GraphQL Federation
+- Redis Cluster
+- Terraform-heavy infrastructure
+- Event sourcing
+- Multi-region deployment
+- Complex distributed systems
+`;
+}
+export function generateAgentsMarkdown() {
+    return `# AGENTS.md
+
+This repository uses Gaslighting-engine.
+
+Before doing any work, read these files in order:
+
+1. \`GASLIGHTING.md\`
+2. \`PRD.md\`
+3. \`STACK_POLICY.md\`
+4. \`MISSING_INFO.md\`
+5. \`ASSUMPTIONS.md\`
+6. \`DECISION_LOG.md\`
+7. \`MEMORY.md\`
+
+## Prime Directive
+
+Do not forget the project purpose.
+
+Do not reduce the requested scope.
+
+Do not pretend partial work is complete.
+
+Do not use TODO comments as fake implementation.
+
+Do not create representative examples when the user requested full coverage.
+
+Do not say "the rest follows the same pattern."
+
+If information is missing, make a reasonable assumption, document it, and continue unless the missing information is truly blocking.
+
+## Completion Standard
+
+A task is complete only when:
+
+- The requested scope is fully handled.
+- No required item is silently skipped.
+- No placeholder is pretending to be implementation.
+- No TODO is used as a substitute for work.
+- The output can actually be used.
+- New assumptions are documented.
+- New technical decisions are recorded.
+- Stable project facts are recorded in \`MEMORY.md\`.
+- The result does not contradict \`GASLIGHTING.md\`.
+
+If the task is incomplete, say it is incomplete.
+
+Do not fake completion.
+`;
+}
+export function generateMemoryMarkdown(input, analysis) {
+    return `# MEMORY.md
+
+This is the local project memory for Gaslighting-engine.
+
+It is inspired by agent memory systems, but it is not a vague diary.
+
+It records stable project facts, recurring workflow rules, known failure patterns, and decisions that future AI-agent sessions must not forget.
+
+Keep required rules in \`AGENTS.md\`, \`GASLIGHTING.md\`, and checked-in documents. Treat this file as a compact recall layer, not the only source of truth.
+
+## Stable Project Facts
+
+- Original request: ${input.rawUserRequest}
+- Project type: ${analysis.projectType}
+- Classification confidence: ${analysis.confidence}
+- Stack hints: ${analysis.detectedStackHints.length ? analysis.detectedStackHints.join(", ") : "none"}
+
+## Working Preferences
+
+- Prefer the shortest useful command: \`gaslighting "project request"\`.
+- Default discipline mode is hardcore.
+- Full-scope enforcement is default.
+- No-TODO escape prevention is default.
+- No-shortcut enforcement is default.
+- Missing information should be assumed, documented, and carried forward unless truly blocking.
+
+## Known Agent Failure Patterns
+
+- Summarizing remaining work instead of doing it.
+- Treating representative examples as full implementation.
+- Using TODO comments as a substitute for requested work.
+- Creating placeholders and calling them structure.
+- Forgetting the project purpose after the first implementation pass.
+- Over-engineering instead of delivering the concrete MVP.
+
+## Hades-Style Audit Rules
+
+These are cleanup and verification rules:
+
+- Zero fake completion.
+- Zero TODO escape.
+- Zero dead placeholder files pretending to be implementation.
+- Zero unexplained scope reductions.
+- Zero unverified success claims.
+- Every destructive cleanup must be intentional and explainable.
+- If code or files are removed, record why in \`DECISION_LOG.md\`.
+
+## Memory Write Rules
+
+Add to this file only when a fact is stable and useful across future sessions.
+
+Do not store secrets, API keys, credentials, private tokens, or sensitive personal data.
+
+When a memory becomes wrong, do not silently delete it. Mark it outdated and append the corrected fact.
+
+## Current Assumptions To Remember
+
+${bullets(analysis.assumptions)}
+`;
+}
+export function generateSkillMarkdown() {
+    return `---
+name: gaslighting
+description: Generate or update strict project discipline documents for Codex and AI coding agents. Use when a user asks to initialize Gaslighting, create GASLIGHTING.md/PRD.md/AGENTS.md discipline files, preserve full project scope, prevent TODO escape, prevent fake completion, or turn vague project intent into actionable control documents.
+---
+
+# Gaslighting-engine Skill
+
+You are a project-discipline generator for AI coding agents.
+
+When a user gives a vague project request, do not stop and ask a long list of questions.
+
+Instead:
+
+1. Infer the project type.
+2. Identify the project's core purpose.
+3. Make reasonable assumptions.
+4. Document assumptions clearly.
+5. Mark missing information clearly.
+6. Generate \`GASLIGHTING.md\`.
+7. Generate \`PRD.md\`.
+8. Generate \`ASSUMPTIONS.md\`.
+9. Generate \`MISSING_INFO.md\`.
+10. Generate \`DECISION_LOG.md\`.
+11. Generate \`STACK_POLICY.md\`.
+12. Generate or update \`AGENTS.md\`.
+
+## Hardcore Discipline Rule
+
+The generated documents must prevent escape behavior.
+
+Explicitly forbid:
+
+- implementing only representative examples
+- leaving TODOs instead of implementation
+- saying "the rest can be done similarly"
+- silently reducing requested scope
+- pretending the task is complete
+- replacing implementation with explanation
+- creating empty placeholders
+- skipping repetitive items because they are repetitive
+- treating structure as completion
+- treating direction as delivery
+
+The agent must either:
+
+1. complete the full requested scope, or
+2. clearly declare what is incomplete.
+
+Never allow fake completion.
+
+Never allow scope shrinkage.
+
+Never allow TODO-based escape.
+
+## Missing Information Rule
+
+Missing information is not a free excuse to stop.
+
+Classify missing information as:
+
+- Confirmed
+- Assumed
+- Missing but non-blocking
+- Missing and risky
+- Missing and blocking
+
+Only truly blocking information may stop implementation.
+
+## Default Tech Policy
+
+For web projects, prefer:
+
+- Next.js
+- TypeScript
+- Tailwind CSS
+- shadcn/ui
+- PostgreSQL
+- NeonDB or Supabase
+- Vercel
+- Vercel Blob or Cloudflare R2
+- GA4 + Google Tag Manager when analytics are needed
+- Resend or equivalent when email is needed
+
+Avoid over-engineering.
+
+## Output Rule
+
+Create real markdown files.
+
+Do not only explain.
+
+Do not produce a plan without files.
+
+Do not say what should be done.
+
+Generate the actual project discipline documents.
+`;
+}
+export function generateSkillOpenAiYaml() {
+    return `interface:
+  display_name: "Gaslighting-engine"
+  short_description: "Generate strict Codex project discipline docs"
+  brand_color: "#111827"
+  default_prompt: "Use $gaslighting to generate Gaslighting-engine discipline documents before implementation."
+
+policy:
+  allow_implicit_invocation: true
+`;
+}
+export function generateCodexPromptMarkdown() {
+    return `# CODEX_PROMPT.md
+
+Copy and paste this into Codex:
+
+---
+
+Read the following files before doing any work:
+
+1. \`GASLIGHTING.md\`
+2. \`PRD.md\`
+3. \`STACK_POLICY.md\`
+4. \`MISSING_INFO.md\`
+5. \`ASSUMPTIONS.md\`
+6. \`DECISION_LOG.md\`
+7. \`AGENTS.md\`
+8. \`MEMORY.md\`
+
+Then implement the project MVP.
+
+Rules:
+
+- Do not shrink the scope.
+- Do not leave TODOs instead of implementation.
+- Do not implement only representative examples.
+- Do not say "the rest follows the same pattern."
+- Do not call scaffolding completion.
+- Do not call placeholders implementation.
+- Do not over-engineer.
+- Do not forget the project purpose.
+- If something is incomplete, declare it explicitly.
+
+Before claiming completion, perform the self-audit in \`GASLIGHTING.md\`.
+
+Proceed.
+`;
+}
+export function generateCodexSlashPromptMarkdown() {
+    return `# /gaslighting
+
+Read the Gaslighting-engine project-control files before doing any work:
+
+1. \`GASLIGHTING.md\`
+2. \`PRD.md\`
+3. \`STACK_POLICY.md\`
+4. \`MISSING_INFO.md\`
+5. \`ASSUMPTIONS.md\`
+6. \`DECISION_LOG.md\`
+7. \`AGENTS.md\`
+8. \`MEMORY.md\`
+
+Then execute the user's requested implementation.
+
+Rules:
+
+- Preserve the full requested scope.
+- Make reasonable assumptions and document them.
+- Do not use TODO comments as fake implementation.
+- Do not implement only representative examples.
+- Do not say "the rest follows the same pattern."
+- Do not call scaffolding completion.
+- Do not call placeholders implementation.
+- Do not over-engineer.
+- Record stable project facts in \`MEMORY.md\`.
+- Record product and technical decisions in \`DECISION_LOG.md\`.
+- If something is incomplete, declare it explicitly.
+
+Before claiming completion, perform the self-audit in \`GASLIGHTING.md\`.
+`;
+}
+export function generateSkillReferenceDocs() {
+    const referenceInput = {
+        rawUserRequest: "I want to build a hospital website.",
+        projectType: "hospital_homepage",
+        mode: "hardcore",
+        fullScope: true,
+        noTodo: true,
+        noShortcut: true,
+    };
+    const referenceAnalysis = {
+        projectType: "hospital_homepage",
+        confidence: "high",
+        detectedStackHints: [],
+        assumptions: ["Hospital name: Sample Clinic.", "Hospital type: dermatology/aesthetic clinic."],
+        missingInfo: [],
+    };
+    return [
+        { filename: ".codex/skills/gaslighting/references/GASLIGHTING_TEMPLATE.md", content: generateGaslightingMarkdown(referenceInput, referenceAnalysis) },
+        { filename: ".codex/skills/gaslighting/references/HARDCORE_DISCIPLINE_TEMPLATE.md", content: generateGaslightingMarkdown(referenceInput, referenceAnalysis) },
+        { filename: ".codex/skills/gaslighting/references/STACK_POLICY_TEMPLATE.md", content: generateStackPolicyMarkdown(referenceAnalysis) },
+        { filename: ".codex/skills/gaslighting/references/HOSPITAL_HOMEPAGE_EXAMPLE.md", content: generatePrdMarkdown(referenceInput, referenceAnalysis) },
+        { filename: ".codex/skills/gaslighting/scripts/generate-gaslighting-docs.ts", content: `// Generated placeholder script for skill users.\n// Prefer the gaslighting CLI for full document generation.\nconsole.log("Run: gaslighting \\"I want to build a hospital website.\\"");\n` },
+    ];
+}
+function titleFromAssumption(assumption, index) {
+    return assumption.split(".")[0]?.replace(/[:`]/g, "").slice(0, 80) || `Assumption ${index + 1}`;
+}

package/dist/core/generatePrdMarkdown.js

@@ -0,0 +1,125 @@
+import { bullets, featureList, pageList, projectPurpose, stackSummary } from "./content.js";
+export function generatePrdMarkdown(input, analysis) {
+    return `# PRD.md
+
+## 1. Product Overview
+
+Build an MVP for this request:
+
+> ${input.rawUserRequest}
+
+Classified project type: \`${analysis.projectType}\`
+
+The product must preserve the user's actual scope and must not become a decorative shell.
+
+## 2. Business Purpose
+
+${bullets(projectPurpose(analysis.projectType))}
+
+## 3. Target Users
+
+${targetUsers(analysis.projectType)}
+
+## 4. User Flows
+
+${userFlows(analysis.projectType)}
+
+## 5. Page List
+
+${bullets(pageList(analysis.projectType))}
+
+## 6. Feature List
+
+${bullets(featureList(analysis.projectType))}
+
+## 7. Data Model Draft
+
+${dataModel(analysis.projectType)}
+
+## 8. MVP Scope
+
+- Implement all pages, flows, and features listed above.
+- Include responsive behavior.
+- Include useful empty, loading, success, and error states where applicable.
+- Include SEO metadata where public pages exist.
+- Include analytics-ready structure where conversion matters.
+- Document every assumption that affects implementation.
+
+## 9. Out of Scope
+
+${outOfScope(analysis.projectType)}
+
+## 10. Non-Functional Requirements
+
+- Mobile-first where users are likely to arrive from search or ads.
+- Accessible semantic HTML.
+- Fast initial load for public pages.
+- Safe form validation and clear error messages.
+- Maintainable TypeScript structure.
+- No unnecessary distributed systems.
+
+## 11. Tech Stack
+
+${stackSummary(analysis)}
+
+See \`STACK_POLICY.md\` for defaults and forbidden-by-default technology.
+
+## 12. Risks
+
+- Vague source requirements can cause wrong vertical assumptions.
+- Placeholder copy can look real if not reviewed.
+- Missing production credentials can block deployment.
+- AI agents may reduce scope unless \`GASLIGHTING.md\` is enforced.
+
+## 13. Missing Information
+
+See \`MISSING_INFO.md\`.
+
+## 14. Success Criteria
+
+- The project purpose is visible in the implemented product.
+- The core pages and features are implemented, not merely described.
+- No required scope is replaced by representative examples.
+- No TODO is used as a substitute for implementation.
+- Assumptions and decisions remain documented.
+- The output can actually be used for the MVP purpose.
+`;
+}
+function targetUsers(type) {
+    if (type === "hospital_homepage")
+        return bullets(["Potential patients searching on mobile", "Patients comparing hospitals", "Users looking for treatment information", "Users who want to call, reserve, or ask questions", "Hospital staff receiving inquiries"]);
+    if (type === "ecommerce")
+        return bullets(["Shoppers browsing products", "Returning customers checking orders", "Store operators managing products and orders"]);
+    if (type === "landing_page")
+        return bullets(["Ad traffic visitors", "Qualified leads", "Operators reviewing submitted leads"]);
+    if (type === "admin_dashboard")
+        return bullets(["Internal operators", "Managers", "Admins reviewing and editing records"]);
+    return bullets(["Primary end users", "Project operators", "Stakeholders evaluating the MVP"]);
+}
+function userFlows(type) {
+    if (type === "ecommerce")
+        return bullets(["Browse products -> view detail -> add to cart -> checkout -> order complete", "Admin -> create/edit product -> review orders"]);
+    if (type === "hospital_homepage")
+        return bullets(["Search/mobile visitor -> home -> treatment/doctor trust -> contact or reservation CTA", "Visitor -> location/contact -> call or submit inquiry"]);
+    if (type === "landing_page")
+        return bullets(["Visitor -> understand offer -> compare benefits -> submit lead form", "Visitor -> FAQ/social proof -> final CTA"]);
+    if (type === "admin_dashboard")
+        return bullets(["Operator -> search/filter records -> inspect detail -> edit safely -> confirm result", "Manager -> review status -> handle exceptions"]);
+    return bullets(["Visitor/user enters primary page", "User completes the main conversion or workflow", "Operator can review submitted or operational data where applicable"]);
+}
+function dataModel(type) {
+    const models = {
+        hospital_homepage: ["Inquiry: name, phone, category, message, privacyConsent, status, createdAt", "Treatment: title, summary, body, image, order", "Doctor: name, specialty, bio, credentials, image", "Location: address, phone, hours, mapUrl"],
+        ecommerce: ["Product: title, slug, description, price, images, stockStatus", "CartItem: productId, quantity, priceSnapshot", "Order: customer, items, total, status, createdAt", "AdminUser: email, role"],
+        landing_page: ["Lead: name, emailOrPhone, source, message, consent, createdAt", "Offer: headline, benefits, proof, CTA"],
+        admin_dashboard: ["User: email, role, status", "Record: searchable fields, status, timestamps", "AuditLog: actor, action, target, createdAt"],
+    };
+    return bullets(models[type] ?? ["PrimaryEntity: title, status, description, timestamps", "SubmissionOrContact: name, contact, message, status, createdAt"]);
+}
+function outOfScope(type) {
+    if (type === "hospital_homepage")
+        return bullets(["full admin dashboard", "payment", "complex reservation calendar", "EMR integration", "user login", "multilingual content", "automated medical diagnosis"]);
+    if (type === "ecommerce")
+        return bullets(["warehouse automation", "multi-vendor marketplace", "subscription billing unless requested", "complex ERP integration"]);
+    return bullets(["LLM API integration unless explicitly requested", "complex infrastructure", "unrequested authentication", "unrequested payments", "native mobile apps"]);
+}

package/dist/index.js

@@ -0,0 +1,3 @@
+#!/usr/bin/env node
+import { buildCli, normalizeDefaultInitArgv } from "./cli.js";
+buildCli().parse(normalizeDefaultInitArgv(process.argv));

package/dist/types.js

@@ -0,0 +1 @@
+export {};