@dezkareid/osddt 0.0.0 → 1.1.0

package/README.md

@@ -1,2 +1,40 @@
 # osddt
-Other spec drivent development tool but for monorepo
+Other spec driven development tool but for monorepo
+
+## CLI Commands
+
+| Command                        | Description                                                   |
+| ------------------------------ | ------------------------------------------------------------- |
+| `@dezkareid/osddt setup`                  | Generate agent command files for Claude and Gemini            |
+| `@dezkareid/osddt meta-info`              | Output current branch and date as JSON                        |
+| `@dezkareid/osddt done <feature-name>`    | Move `working-on/<feature>` to `done/<feature>`               |
+
+## Command Templates
+
+Run `npx @dezkareid/osddt setup` once to generate the agent command files.
+
+`osddt.research` and `osddt.start` are **peer entry points** — use whichever fits your situation. Both lead to `osddt.spec`. Use `osddt.continue` to resume an in-progress feature from a new session.
+
+```
+osddt.continue ──────────────────────────────────────────────────────────────────────────────┐
+                                                                                              │
+osddt.research ──┐                                                                            │
+                 ├──► osddt.spec → osddt.plan → osddt.tasks → osddt.implement → osddt.done ◄─┘
+osddt.start    ──┘
+```
+
+| Template           | Description                                                        |
+| ------------------ | ------------------------------------------------------------------ |
+| `osddt.continue`   | Detect the current workflow phase and prompt the next command      |
+| `osddt.research`   | Research a topic and write a research file to inform the spec      |
+| `osddt.start`      | Start a new feature by creating a branch and working-on folder     |
+| `osddt.spec`       | Analyze requirements and write a feature specification             |
+| `osddt.plan`       | Create a technical implementation plan from a specification        |
+| `osddt.tasks`      | Generate actionable tasks from an implementation plan              |
+| `osddt.implement`  | Execute tasks from the task list one by one                        |
+| `osddt.done`       | Mark a feature as done and move it from working-on to done         |
+
+Generated files are placed in:
+
+- `.claude/commands/osddt.<name>.md` (Claude Code)
+- `.gemini/commands/osddt.<name>.toml` (Gemini CLI)

package/dist/commands/done.d.ts

@@ -0,0 +1,2 @@
+import { Command } from 'commander';
+export declare function doneCommand(): Command;

package/dist/commands/done.spec.d.ts

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

package/dist/commands/meta-info.d.ts

@@ -0,0 +1,2 @@
+import { Command } from 'commander';
+export declare function metaInfoCommand(): Command;

package/dist/commands/meta-info.spec.d.ts

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

package/dist/commands/setup.d.ts

@@ -0,0 +1,2 @@
+import { Command } from 'commander';
+export declare function setupCommand(): Command;

package/dist/index.d.ts

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

package/dist/index.js

