@intoinside/praxis 1.0.1

package/src/index.ts

@@ -0,0 +1,97 @@
+#!/usr/bin/env node
+import { Command } from 'commander';
+import { manifest } from './manifest.js';
+import { initCommand } from './commands/init.js';
+import { intentCreateAction } from './commands/intent/create.js';
+import { intentListAction } from './commands/intent/list.js';
+import { generateSlashCommandsAction } from './commands/integration/generate.js';
+
+import { specDeriveAction } from './commands/spec/derive.js';
+import { specDeleteAction } from './commands/spec/delete.js';
+import { specApplyAction } from './commands/spec/apply.js';
+import { specArchiveAction } from './commands/spec/archive.js';
+
+const program = new Command();
+
+program
+    .name('praxis')
+    .description('Praxis: Intent-First Development Framework')
+    .version('1.0.0');
+
+// Dynamically build commands from manifest
+manifest.forEach((cmdDef) => {
+    const cmd = program.command(cmdDef.name).description(cmdDef.description);
+
+    if (cmdDef.subcommands) {
+        cmdDef.subcommands.forEach((subCmdDef) => {
+            const subCmd = cmd.command(subCmdDef.name).description(subCmdDef.description);
+
+            if (subCmdDef.arguments) {
+                subCmdDef.arguments.forEach(arg => {
+                    const argStr = arg.required ? `<${arg.name}>` : `[${arg.name}]`;
+                    subCmd.argument(argStr, arg.description);
+                });
+            }
+
+            if (subCmdDef.options) {
+                subCmdDef.options.forEach(opt => {
+                    const flag = opt.required ? `<${opt.name}>` : `[${opt.name}]`;
+                    subCmd.option(opt.alias ? `-${opt.alias}, --${opt.name} ${flag}` : `--${opt.name} ${flag}`, opt.description);
+                });
+            }
+
+            subCmd.action(async (...args: any[]) => {
+                if (cmdDef.name === 'intent' && subCmdDef.name === 'create') {
+                    const [description] = args;
+                    await intentCreateAction(description);
+                } else if (cmdDef.name === 'intent' && subCmdDef.name === 'list') {
+                    await intentListAction();
+                } else if (cmdDef.name === 'integration' && subCmdDef.name === 'generate-slash-commands') {
+                    const [tool] = args;
+                    await generateSlashCommandsAction(tool);
+                } else if (cmdDef.name === 'spec' && subCmdDef.name === 'derive') {
+                    const [options] = args;
+                    await specDeriveAction(options);
+                } else if (cmdDef.name === 'spec' && subCmdDef.name === 'delete') {
+                    const [specId] = args;
+                    await specDeleteAction(specId);
+                } else if (cmdDef.name === 'spec' && subCmdDef.name === 'apply') {
+                    const [specId] = args;
+                    await specApplyAction(specId);
+                } else if (cmdDef.name === 'spec' && subCmdDef.name === 'archive') {
+                    const [specId] = args;
+                    await specArchiveAction(specId);
+                } else {
+                    console.log(`Executing ${cmdDef.name} ${subCmdDef.name}...`);
+                    // Implementation will go here
+                }
+            });
+        });
+    } else {
+        // Top-level command with no subcommands
+        if (cmdDef.arguments) {
+            cmdDef.arguments.forEach(arg => {
+                const argStr = arg.required ? `<${arg.name}>` : `[${arg.name}]`;
+                cmd.argument(argStr, arg.description);
+            });
+        }
+
+        if (cmdDef.options) {
+            cmdDef.options.forEach(opt => {
+                const flag = opt.required ? `<${opt.name}>` : `[${opt.name}]`;
+                cmd.option(opt.alias ? `-${opt.alias}, --${opt.name} ${flag}` : `--${opt.name} ${flag}`, opt.description);
+            });
+        }
+
+        cmd.action(async () => {
+            if (cmdDef.name === 'init') {
+                await initCommand();
+            } else {
+                console.log(`Executing ${cmdDef.name}...`);
+                // Implementation will go here
+            }
+        });
+    }
+});
+
+program.parse();

package/src/manifest.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Praxis Command Manifest
+ * This file defines all supported commands and subcommands for the Praxis CLI.
+ */
+export interface CommandDefinition {
+    name: string;
+    description: string;
+    subcommands?: CommandDefinition[];
+    options?: {
+        name: string;
+        description: string;
+        alias?: string;
+        required?: boolean;
+    }[];
+    arguments?: {
+        name: string;
+        description: string;
+        required?: boolean;
+    }[];
+}
+export declare const manifest: CommandDefinition[];

package/src/manifest.js

