crewx 0.8.7-rc.2 → 0.8.7-rc.21

package/dist-server/domain/goal/goal.service.js

@@ -0,0 +1,197 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GoalService = void 0;
+const common_1 = require("@nestjs/common");
+const fs_1 = require("fs");
+const path_1 = require("path");
+const goal_md_parser_js_1 = require("./parser/goal-md-parser.js");
+const goal_md_serializer_js_1 = require("./parser/goal-md-serializer.js");
+let GoalService = class GoalService {
+    goalDir(workspacePath) {
+        return (0, path_1.join)(workspacePath, 'docs', 'goal');
+    }
+    filePath(workspacePath, goalId) {
+        return (0, path_1.join)(this.goalDir(workspacePath), `${goalId}.md`);
+    }
+    listGoals(workspacePath, status) {
+        const dir = this.goalDir(workspacePath);
+        if (!(0, fs_1.existsSync)(dir)) {
+            return { goals: [] };
+        }
+        const files = (0, fs_1.readdirSync)(dir).filter((f) => f.endsWith('.md') && !f.toUpperCase().includes('-TEMPLATE'));
+        const goals = [];
+        for (const file of files) {
+            const goalId = (0, path_1.basename)(file, '.md');
+            const fp = (0, path_1.join)(dir, file);
+            const raw = (0, fs_1.readFileSync)(fp, 'utf-8');
+            const parsed = (0, goal_md_parser_js_1.parseGoalMd)(goalId, raw);
+            if (status && parsed.period.status !== status)
+                continue;
+            const progress = this.computeOverallProgress(parsed.keyResults);
+            const stat = (0, fs_1.statSync)(fp);
+            goals.push({
+                goalId,
+                title: parsed.title,
+                status: parsed.period.status,
+                period: parsed.period,
+                progress,
+                krSummary: parsed.keyResults.slice(0, 4).map((kr) => ({
+                    rank: kr.rank,
+                    text: kr.text,
+                    progress: this.getKRProgress(kr),
+                    checked: kr.checked,
+                })),
+                krCount: parsed.keyResults.length,
+                updatedAt: stat.mtime.toISOString(),
+            });
+        }
+        goals.sort((a, b) => {
+            const statusOrder = { active: 0, done: 1, dropped: 2 };
+            const oa = statusOrder[a.status] ?? 3;
+            const ob = statusOrder[b.status] ?? 3;
+            if (oa !== ob)
+                return oa - ob;
+            if (a.status === 'active')
+                return b.period.start.localeCompare(a.period.start);
+            if (a.status === 'done')
+                return (b.period.completedAt ?? '').localeCompare(a.period.completedAt ?? '');
+            return (b.period.droppedAt ?? '').localeCompare(a.period.droppedAt ?? '');
+        });
+        return { goals };
+    }
+    getGoal(workspacePath, goalId) {
+        const fp = this.filePath(workspacePath, goalId);
+        if (!(0, fs_1.existsSync)(fp)) {
+            throw new common_1.NotFoundException(`Goal not found: ${goalId}`);
+        }
+        const raw = (0, fs_1.readFileSync)(fp, 'utf-8');
+        const parsed = (0, goal_md_parser_js_1.parseGoalMd)(goalId, raw);
+        const stat = (0, fs_1.statSync)(fp);
+        return this.toGoalDetail(goalId, parsed, stat.mtime.toISOString());
+    }
+    putGoal(workspacePath, goalId, dto, createOnly = false) {
+        if (dto.period?.status === 'dropped' && !dto.period?.reason) {
+            throw new common_1.BadRequestException('Reason is required when status is dropped');
+        }
+        const dir = this.goalDir(workspacePath);
+        if (!(0, fs_1.existsSync)(dir)) {
+            (0, fs_1.mkdirSync)(dir, { recursive: true });
+        }
+        if (createOnly && (0, fs_1.existsSync)(this.filePath(workspacePath, goalId))) {
+            throw new common_1.ConflictException(`Goal already exists: ${goalId}`);
+        }
+        const keyResults = this.recalculateAutoProgress(dto.keyResults ?? []);
+        const parsed = {
+            frontmatter: {
+                type: 'goal',
+                description: 'CrewX Goal — OKR',
+                notation: {
+                    weight: '(w:N) — KR weight, default 1 if omitted',
+                    auto: 'N% auto — L1 progress auto-calculated as weighted average of children',
+                },
+            },
+            title: dto.title,
+            period: dto.period ?? { start: '', end: '', status: 'active' },
+            objective: dto.objective ?? { body: '' },
+            keyResults,
+            notes: dto.notes ?? '',
+            reflection: dto.reflection ?? '',
+        };
+        const md = (0, goal_md_serializer_js_1.serializeGoalMd)(parsed);
+        const fp = this.filePath(workspacePath, goalId);
+        (0, fs_1.writeFileSync)(fp, md, 'utf-8');
+        const stat = (0, fs_1.statSync)(fp);
+        return this.toGoalDetail(goalId, parsed, stat.mtime.toISOString());
+    }
+    deleteGoal(workspacePath, goalId) {
+        const fp = this.filePath(workspacePath, goalId);
+        if (!(0, fs_1.existsSync)(fp)) {
+            throw new common_1.NotFoundException(`Goal not found: ${goalId}`);
+        }
+        (0, fs_1.unlinkSync)(fp);
+        return { goalId, deleted: true };
+    }
+    recalculateAutoProgress(keyResults) {
+        return keyResults.map((kr) => {
+            if (kr.children && kr.children.length > 0) {
+                let totalWeight = 0;
+                let weightedSum = 0;
+                for (const c of kr.children) {
+                    const w = c.weight ?? 1;
+                    const p = c.counter
+                        ? Math.round((c.counter.current / c.counter.target) * 100)
+                        : (c.progress ?? 0);
+                    weightedSum += p * w;
+                    totalWeight += w;
+                }
+                const auto = totalWeight > 0 ? Math.round(weightedSum / totalWeight) : 0;
+                return { ...kr, progressAuto: auto, progress: undefined };
+            }
+            if (kr.counter) {
+                const pct = Math.round((kr.counter.current / kr.counter.target) * 100);
+                return { ...kr, progress: pct };
+            }
+            return kr;
+        });
+    }
+    computeOverallProgress(keyResults) {
+        if (keyResults.length === 0)
+            return 0;
+        let totalWeight = 0;
+        let weightedSum = 0;
+        for (const kr of keyResults) {
+            const w = kr.weight ?? 1;
+            const p = this.getKRProgress(kr);
+            weightedSum += p * w;
+            totalWeight += w;
+        }
+        return totalWeight > 0 ? Math.round(weightedSum / totalWeight) : 0;
+    }
+    getKRProgress(kr) {
+        if (kr.children && kr.children.length > 0) {
+            let totalWeight = 0;
+            let weightedSum = 0;
+            for (const c of kr.children) {
+                const w = c.weight ?? 1;
+                const p = c.counter
+                    ? Math.round((c.counter.current / c.counter.target) * 100)
+                    : (c.progress ?? 0);
+                weightedSum += p * w;
+                totalWeight += w;
+            }
+            return totalWeight > 0 ? Math.round(weightedSum / totalWeight) : 0;
+        }
+        if (kr.progressAuto !== undefined)
+            return kr.progressAuto;
+        if (kr.counter)
+            return Math.round((kr.counter.current / kr.counter.target) * 100);
+        return kr.progress ?? 0;
+    }
+    toGoalDetail(goalId, parsed, updatedAt) {
+        return {
+            goalId,
+            title: parsed.title,
+            description: parsed.frontmatter.description ?? 'CrewX Goal — OKR',
+            notation: parsed.frontmatter.notation ?? {
+                weight: '(w:N) — KR weight, default 1 if omitted',
+                auto: 'N% auto — L1 progress auto-calculated as weighted average of children',
+            },
+            period: parsed.period,
+            objective: parsed.objective,
+            keyResults: this.recalculateAutoProgress(parsed.keyResults),
+            notes: parsed.notes,
+            reflection: parsed.reflection,
+            updatedAt,
+        };
+    }
+};
+exports.GoalService = GoalService;
+exports.GoalService = GoalService = __decorate([
+    (0, common_1.Injectable)()
+], GoalService);