@@ -0,0 +1,533 @@
+#!/usr/bin/env node
+import { Command } from 'commander';
+import path from 'path';
+import fs from 'fs-extra';
+import select from '@inquirer/select';
+import checkbox from '@inquirer/checkbox';
+import { execSync } from 'child_process';
+
+const REPO_PREAMBLE = `## Context
+
+Before proceeding, run the following command and parse the JSON output to get the current branch and date:
+
+\`\`\`
+npx @dezkareid/osddt meta-info
+\`\`\`
+
+## Repository Configuration
+
+Before proceeding, read the \`.osddtrc\` file in the root of the repository to determine the project path.
+
+\`\`\`json
+// .osddtrc example
+{ "repoType": "monorepo" | "single" }
+\`\`\`
+
+- If \`repoType\` is \`"single"\`: the project path is the repository root.
+- If \`repoType\` is \`"monorepo"\`: ask the user which package to work on (e.g. \`packages/my-package\`), then use \`<repo-root>/<package>\` as the project path.
+
+## Working Directory
+
+All generated files live under \`<project-path>/working-on/<feature-name>/\`. The \`<feature-name>\` is derived from the arguments provided. Create the directory if it does not exist.
+
+> All file paths in the instructions below are relative to \`<project-path>/working-on/<feature-name>/\`.
+
+`;
+const FEATURE_NAME_RULES = `### Feature Name Constraints
+
+When deriving a feature name from a description:
+
+- Use only lowercase letters, digits, and hyphens (\`a-z\`, \`0-9\`, \`-\`)
+- Replace spaces and special characters with hyphens
+- Remove consecutive hyphens (e.g. \`--\` → \`-\`)
+- Remove leading and trailing hyphens
+- **Maximum length: 30 characters** — if the derived name exceeds 30 characters, truncate at the last hyphen boundary before or at the 30th character
+- If the input is already a valid branch name (no spaces, kebab-case or slash-separated), apply the 30-character limit to the last segment only (after the last \`/\`)
+- Reject (and ask the user to provide a shorter name) if no valid name can be derived after truncation
+
+**Examples:**
+
+| Input | Derived feature name |
+| ----------------------------------------------------- | ---------------------------- |
+| \`Add user authentication\` | \`add-user-authentication\` |
+| \`Implement real-time notifications for dashboard\` | \`implement-real-time\` |
+| \`feat/add-user-authentication\` | \`add-user-authentication\` |
+| \`feat/implement-real-time-notifications-for-dashboard\` | \`implement-real-time\` |
+`;
+const WORKING_DIR_STEP = `Check whether the working directory \`<project-path>/working-on/<feature-name>\` already exists:
+   - If it **does not exist**, create it:
+     \`\`\`
+     mkdir -p <project-path>/working-on/<feature-name>
+     \`\`\`
+   - If it **already exists**, warn the user and ask whether to:
+     - **Resume** — continue into the existing folder (proceed to the next step without recreating it)
+     - **Abort** — stop and do nothing`;
+const COMMAND_DEFINITIONS = [
+    {
+        name: 'osddt.continue',
+        description: 'Detect the current workflow phase and prompt the next command to run',
+        body: (args) => `${REPO_PREAMBLE}## Instructions
+
+Check the working directory \`<project-path>/working-on/<feature-name>\` for the files listed below **in order** to determine the current phase. Use the first matching condition:
+
+| Condition | Current phase | Run next |
+| --------- | ------------- | -------- |
+| \`osddt.tasks.md\` exists **and** has at least one unchecked task (\`- [ ]\`) | Implementing | \`/osddt.implement ${args}\` |
+| \`osddt.tasks.md\` exists **and** all tasks are checked (\`- [x]\`) | Ready to close | \`/osddt.done ${args}\` |
+| \`osddt.plan.md\` exists | Planning done | \`/osddt.tasks ${args}\` |
+| \`osddt.spec.md\` exists | Spec done | \`/osddt.plan ${args}\` |
+| \`osddt.research.md\` exists | Research done | \`/osddt.spec ${args}\` |
+| None of the above | Not started | \`/osddt.spec ${args}\` (or \`/osddt.research ${args}\` if research is needed first) |
+
+Report which file was found, which phase that corresponds to, and the exact command the user should run next.
+
+## Arguments
+
+${args}
+`,
+    },
+    {
+        name: 'osddt.research',
+        description: 'Research a topic and write a research file to inform the feature specification',
+        body: (args) => `${REPO_PREAMBLE}## Instructions
+
+The argument provided is: ${args}
+
+Determine the feature name using the following logic:
+
+1. If ${args} looks like a branch name (e.g. \`feat/my-feature\`, \`my-feature-branch\` — no spaces, kebab-case or slash-separated), derive the feature name from the last segment (after the last \`/\`, or the full value if no \`/\` is present).
+2. Otherwise treat ${args} as a human-readable topic description and convert it to a feature name.
+
+Apply the constraints below before using the name:
+
+${FEATURE_NAME_RULES}
+
+Once the feature name is determined:
+
+3. ${WORKING_DIR_STEP}
+
+4. Research the topic thoroughly:
+   - Explore the existing codebase for relevant patterns, conventions, and prior art
+   - Identify related files, modules, and dependencies
+   - Note any constraints, risks, or open questions
+
+5. Write the findings to \`osddt.research.md\` in the working directory using the following format:
+
+## Research Format
+
+The research file should include:
+- **Topic**: What was researched and why
+- **Codebase Findings**: Relevant existing code, patterns, and conventions found
+- **External References**: Libraries, APIs, or documentation consulted
+- **Key Insights**: Important discoveries that should inform the specification
+- **Constraints & Risks**: Known limitations or risks uncovered during research
+- **Open Questions**: Ambiguities that the specification phase should resolve
+
+## Arguments
+
+${args}
+
+## Next Step
+
+Run the following command to write the feature specification:
+
+\`\`\`
+/osddt.spec ${args}
+\`\`\`
+`,
+    },
+    {
+        name: 'osddt.start',
+        description: 'Start a new feature by creating a branch and working-on folder',
+        body: (args) => `${REPO_PREAMBLE}## Instructions
+
+The argument provided is: ${args}
+
+Determine the branch name using the following logic:
+
+1. If ${args} looks like a branch name (e.g. \`feat/my-feature\`, \`fix/some-bug\`, \`my-feature-branch\` — no spaces, kebab-case or slash-separated), use it as-is.
+2. Otherwise treat ${args} as a human-readable feature description, convert it to a feature name, and use the format \`feat/<derived-name>\` as the branch name.
+
+Apply the constraints below to the feature name (the segment after the last \`/\`) before using it:
+
+${FEATURE_NAME_RULES}
+
+Once the branch name is determined:
+
+3. Check whether the branch already exists locally or remotely:
+   - If it **does not exist**, create and switch to it:
+     \`\`\`
+     git checkout -b <branch-name>
+     \`\`\`
+   - If it **already exists**, warn the user and ask whether to:
+     - **Resume** — switch to the existing branch (\`git checkout <branch-name>\`) and continue
+     - **Abort** — stop and do nothing
+
+4. ${WORKING_DIR_STEP}
+
+Where \`<feature-name>\` is the last segment of the branch name (after the last \`/\`, or the full branch name if no \`/\` is present).
+
+5. Report the branch name and working directory that were created or resumed.
+
+## Arguments
+
+${args}
+
+## Next Step
+
+Run the following command to write the feature specification:
+
+\`\`\`
+/osddt.spec ${args}
+\`\`\`
+`,
+    },
+    {
+        name: 'osddt.spec',
+        description: 'Analyze requirements and write a feature specification',
+        body: (args) => `## Instructions
+
+1. Check whether \`osddt.research.md\` exists in the working directory.
+   - If it exists, read it and use its findings (key insights, constraints, open questions, codebase findings) as additional context when writing the specification.
+   - If it does not exist, proceed using only the requirements provided in ${args}.
+2. Analyze the requirements provided in ${args}
+3. Identify the core problem being solved
+4. Define the scope, constraints, and acceptance criteria
+5. Write the specification to \`osddt.spec.md\` in the working directory
+
+## Specification Format
+
+The spec should include:
+- **Overview**: What and why
+- **Requirements**: Functional and non-functional
+- **Scope**: What is in and out of scope
+- **Acceptance Criteria**: Clear, testable criteria
+- **Open Questions**: Any ambiguities to resolve
+
+> If \`osddt.research.md\` was found, add a **Research Summary** section that briefly references the key insights and constraints it identified.
+
+## Arguments
+
+${args}
+
+## Next Step
+
+Run the following command to create the implementation plan:
+
+\`\`\`
+/osddt.plan ${args}
+\`\`\`
+`,
+    },
+    {
+        name: 'osddt.plan',
+        description: 'Create a technical implementation plan from a specification',
+        body: (args) => `## Instructions
+
+1. Read \`osddt.spec.md\` from the working directory
+2. Break down the implementation into logical phases and steps
+3. Identify technical decisions, dependencies, and risks
+4. Write the plan to \`osddt.plan.md\` in the working directory
+
+## Plan Format
+
+The plan should include:
+- **Architecture Overview**: High-level design decisions
+- **Implementation Phases**: Ordered phases with goals
+- **Technical Dependencies**: Libraries, APIs, services needed
+- **Risks & Mitigations**: Known risks and how to address them
+- **Out of Scope**: Explicitly what will not be built
+
+## Arguments
+
+${args}
+
+## Next Step
+
+Run the following command to generate the task list:
+
+\`\`\`
+/osddt.tasks ${args}
+\`\`\`
+`,
+    },
+    {
+        name: 'osddt.tasks',
+        description: 'Generate actionable tasks from an implementation plan',
+        body: (args) => `## Instructions
+
+1. Read \`osddt.plan.md\` from the working directory
+2. Break each phase into discrete, executable tasks
+3. Estimate complexity (S/M/L) for each task
+4. Write the task list to \`osddt.tasks.md\` in the working directory
+
+## Tasks Format
+
+The task list should include:
+- **Checklist** of tasks grouped by phase
+- Each task should be: \`- [ ] [S/M/L] Description of task\`
+- **Dependencies**: Note which tasks must complete before others
+- **Definition of Done**: Clear completion criteria per phase
+
+## Arguments
+
+${args}
+
+## Next Step
+
+Run the following command to start implementing tasks:
+
+\`\`\`
+/osddt.implement ${args}
+\`\`\`
+`,
+    },
+    {
+        name: 'osddt.implement',
+        description: 'Execute tasks from the task list one by one',
+        body: (args) => `## Instructions
+
+1. Read \`osddt.tasks.md\` from the working directory
+2. Find the next unchecked task (\`- [ ]\`)
+3. Implement that task following the spec (\`osddt.spec.md\`) and plan (\`osddt.plan.md\`) in the working directory
+4. Mark the task as complete (\`- [x]\`) in \`osddt.tasks.md\`
+5. Report what was done and any issues encountered
+
+## Guidelines
+
+- Implement one task at a time
+- Follow the existing code style and conventions
+- Write tests for new functionality when applicable
+- Ask for clarification if requirements are ambiguous
+
+## Arguments
+
+${args}
+
+## Next Step
+
+Once all tasks are checked off, run the following command to mark the feature as done:
+
+\`\`\`
+/osddt.done ${args}
+\`\`\`
+`,
+    },
+    {
+        name: 'osddt.done',
+        description: 'Mark a feature as done and move it from working-on to done',
+        body: (args) => `## Instructions
+
+1. Confirm all tasks in \`osddt.tasks.md\` are checked off (\`- [x]\`)
+2. Run the following command to move the feature folder from \`working-on\` to \`done\`:
+
+\`\`\`
+npx @dezkareid/osddt done ${args}
+\`\`\`
+
+   The command will automatically prefix the destination folder name with today's date in \`YYYY-MM-DD\` format.
+   For example, \`working-on/feature-a\` will be moved to \`done/YYYY-MM-DD-feature-a\`.
+
+3. Report the result of the command, including the full destination path
+
+## Arguments
+
+${args}
+`,
+    },
+];
+
+const CLAUDE_COMMANDS_DIR = '.claude/commands';
+function formatClaudeCommand(description, body) {
+    return `---
+description: "${description}"
+---
+
+${body}`;
+}
+function getClaudeTemplates(cwd) {
+    const dir = path.join(cwd, CLAUDE_COMMANDS_DIR);
+    return COMMAND_DEFINITIONS.map((cmd) => ({
+        filePath: path.join(dir, `${cmd.name}.md`),
+        content: formatClaudeCommand(cmd.description, cmd.body('$ARGUMENTS')),
+    }));
+}
+
+const GEMINI_COMMANDS_DIR = '.gemini/commands';
+function formatGeminiCommand(description, body) {
+    return `description = "${description}"
+
+prompt = """
+${body}"""
+`;
+}
+function getGeminiTemplates(cwd) {
+    const dir = path.join(cwd, GEMINI_COMMANDS_DIR);
+    return COMMAND_DEFINITIONS.map((cmd) => ({
+        filePath: path.join(dir, `${cmd.name}.toml`),
+        content: formatGeminiCommand(cmd.description, cmd.body('{{args}}')),
+    }));
+}
+
+async function askRepoType() {
+    return select({
+        message: 'What type of repository is this?',
+        choices: [
+            {
+                name: 'Single repo',
+                value: 'single',
+                description: 'A standalone project with one package',
+            },
+            {
+                name: 'Monorepo',
+                value: 'monorepo',
+                description: 'A repository containing multiple packages',
+            },
+        ],
+    });
+}
+async function askAgents() {
+    return checkbox({
+        message: 'Which AI assistant tools do you want to set up?',
+        choices: [
+            {
+                name: 'Claude Code',
+                value: 'claude',
+                checked: true,
+            },
+            {
+                name: 'Gemini CLI',
+                value: 'gemini',
+                checked: true,
+            },
+        ],
+        validate(choices) {
+            if (choices.length === 0) {
+                return 'You must select at least one agent.';
+            }
+            return true;
+        },
+    });
+}
+
+async function writeCommandFile(file) {
+    await fs.ensureDir(path.dirname(file.filePath));
+    await fs.writeFile(file.filePath, file.content, 'utf-8');
+    console.log(`  Created: ${file.filePath}`);
+}
+async function writeConfig(cwd, config) {
+    const configPath = path.join(cwd, '.osddtrc');
+    await fs.writeJson(configPath, config, { spaces: 2 });
+    console.log(`\nSaved config: ${configPath}`);
+}
+async function runSetup(cwd) {
+    const agents = await askAgents();
+    console.log('');
+    const repoType = await askRepoType();
+    console.log('');
+    console.log('Setting up OSDDT command files...\n');
+    if (agents.includes('claude')) {
+        const claudeFiles = getClaudeTemplates(cwd);
+        console.log('Claude Code commands (.claude/commands/):');
+        for (const file of claudeFiles) {
+            await writeCommandFile(file);
+        }
+        console.log('');
+    }
+    if (agents.includes('gemini')) {
+        const geminiFiles = getGeminiTemplates(cwd);
+        console.log('Gemini CLI commands (.gemini/commands/):');
+        for (const file of geminiFiles) {
+            await writeCommandFile(file);
+        }
+        console.log('');
+    }
+    await writeConfig(cwd, { repoType });
+    console.log('\nSetup complete!');
+    console.log('Commands created: osddt.spec, osddt.plan, osddt.tasks, osddt.implement');
+}
+function setupCommand() {
+    const cmd = new Command('setup');
+    cmd
+        .description('Create OSDDT command files for Claude and Gemini CLI agents')
+        .option('-d, --dir <directory>', 'target directory', process.cwd())
+        .action(async (options) => {
+        const targetDir = path.resolve(options.dir);
+        await runSetup(targetDir);
+    });
+    return cmd;
+}
+
+function getCurrentBranch() {
+    try {
+        return execSync('git rev-parse --abbrev-ref HEAD', { encoding: 'utf-8' }).trim();
+    }
+    catch {
+        return 'unknown';
+    }
+}
+function getCurrentDate() {
+    return new Date().toISOString().split('T')[0];
+}
+function metaInfoCommand() {
+    const cmd = new Command('meta-info');
+    cmd
+        .description('Output project meta information as JSON (branch, date)')
+        .action(() => {
+        const info = {
+            branch: getCurrentBranch(),
+            date: getCurrentDate(),
+        };
+        console.log(JSON.stringify(info));
+    });
+    return cmd;
+}
+
+function todayPrefix() {
+    const now = new Date();
+    const yyyy = now.getFullYear();
+    const mm = String(now.getMonth() + 1).padStart(2, '0');
+    const dd = String(now.getDate()).padStart(2, '0');
+    return `${yyyy}-${mm}-${dd}`;
+}
+async function runDone(featureName, cwd) {
+    const configPath = path.join(cwd, '.osddtrc');
+    if (!(await fs.pathExists(configPath))) {
+        console.error('Error: .osddtrc not found. Run `osddt setup` first.');
+        process.exit(1);
+    }
+    await fs.readJson(configPath);
+    const projectPath = cwd;
+    const src = path.join(projectPath, 'working-on', featureName);
+    const destName = `${todayPrefix()}-${featureName}`;
+    const dest = path.join(projectPath, 'done', destName);
+    if (!(await fs.pathExists(src))) {
+        console.error(`Error: working-on/${featureName} does not exist.`);
+        process.exit(1);
+    }
+    await fs.ensureDir(path.dirname(dest));
+    await fs.move(src, dest);
+    console.log(`Moved: working-on/${featureName} → done/${destName}`);
+}
+function doneCommand() {
+    const cmd = new Command('done');
+    cmd
+        .description('Move a feature from working-on/<feature-name> to done/<feature-name>')
+        .argument('<feature-name>', 'name of the feature to mark as done')
+        .option('-d, --dir <directory>', 'project directory', process.cwd())
+        .action(async (featureName, options) => {
+        const targetDir = path.resolve(options.dir);
+        await runDone(featureName, targetDir);
+    });
+    return cmd;
+}
+
+const program = new Command();
+program
+    .name('osddt')
+    .description('Spec-Driven Development tooling for monorepos and single-package repos')
+    .version('0.0.0');
+program.addCommand(setupCommand());
+program.addCommand(metaInfoCommand());
+program.addCommand(doneCommand());
+program.parse(process.argv);