@@ -0,0 +1,170 @@
+/**
+ * Praxis Command Manifest
+ * This file defines all supported commands and subcommands for the Praxis CLI.
+ */
+export const manifest = [
+    {
+        name: 'init',
+        description: 'Initialize a new project to be used with Praxis',
+    },
+    {
+        name: 'intent',
+        description: 'Manage intents (the WHY)',
+        subcommands: [
+            {
+                name: 'create',
+                description: 'Create a new intent',
+                arguments: [
+                    {
+                        name: 'description',
+                        description: 'The description of the intent to create',
+                        required: true,
+                    }
+                ]
+            },
+            {
+                name: 'update',
+                description: 'Update an existing intent',
+            },
+            {
+                name: 'validate',
+                description: 'Validate all intents for completeness and consistency',
+            },
+            {
+                name: 'list',
+                description: 'List all defined intents',
+            },
+            {
+                name: 'check',
+                description: 'Verify that current specs and code still satisfy all intents',
+            },
+        ],
+    },
+    {
+        name: 'model',
+        description: 'Generate or update the intent model',
+        options: [
+            {
+                name: 'intent-id',
+                description: 'The ID of the intent to model',
+                required: true
+            }
+        ]
+    },
+    {
+        name: 'spec',
+        description: 'Manage specifications (the WHAT)',
+        subcommands: [
+            {
+                name: 'derive',
+                description: 'Generate initial specifications from an intent or intent model',
+                options: [
+                    {
+                        name: 'from',
+                        description: 'The ID of the intent or model to derive from',
+                        required: true,
+                    },
+                ],
+            },
+            {
+                name: 'refine',
+                description: 'Manually refine a specification while preserving intent traceability',
+            },
+            {
+                name: 'validate',
+                description: 'Validate specs for internal consistency and completeness',
+            },
+            {
+                name: 'lock',
+                description: 'Lock a specification as a formal contract',
+            },
+            {
+                name: 'list',
+                description: 'List all specifications and their associated intents',
+            },
+            {
+                name: 'check',
+                description: 'Verify implementation compliance against locked specs',
+            },
+            {
+                name: 'delete',
+                description: 'Delete a specification and its artifacts',
+                arguments: [
+                    {
+                        name: 'spec-id',
+                        description: 'The ID of the spec to delete',
+                        required: true,
+                    },
+                ],
+            },
+            {
+                name: 'archive',
+                description: 'Archive a specification',
+                arguments: [
+                    {
+                        name: 'spec-id',
+                        description: 'The ID of the spec to archive',
+                        required: true,
+                    },
+                ],
+            },
+            {
+                name: 'apply',
+                description: 'Implement a specification',
+                arguments: [
+                    {
+                        name: 'spec-id',
+                        description: 'The ID of the spec to apply',
+                        required: true,
+                    },
+                ],
+            },
+        ],
+    },
+    {
+        name: 'analyze',
+        description: 'Analyze impact and drift',
+        subcommands: [
+            {
+                name: 'impact',
+                description: 'Analyze the impact of changes to an intent on specs and code',
+                options: [
+                    {
+                        name: 'intent',
+                        description: 'The ID of the intent to analyze',
+                        required: true,
+                    },
+                ],
+            },
+            {
+                name: 'drift',
+                description: 'Detect intent/spec/code drift',
+            },
+        ],
+    },
+    {
+        name: 'integration',
+        description: 'IDE and AI integration',
+        subcommands: [
+            {
+                name: 'serve',
+                description: 'Expose Praxis commands through a local service',
+            },
+            {
+                name: 'commands',
+                description: 'List all available commands in machine-readable form',
+            },
+            {
+                name: 'generate-slash-commands',
+                description: 'Generate slash command definitions for IDE integration',
+                arguments: [
+                    {
+                        name: 'tool',
+                        description: 'The tool ID (e.g., antigravity)',
+                        required: true,
+                    }
+                ]
+            },
+        ],
+    },
+];

package/src/manifest.ts