package/dist-server/domain/goal/parser/goal-md-parser.js

@@ -0,0 +1,166 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseGoalMd = parseGoalMd;
+const gray_matter_1 = __importDefault(require("gray-matter"));
+const WEIGHT_RE = /\(w:(\d+)\)/;
+const AUTO_RE = /—\s+(\d+)%\s+auto/;
+const COUNTER_RE = /—\s+(\d+)\/(\d+)\s+\((\d+)%\)/;
+const SIMPLE_PCT_RE = /—\s+(\d+)%/;
+const L1_RE = /^(\d+)\.\s+\[(x| )\]\s+(.+)$/;
+const L2_RE = /^ {3}-\s+\[(x| )\]\s+(.+)$/;
+function extractWeight(text) {
+    const m = text.match(WEIGHT_RE);
+    if (!m)
+        return { text: text.trim(), weight: 1 };
+    return {
+        text: text.replace(WEIGHT_RE, '').trim(),
+        weight: parseInt(m[1], 10),
+    };
+}
+function parseProgress(text) {
+    let autoMatch = text.match(AUTO_RE);
+    if (autoMatch) {
+        const cleanText = text.replace(AUTO_RE, '').trim();
+        return { cleanText, progressAuto: parseInt(autoMatch[1], 10) };
+    }
+    let counterMatch = text.match(COUNTER_RE);
+    if (counterMatch) {
+        const cleanText = text.replace(COUNTER_RE, '').trim();
+        return {
+            cleanText,
+            counter: {
+                current: parseInt(counterMatch[1], 10),
+                target: parseInt(counterMatch[2], 10),
+            },
+            progress: parseInt(counterMatch[3], 10),
+        };
+    }
+    let pctMatch = text.match(SIMPLE_PCT_RE);
+    if (pctMatch) {
+        const cleanText = text.replace(SIMPLE_PCT_RE, '').trim();
+        return { cleanText, progress: parseInt(pctMatch[1], 10) };
+    }
+    return { cleanText: text.trim(), progress: 0 };
+}
+function parseL2(line) {
+    const m = line.match(L2_RE);
+    if (!m)
+        return null;
+    const checked = m[1] === 'x';
+    let rawText = m[2];
+    const { text: afterWeight, weight } = extractWeight(rawText);
+    const { cleanText, progress, counter } = parseProgress(afterWeight);
+    const child = { text: cleanText, checked, weight };
+    if (progress !== undefined)
+        child.progress = progress;
+    if (counter)
+        child.counter = counter;
+    return child;
+}
+function parseL1(line) {
+    const m = line.match(L1_RE);
+    if (!m)
+        return null;
+    const rank = parseInt(m[1], 10);
+    const checked = m[2] === 'x';
+    let rawText = m[3];
+    const { text: afterWeight, weight } = extractWeight(rawText);
+    const { cleanText, progress, progressAuto, counter } = parseProgress(afterWeight);
+    const item = { rank, text: cleanText, checked, weight };
+    if (progressAuto !== undefined)
+        item.progressAuto = progressAuto;
+    if (progress !== undefined)
+        item.progress = progress;
+    if (counter)
+        item.counter = counter;
+    return item;
+}
+function parsePeriod(body) {
+    const period = { start: '', end: '', status: 'active' };
+    const lines = body.split('\n');
+    for (const line of lines) {
+        const m = line.match(/^-\s+(\w[\w\s]*):\s*(.+)$/);
+        if (!m)
+            continue;
+        const key = m[1].trim().toLowerCase();
+        const val = m[2].trim();
+        if (key === 'start')
+            period.start = val;
+        else if (key === 'end')
+            period.end = val;
+        else if (key === 'status')
+            period.status = val;
+        else if (key === 'completed at')
+            period.completedAt = val;
+        else if (key === 'dropped at')
+            period.droppedAt = val;
+        else if (key === 'reason')
+            period.reason = val;
+    }
+    return period;
+}
+function parseKeyResults(body) {
+    const lines = body.split('\n');
+    const items = [];
+    let currentL1 = null;
+    for (const line of lines) {
+        const l1 = parseL1(line);
+        if (l1) {
+            if (currentL1)
+                items.push(currentL1);
+            currentL1 = l1;
+            continue;
+        }
+        const l2 = parseL2(line);
+        if (l2 && currentL1) {
+            if (!currentL1.children)
+                currentL1.children = [];
+            currentL1.children.push(l2);
+        }
+    }
+    if (currentL1)
+        items.push(currentL1);
+    return items;
+}
+function splitSections(content) {
+    const sections = new Map();
+    const parts = content.split(/^(?=##\s)/m);
+    for (const part of parts) {
+        const m = part.match(/^##\s+(.+)$/m);
+        if (!m)
+            continue;
+        const heading = m[1].trim();
+        const body = part.slice(m[0].length).trimStart();
+        sections.set(heading, body);
+    }
+    return sections;
+}
+function parseGoalMd(_goalId, raw) {
+    const { data: fm, content: body } = (0, gray_matter_1.default)(raw);
+    const frontmatter = {
+        type: fm.type,
+        description: fm.description,
+        notation: fm.notation,
+    };
+    // Extract H1 title
+    const h1Match = body.match(/^#\s+(.+)$/m);
+    const title = h1Match ? h1Match[1].trim() : '';
+    const sections = splitSections(body);
+    const period = parsePeriod(sections.get('Period') ?? '');
+    const objectiveBody = (sections.get('Objective') ?? '').trim();
+    const keyResults = parseKeyResults(sections.get('Key Results') ?? '');
+    const notes = (sections.get('Notes') ?? '').trim();
+    const reflection = (sections.get('Reflection') ?? '').trim();
+    return {
+        frontmatter,
+        title,
+        period,
+        objective: { body: objectiveBody },
+        keyResults,
+        notes,
+        reflection,
+    };
+}

package/dist-server/domain/goal/parser/goal-md-serializer.js

@@ -0,0 +1,110 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.serializeGoalMd = serializeGoalMd;
+const DEFAULT_FRONTMATTER = `---
+type: goal
+description: CrewX Goal — OKR
+notation:
+  weight: "(w:N) — KR weight, default 1 if omitted"
+  auto: "N% auto — L1 progress auto-calculated as weighted average of children"
+---`;
+function computeWeightedAverage(children) {
+    let totalWeight = 0;
+    let weightedSum = 0;
+    for (const c of children) {
+        const w = c.weight ?? 1;
+        const p = c.counter
+            ? Math.round((c.counter.current / c.counter.target) * 100)
+            : (c.progress ?? 0);
+        weightedSum += p * w;
+        totalWeight += w;
+    }
+    return totalWeight > 0 ? Math.round(weightedSum / totalWeight) : 0;
+}
+function serializeKRProgress(kr, isL1WithChildren, autoProgress) {
+    if (isL1WithChildren && autoProgress !== undefined) {
+        return ` — ${autoProgress}% auto`;
+    }
+    if (kr.counter) {
+        const pct = Math.round((kr.counter.current / kr.counter.target) * 100);
+        return ` — ${kr.counter.current}/${kr.counter.target} (${pct}%)`;
+    }
+    if (kr.progress !== undefined && kr.progress !== 0) {
+        return ` — ${kr.progress}%`;
+    }
+    if (kr.progress === 0) {
+        return '';
+    }
+    return '';
+}
+function serializeWeight(weight) {
+    return weight !== 1 ? ` (w:${weight})` : '';
+}
+function serializeL2(child) {
+    const check = child.checked ? 'x' : ' ';
+    const progress = serializeKRProgress(child, false);
+    const weight = serializeWeight(child.weight ?? 1);
+    return `   - [${check}] ${child.text}${progress}${weight}`;
+}
+function serializeL1(kr) {
+    const lines = [];
+    const check = kr.checked ? 'x' : ' ';
+    const hasChildren = kr.children && kr.children.length > 0;
+    let autoProgress;
+    if (hasChildren) {
+        autoProgress = computeWeightedAverage(kr.children);
+    }
+    const progress = serializeKRProgress(kr, !!hasChildren, autoProgress);
+    const weight = serializeWeight(kr.weight ?? 1);
+    lines.push(`${kr.rank}. [${check}] ${kr.text}${progress}${weight}`);
+    if (kr.children) {
+        for (const child of kr.children) {
+            lines.push(serializeL2(child));
+        }
+    }
+    return lines;
+}
+function serializePeriod(period) {
+    const lines = [];
+    lines.push(`- Start: ${period.start}`);
+    lines.push(`- End: ${period.end}`);
+    lines.push(`- Status: ${period.status}`);
+    if (period.completedAt)
+        lines.push(`- Completed At: ${period.completedAt}`);
+    if (period.droppedAt)
+        lines.push(`- Dropped At: ${period.droppedAt}`);
+    if (period.reason)
+        lines.push(`- Reason: ${period.reason}`);
+    return lines;
+}
+function serializeGoalMd(parsed) {
+    const lines = [];
+    lines.push(DEFAULT_FRONTMATTER);
+    lines.push('');
+    lines.push(`# ${parsed.title}`);
+    lines.push('');
+    lines.push('## Period');
+    lines.push(...serializePeriod(parsed.period));
+    lines.push('');
+    lines.push('## Objective');
+    if (parsed.objective.body) {
+        lines.push(parsed.objective.body);
+    }
+    lines.push('');
+    lines.push('## Key Results');
+    for (const kr of parsed.keyResults) {
+        lines.push(...serializeL1(kr));
+    }
+    lines.push('');
+    lines.push('## Notes');
+    if (parsed.notes) {
+        lines.push(parsed.notes);
+    }
+    lines.push('');
+    lines.push('## Reflection');
+    if (parsed.reflection) {
+        lines.push(parsed.reflection);
+    }
+    lines.push('');
+    return lines.join('\n');
+}

package/dist-server/domain/market/market.controller.js

@@ -47,10 +47,18 @@ let MarketController = class MarketController {
         this.marketService.deleteRegistry(id);
         return { success: true };
     }
+    async listAllMarketItems() {
+        const data = await this.marketService.listAllMarketItems();
+        return { success: true, data };
+    }
     async listMarketItems(id) {
         const data = await this.marketService.listMarketItems(id);
         return { success: true, data };
     }
+    async getRemoteSkillDetail(id, name) {
+        const data = await this.marketService.getRemoteSkillDetail(id, name);
+        return { success: true, data };
+    }
     async installMarketItem(dto) {
         const data = await this.marketService.installMarketItem(dto.registryId, dto.marketName);
         return { success: true, data };
@@ -108,13 +116,29 @@ __decorate([
     __metadata("design:returntype", void 0)
 ], MarketController.prototype, "deleteRegistry", null);
 __decorate([
-    (0, swagger_1.ApiOperation)({ operationId: 'MKT.LIST', summary: 'List items in a registry' }),
+    (0, swagger_1.ApiOperation)({ operationId: 'MKT.LIST', summary: 'List all market items across registries' }),
+    (0, common_1.Get)('items'),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", []),
+    __metadata("design:returntype", Promise)
+], MarketController.prototype, "listAllMarketItems", null);
+__decorate([
+    (0, swagger_1.ApiOperation)({ operationId: 'MKT.LIST.REGISTRY', summary: 'List items in a registry' }),
     (0, common_1.Get)('registries/:id/items'),
     __param(0, (0, common_1.Param)('id')),
     __metadata("design:type", Function),
     __metadata("design:paramtypes", [String]),
     __metadata("design:returntype", Promise)
 ], MarketController.prototype, "listMarketItems", null);
+__decorate([
+    (0, swagger_1.ApiOperation)({ operationId: 'MKT.REMOTE.DETAIL', summary: 'Get remote skill detail (SKILL.md)' }),
+    (0, common_1.Get)('registries/:id/items/:name/detail'),
+    __param(0, (0, common_1.Param)('id')),
+    __param(1, (0, common_1.Param)('name')),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [String, String]),
+    __metadata("design:returntype", Promise)
+], MarketController.prototype, "getRemoteSkillDetail", null);
 __decorate([
     (0, swagger_1.ApiOperation)({ operationId: 'MKT.INSTALL', summary: 'Install an item from registry' }),
     (0, common_1.Post)('install'),