package/dist/templates/claude.d.ts

@@ -0,0 +1,6 @@
+interface CommandFile {
+    filePath: string;
+    content: string;
+}
+export declare function getClaudeTemplates(cwd: string): CommandFile[];
+export {};

package/dist/templates/claude.spec.d.ts

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

package/dist/templates/gemini.d.ts

@@ -0,0 +1,6 @@
+interface CommandFile {
+    filePath: string;
+    content: string;
+}
+export declare function getGeminiTemplates(cwd: string): CommandFile[];
+export {};

package/dist/templates/gemini.spec.d.ts

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

package/dist/templates/shared.d.ts

@@ -0,0 +1,10 @@
+export declare const REPO_PREAMBLE = "## Context\n\nBefore proceeding, run the following command and parse the JSON output to get the current branch and date:\n\n```\nnpx @dezkareid/osddt meta-info\n```\n\n## Repository Configuration\n\nBefore proceeding, read the `.osddtrc` file in the root of the repository to determine the project path.\n\n```json\n// .osddtrc example\n{ \"repoType\": \"monorepo\" | \"single\" }\n```\n\n- If `repoType` is `\"single\"`: the project path is the repository root.\n- If `repoType` is `\"monorepo\"`: ask the user which package to work on (e.g. `packages/my-package`), then use `<repo-root>/<package>` as the project path.\n\n## Working Directory\n\nAll generated files live under `<project-path>/working-on/<feature-name>/`. The `<feature-name>` is derived from the arguments provided. Create the directory if it does not exist.\n\n> All file paths in the instructions below are relative to `<project-path>/working-on/<feature-name>/`.\n\n";
+export declare const FEATURE_NAME_RULES = "### Feature Name Constraints\n\nWhen deriving a feature name from a description:\n\n- Use only lowercase letters, digits, and hyphens (`a-z`, `0-9`, `-`)\n- Replace spaces and special characters with hyphens\n- Remove consecutive hyphens (e.g. `--` \u2192 `-`)\n- Remove leading and trailing hyphens\n- **Maximum length: 30 characters** \u2014 if the derived name exceeds 30 characters, truncate at the last hyphen boundary before or at the 30th character\n- If the input is already a valid branch name (no spaces, kebab-case or slash-separated), apply the 30-character limit to the last segment only (after the last `/`)\n- Reject (and ask the user to provide a shorter name) if no valid name can be derived after truncation\n\n**Examples:**\n\n| Input | Derived feature name |\n| ----------------------------------------------------- | ---------------------------- |\n| `Add user authentication` | `add-user-authentication` |\n| `Implement real-time notifications for dashboard` | `implement-real-time` |\n| `feat/add-user-authentication` | `add-user-authentication` |\n| `feat/implement-real-time-notifications-for-dashboard` | `implement-real-time` |\n";
+export declare const WORKING_DIR_STEP = "Check whether the working directory `<project-path>/working-on/<feature-name>` already exists:\n   - If it **does not exist**, create it:\n     ```\n     mkdir -p <project-path>/working-on/<feature-name>\n     ```\n   - If it **already exists**, warn the user and ask whether to:\n     - **Resume** \u2014 continue into the existing folder (proceed to the next step without recreating it)\n     - **Abort** \u2014 stop and do nothing";
+export type ArgPlaceholder = '$ARGUMENTS' | '{{args}}';
+export interface CommandDefinition {
+    name: string;
+    description: string;
+    body: (args: ArgPlaceholder) => string;
+}
+export declare const COMMAND_DEFINITIONS: CommandDefinition[];