@@ -0,0 +1,188 @@
+/**
+ * Praxis Command Manifest
+ * This file defines all supported commands and subcommands for the Praxis CLI.
+ */
+
+export interface CommandDefinition {
+  name: string;
+  description: string;
+  subcommands?: CommandDefinition[];
+  options?: {
+    name: string;
+    description: string;
+    alias?: string;
+    required?: boolean;
+  }[];
+  arguments?: {
+    name: string;
+    description: string;
+    required?: boolean;
+  }[];
+}
+
+export const manifest: CommandDefinition[] = [
+  {
+    name: 'init',
+    description: 'Initialize a new project to be used with Praxis',
+  },
+  {
+    name: 'intent',
+    description: 'Manage intents (the WHY)',
+    subcommands: [
+      {
+        name: 'create',
+        description: 'Create a new intent',
+        arguments: [
+          {
+            name: 'description',
+            description: 'The description of the intent to create',
+            required: true,
+          }
+        ]
+      },
+      {
+        name: 'update',
+        description: 'Update an existing intent',
+      },
+      {
+        name: 'validate',
+        description: 'Validate all intents for completeness and consistency',
+      },
+      {
+        name: 'list',
+        description: 'List all defined intents',
+      },
+      {
+        name: 'check',
+        description: 'Verify that current specs and code still satisfy all intents',
+      },
+    ],
+  },
+  {
+    name: 'model',
+    description: 'Generate or update the intent model',
+    options: [
+      {
+        name: 'intent-id',
+        description: 'The ID of the intent to model',
+        required: true
+      }
+    ]
+  },
+  {
+    name: 'spec',
+    description: 'Manage specifications (the WHAT)',
+    subcommands: [
+      {
+        name: 'derive',
+        description: 'Generate initial specifications from an intent or intent model',
+        options: [
+          {
+            name: 'from',
+            description: 'The ID of the intent or model to derive from',
+            required: true,
+          },
+        ],
+      },
+      {
+        name: 'refine',
+        description: 'Manually refine a specification while preserving intent traceability',
+      },
+      {
+        name: 'validate',
+        description: 'Validate specs for internal consistency and completeness',
+      },
+      {
+        name: 'lock',
+        description: 'Lock a specification as a formal contract',
+      },
+      {
+        name: 'list',
+        description: 'List all specifications and their associated intents',
+      },
+      {
+        name: 'check',
+        description: 'Verify implementation compliance against locked specs',
+      },
+      {
+        name: 'delete',
+        description: 'Delete a specification and its artifacts',
+        arguments: [
+          {
+            name: 'spec-id',
+            description: 'The ID of the spec to delete',
+            required: true,
+          },
+        ],
+      },
+      {
+        name: 'archive',
+        description: 'Archive a specification',
+        arguments: [
+          {
+            name: 'spec-id',
+            description: 'The ID of the spec to archive',
+            required: true,
+          },
+        ],
+      },
+      {
+        name: 'apply',
+        description: 'Implement a specification',
+        arguments: [
+          {
+            name: 'spec-id',
+            description: 'The ID of the spec to apply',
+            required: true,
+          },
+        ],
+      },
+    ],
+  },
+  {
+    name: 'analyze',
+    description: 'Analyze impact and drift',
+    subcommands: [
+      {
+        name: 'impact',
+        description: 'Analyze the impact of changes to an intent on specs and code',
+        options: [
+          {
+            name: 'intent',
+            description: 'The ID of the intent to analyze',
+            required: true,
+          },
+        ],
+      },
+      {
+        name: 'drift',
+        description: 'Detect intent/spec/code drift',
+      },
+    ],
+  },
+  {
+    name: 'integration',
+    description: 'IDE and AI integration',
+    subcommands: [
+      {
+        name: 'serve',
+        description: 'Expose Praxis commands through a local service',
+      },
+      {
+        name: 'commands',
+        description: 'List all available commands in machine-readable form',
+      },
+      {
+        name: 'generate-slash-commands',
+        description: 'Generate slash command definitions for IDE integration',
+        arguments: [
+          {
+            name: 'tool',
+            description: 'The tool ID (e.g., antigravity)',
+            required: true,
+          }
+        ]
+      },
+    ],
+  },
+];

package/templates/checklist-template.md

@@ -0,0 +1,42 @@
+# [Feature] Requirements Quality Checklist
+
+**Purpose**: Validate intent completeness and quality before proceeding to planning
+**Created**: [DATE]
+**Feature**: [Link to intent.md]
+
+## Content Quality
+
+- [ ] No implementation details (languages, frameworks, APIs)
+- [ ] Focused on user value and business needs
+- [ ] Written for non-technical stakeholders
+- [ ] All mandatory sections completed
+- [ ] User stories prioritized by business value and technical feasibility
+- [ ] Clear success thresholds defined (minimum viable, target, stretch goals)
+
+## Requirement Completeness
+
+- [ ] No [NEEDS CLARIFICATION] markers remain
+- [ ] Requirements are testable and unambiguous
+- [ ] Success criteria are measurable
+- [ ] Success criteria are technology-agnostic (no implementation details)
+- [ ] All acceptance scenarios are defined
+- [ ] Edge cases are identified
+- [ ] Scope is clearly bounded
+- [ ] Dependencies and assumptions identified
+- [ ] Non-functional requirements specified (performance, security, scalability, usability)
+
+## Feature Readiness
+
+- [ ] All functional requirements have clear acceptance criteria
+- [ ] User scenarios cover primary flows
+- [ ] Feature meets measurable outcomes defined in Success Criteria
+- [ ] No implementation details leak into intent
+- [ ] User stories are independently testable and deliverable
+- [ ] Risk assessment and mitigation strategies documented
+
+## Validation Results
+
+- [ ] Checklist completed by: [Name/Role]
+- [ ] Date of validation: [DATE]
+- [ ] Overall status: [Pass/Fail/Conditional Pass]
+- [ ] Action items for improvements: [List any required changes]