@we-scrum/cli 1.0.4 → 1.0.6

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@we-scrum/cli",
-  "version": "1.0.4",
+  "version": "1.0.6",
   "description": "Cli tool for we-scrum application",
   "main": "dist/cli.js",
   "bin": {
@@ -20,22 +20,23 @@
     "noExternal": [
       "@we-scrum/*",
       "@my-devkit/*"
-    ]
+    ],
+    "loader": {
+      ".hbs": "text"
+    }
   },
   "dependencies": {
-    "@inquirer/prompts": "8.3.0",
-    "zod": "4.3.6",
-    "@modelcontextprotocol/sdk": "1.27.1",
-    "commander": "14.0.3",
-    "firebase": "12.10.0",
-    "google-auth-library": "^10.6.1",
+    "@inquirer/prompts": "^8.4.2",
+    "commander": "^14.0.3",
+    "firebase": "^12.12.1",
+    "google-auth-library": "^10.6.2",
+    "handlebars": "^4.7.9",
     "open": "^11.0.0"
   },
   "devDependencies": {
-    "@types/node": "22.18.6",
-    "@modelcontextprotocol/inspector": "0.21.1",
-    "tsup": "8.5.1",
-    "typescript": "5.9.3",
+    "@types/node": "^22.19.17",
+    "tsup": "^8.5.1",
+    "typescript": "^5.9.3",
     "@my-devkit/cli": "2.1.0",
     "@my-devkit/core": "1.0.0",
     "@we-scrum/commands": "1.0.0",
@@ -45,7 +46,6 @@
   },
   "scripts": {
     "start": "node dist/cli.js",
-    "inspect": "mcp-inspector node dist/cli.js mcp",
     "build": "tsup",
     "watch": "tsup --watch",
     "deploy": "pnpm build && pnpm publish --access public"

package/src/cli.ts

@@ -1,12 +1,11 @@
 #!/usr/bin/env node
 import { select } from '@inquirer/prompts';
-import { Logger } from '@my-devkit/core';
+import { assert, Logger } from '@my-devkit/core';
 import { UserProjectModel } from '@we-scrum/models';
 import { Command } from 'commander';
 import { version } from '../package.json';
 
-import { AuthHelper, FirebaseHelper, SettingsHelper } from './helpers';
-import { startMcpServer } from './mcp-server';
+import { AuthHelper, FirebaseHelper, ProjectHelper, WeScrumHelper } from './helpers';
 
 Logger.registerLogger(new Logger.ConsoleImplementation());
 
@@ -14,59 +13,77 @@ const program = new Command();
 
 program.name('we-scrum').description('CLI for we-scrum application').version(version);
 
-program
-    .command('login')
-    .description('Authenticate with your Google account')
-    .action(async () => {
+async function requireAuth(): Promise<void> {
+    const initialized = await AuthHelper.initializeFromStoredCredentials();
+    assert(initialized, 'Not authenticated. Please run "we-scrum login" first.');
+}
+
+async function requireProject(): Promise<void> {
+    const root = ProjectHelper.requireRoot();
+    await ProjectHelper.init(root);
+}
+
+function runCommand<T = void>(fn: (options: T) => Promise<string | void>) {
+    return async (options: T) => {
         try {
-            await AuthHelper.loginWithGoogle();
+            const output = await fn(options);
+            if (output) process.stdout.write(output + '\n');
             process.exit(0);
         } catch (error) {
-            Logger.error(error?.message ?? 'Login failed');
+            if (error?.name === 'ExitPromptError') process.exit(0);
+            Logger.error(error?.message ?? 'Command failed');
             process.exit(1);
         }
+    };
+}
+
+function runProjectCommand<T = void>(fn: (options: T) => Promise<string | void>) {
+    return runCommand<T>(async (options) => {
+        await requireProject();
+        await requireAuth();
+        return fn(options);
     });
+}
+
+program
+    .command('login')
+    .description('Authenticate with your Google account')
+    .action(
+        runCommand(async () => {
+            await AuthHelper.loginWithGoogle();
+        }),
+    );
 
 program
     .command('logout')
     .description('Log out and remove stored credentials')
-    .action(() => {
-        AuthHelper.logout();
-        Logger.info('Logged out successfully.');
-        process.exit(0);
-    });
+    .action(
+        runCommand(async () => {
+            AuthHelper.logout();
+            Logger.info('Logged out successfully.');
+        }),
+    );
 
 program
     .command('use-project')
-    .description('Select the active project')
+    .description('Select the active project and initialize we-scrum.json')
     .option('--projectId <id>', 'Set the active project directly without the interactive prompt')
-    .action(async (options: { projectId?: string }) => {
-        try {
-            const initialized = await AuthHelper.initializeFromStoredCredentials();
-            if (!initialized) {
-                Logger.error('Not authenticated. Please run "we-scrum login" first.');
-                process.exit(1);
-            }
+    .action(
+        runCommand<{ projectId?: string }>(async (options) => {
+            await requireAuth();
 
             const projects = await FirebaseHelper.getCollection<UserProjectModel>(`users/${AuthHelper.userId}/projects`);
-            if (projects.length === 0) {
-                Logger.error('No projects found for your account.');
-                process.exit(1);
-            }
+            assert(projects.length > 0, 'No projects found for your account. Please create a project in the we-scrum web app first.');
 
             let selectedProjectId: string;
 
             if (options.projectId) {
                 const match = projects.find((p) => p.projectId === options.projectId);
-                if (!match) {
-                    Logger.error(`Project "${options.projectId}" not found in your account.`);
-                    process.exit(1);
-                }
+                assert(!!match, `Project "${options.projectId}" not found in your account.`);
                 selectedProjectId = match.projectId;
             } else {
                 selectedProjectId = await select({
                     message: 'Select a project',
-                    default: SettingsHelper.get().selectedProjectId,
                     choices: projects.map((p) => ({
                         name: p.name,
                         value: p.projectId,
@@ -75,27 +92,75 @@ program
                 });
             }
 
-            SettingsHelper.set({ selectedProjectId });
-            Logger.info(`Active project set to: ${projects.find((p) => p.projectId === selectedProjectId)?.name}`);
-            process.exit(0);
-        } catch (error) {
-            if (error?.name === 'ExitPromptError') {
-                process.exit(0);
-            }
-            Logger.error(error?.message ?? 'Failed to select project');
-            process.exit(1);
-        }
-    });
+            const projectRoot = await ProjectHelper.confirmAndCreate(selectedProjectId);
+            await ProjectHelper.init(projectRoot);
+
+            Logger.info(`Project configured: ${projects.find((p) => p.projectId === selectedProjectId)?.name}`);
+        }),
+    );
 
 program
-    .command('mcp')
-    .description('Start the we-scrum MCP server (stdio transport)')
-    .option('--projectId <id>', 'Override the active project for this session')
-    .action(async (options: { projectId?: string }) => {
-        if (options.projectId) {
-            SettingsHelper.set({ selectedProjectId: options.projectId });
-        }
-        await startMcpServer();
-    });
+    .command('start-task')
+    .description('Mark a specific task as in progress')
+    .requiredOption('--identificationNumber <id>', 'Story identification number')
+    .requiredOption('--taskId <id>', 'Unique identifier of the change to act on')
+    .action(
+        runProjectCommand<{ identificationNumber: string; taskId: string }>(async (options) => {
+            await WeScrumHelper.startTask(options.identificationNumber, options.taskId);
+            Logger.info('Task started successfully. You can now make changes to the codebase.');
+        }),
+    );
+
+program
+    .command('complete-task')
+    .description('Mark the current in-progress task as done')
+    .requiredOption('--identificationNumber <id>', 'Story identification number')
+    .requiredOption('--taskId <id>', 'Unique identifier of the change to act on')
+    .action(
+        runProjectCommand<{ identificationNumber: string; taskId: string }>(async (options) => {
+            await WeScrumHelper.completeTask(options.identificationNumber, options.taskId);
+            Logger.info('Task completed successfully.');
+        }),
+    );
+
+program
+    .command('get-story-description')
+    .description('Get the description of a story')
+    .requiredOption('--identificationNumber <id>', 'Story identification number')
+    .action(
+        runProjectCommand<{ identificationNumber: string }>(async (options) => {
+            return WeScrumHelper.getStoryDescription(options.identificationNumber);
+        }),
+    );
+
+program
+    .command('get-story-analysis')
+    .description('Get the analysis DSL for a story')
+    .requiredOption('--identificationNumber <id>', 'Story identification number')
+    .action(
+        runProjectCommand<{ identificationNumber: string }>(async (options) => {
+            return WeScrumHelper.getStoryAnalysis(options.identificationNumber);
+        }),
+    );
+
+program
+    .command('get-next-task')
+    .description('Get the next pending task for a story')
+    .requiredOption('--identificationNumber <id>', 'Story identification number')
+    .action(
+        runProjectCommand<{ identificationNumber: string }>(async (options) => {
+            return WeScrumHelper.getNextTask(options.identificationNumber);
+        }),
+    );
+
+program
+    .command('synchronize-development-policies')
+    .description('Sync development guidelines from we-scrum into the project')
+    .action(
+        runProjectCommand(async () => {
+            const count = await WeScrumHelper.synchronizeDevelopmentPolicies();
+            Logger.info(`Synchronized ${count} development ${count === 1 ? 'policy' : 'policies'}.`);
+        }),
+    );
 
 program.parse(process.argv);

package/src/hbs.d.ts

@@ -0,0 +1,4 @@
+declare module '*.hbs' {
+    const content: string;
+    export default content;
+}

package/src/helpers/auth-helper.ts

@@ -70,7 +70,7 @@ export class AuthHelper {
 
                         // Exchange the Authorization Code for tokens using the PKCE Verifier
                         const { tokens } = await oAuth2Client.getToken({
-                            code: code,
+                            code,
                             codeVerifier: verifier,
                         });
 

package/src/helpers/index.ts

@@ -1,4 +1,6 @@
 export * from './auth-helper';
 export * from './firebase-helper';
+export * from './project-helper';
 export * from './settings-helper';
+export * from './template.helper';
 export * from './we-scrum.helper';

package/src/helpers/project-helper.ts

@@ -0,0 +1,96 @@
+import { assert, Logger } from '@my-devkit/core';
+import { confirm, input } from '@inquirer/prompts';
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs';
+import { dirname, join, resolve } from 'node:path';
+import { version as cliVersion } from '../../package.json';
+import { renderTemplate } from './template.helper';
+
+const CONFIG_FILE = 'we-scrum.json';
+
+export interface WeScrumProjectConfig {
+    projectId: string;
+    version: string;
+    developmentPoliciesPath: string;
+}
+
+export class ProjectHelper {
+    public static findRoot(from = process.cwd()): string | null {
+        let dir = resolve(from);
+        while (true) {
+            if (existsSync(join(dir, CONFIG_FILE))) return dir;
+            const parent = dirname(dir);
+            if (parent === dir) return null;
+            dir = parent;
+        }
+    }
+
+    public static requireRoot(): string {
+        const root = this.findRoot();
+        assert(!!root, `we-scrum.json not found. Please run "we-scrum use-project" first.`);
+        return root;
+    }
+
+    public static read(root: string): WeScrumProjectConfig {
+        const content = readFileSync(join(root, CONFIG_FILE), 'utf8');
+        return JSON.parse(content) as WeScrumProjectConfig;
+    }
+
+    public static write(root: string, partial: Partial<WeScrumProjectConfig>): void {
+        const existing = existsSync(join(root, CONFIG_FILE)) ? this.read(root) : ({} as WeScrumProjectConfig);
+        writeFileSync(join(root, CONFIG_FILE), JSON.stringify({ ...existing, ...partial }, null, 2) + '\n');
+    }
+
+    public static async init(root: string): Promise<void> {
+        const config = this.read(root);
+        assert(!!config.projectId, 'No project selected. Please run "we-scrum use-project" first.');
+        if (config.version === cliVersion) return;
+
+        this.installSkills(root);
+        this.write(root, { version: cliVersion });
+        Logger.info(`we-scrum initialized (v${cliVersion}).`);
+    }
+
+    public static async confirmAndCreate(projectId: string): Promise<string> {
+        const defaultRoot = process.cwd();
+
+        const useDefault = await confirm({
+            message: `Use "${defaultRoot}" as the project root?`,
+            default: true,
+        });
+
+        let root: string;
+        if (useDefault) {
+            root = defaultRoot;
+        } else {
+            root = await input({ message: 'Enter the project root directory:' });
+            root = resolve(root);
+        }
+
+        assert(existsSync(root), `Directory "${root}" does not exist.`);
+
+        const defaultPoliciesPath = '.claude/development-policies';
+        const confirmPolicies = await confirm({
+            message: `Store development policies in "${defaultPoliciesPath}"?`,
+            default: true,
+        });
+
+        const developmentPoliciesPath = confirmPolicies
+            ? defaultPoliciesPath
+            : await input({ message: 'Enter the development policies path (relative to project root):' });
+
+        this.write(root, { projectId, version: '0.0.0', developmentPoliciesPath });
+        return root;
+    }
+
+    private static installSkills(root: string): void {
+        if (!existsSync(join(root, '.claude'))) return;
+        for (const [name, template] of [
+            ['develop-story', 'develop-story-skill'],
+            ['review-analysis', 'review-analysis-skill'],
+        ] as const) {
+            const skillDir = join(root, '.claude', 'skills', name);
+            mkdirSync(skillDir, { recursive: true });
+            writeFileSync(join(skillDir, 'SKILL.md'), renderTemplate(template));
+        }
+    }
+}

package/src/helpers/settings-helper.ts

@@ -8,7 +8,6 @@ const SETTINGS_FILE = pathJoin(homedir(), '.we-scrum.json');
 
 export interface WeScrumSettings {
     credentials?: Credentials;
-    selectedProjectId?: string;
 }
 
 export class SettingsHelper {

package/src/helpers/template.helper.ts

@@ -0,0 +1,25 @@
+import Handlebars from 'handlebars';
+import developStorySkill from '../../templates/develop-story-skill.hbs';
+import getNextTask from '../../templates/get-next-task.hbs';
+import reviewAnalysisSkill from '../../templates/review-analysis-skill.hbs';
+
+const sources = {
+    'develop-story-skill': developStorySkill,
+    'get-next-task': getNextTask,
+    'review-analysis-skill': reviewAnalysisSkill,
+} as const;
+
+export type TemplateName = keyof typeof sources;
+
+const compiled = new Map<TemplateName, Handlebars.TemplateDelegate>();
+
+function getTemplate(name: TemplateName): Handlebars.TemplateDelegate {
+    if (!compiled.has(name)) {
+        compiled.set(name, Handlebars.compile(sources[name]));
+    }
+    return compiled.get(name)!;
+}
+
+export function renderTemplate(name: TemplateName, context?: Record<string, unknown>): string {
+    return getTemplate(name)(context ?? {}).trim();
+}