package/dist/templates/shared.spec.d.ts

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

package/dist/utils/prompt.d.ts

@@ -0,0 +1,4 @@
+export type RepoType = 'monorepo' | 'single';
+export type AgentType = 'claude' | 'gemini';
+export declare function askRepoType(): Promise<RepoType>;
+export declare function askAgents(): Promise<AgentType[]>;

package/package.json

@@ -1,10 +1,57 @@
 {
   "name": "@dezkareid/osddt",
-  "version": "0.0.0",
+  "version": "1.1.0",
   "description": "Package for Spec-Driven Development workflow",
   "keywords": [
-    "setup",
-    "package",
-    "npm"
-  ]
-}
+    "spec-driven",
+    "cli"
+  ],
+  "files": [
+    "dist",
+    "README.md"
+  ],
+  "publishConfig": {
+    "access": "public",
+    "provenance": true
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/dezkareid/osddt.git"
+  },
+  "author": "Joel Humberto Gomez Paredes <elmaildeldezkareid@gmail.com>",
+  "license": "ISC",
+  "bugs": {
+    "url": "https://github.com/dezkareid/osddt/issues"
+  },
+  "homepage": "https://github.com/dezkareid/osddt#readme",
+  "type": "module",
+  "bin": {
+    "osddt": "./dist/index.js"
+  },
+  "main": "./dist/index.js",
+  "dependencies": {
+    "@inquirer/checkbox": "5.0.7",
+    "@inquirer/select": "5.0.7",
+    "commander": "12.0.0",
+    "fs-extra": "11.2.0",
+    "tslib": "2.8.1"
+  },
+  "devDependencies": {
+    "@rollup/plugin-typescript": "12.1.4",
+    "@types/fs-extra": "11.0.4",
+    "@types/node": "25.0.10",
+    "eslint": "9.39.2",
+    "prettier": "3.8.1",
+    "rollup": "4.56.0",
+    "typescript": "5.9.3",
+    "vitest": "4.0.18"
+  },
+  "scripts": {
+    "build": "rollup -c",
+    "dev": "rollup -c --watch",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "lint": "eslint src",
+    "format": "prettier --write src"
+  }
+}

package/AGENTS.md

@@ -1,32 +0,0 @@
-# Agent Instructions: dezkareid monorepo
-
-This file provides critical context and dependency information for AI agents working in this project.
-
-## Critical Dependency Versions
-
-The following versions are established across the project's packages and should be respected when adding new dependencies or troubleshooting.
-
-### Core Languages & Runtimes
-- **TypeScript**: `5.9.3`
-
-### Build & Bundling Tools
-- **Rollup**: `4.56.0`
-
-### Testing Frameworks
-- **Vitest**: `4.0.18`
-
-### Linting & Formatting
-- **ESLint**: `9.39.2`
-- **Prettier**: `3.8.1`
-
-### Type Definitions
-- **@types/node**: `25.0.10`
-- **@types/fs-extra**: `11.0.4`
-
-### Key Libraries
-- **Commander**: `12.0.0` (for CLI tools)
-- **fs-extra**: `11.2.0`
-- **globby**: `14.0.1`
-
-## Project Structure & Conventions
-- **Package Manager**: `npm` is the required package manager.