crewos 0.1.0

package/backend/src/services/onboarding.service.js

@@ -0,0 +1,328 @@
+import path from 'path';
+import os from 'os';
+import fs from 'fs';
+import { spawn } from 'child_process';
+
+import { getDB } from '../configs/db.config.js';
+import { fetchModelsFromProvider } from './config.service.js';
+
+const CREWOS_CONFIG_PATH = path.join(os.homedir(), '.crewos', 'config.json');
+const ANALYSIS_TIMEOUT_MS = 15 * 60 * 1_000;
+
+const SECTION_MARKERS = [
+  'FOLDER_STRUCTURE',
+  'TECH_STACK',
+  'CODING_CONVENTIONS',
+  'DATABASE_DESIGN',
+  'API_DESIGN',
+  'CONFIG_SYSTEM',
+  'KEY_PATTERNS',
+];
+
+const FIELD_MAP = {
+  FOLDER_STRUCTURE: 'folderStructure',
+  TECH_STACK: 'techStack',
+  CODING_CONVENTIONS: 'codingConventions',
+  DATABASE_DESIGN: 'databaseDesign',
+  API_DESIGN: 'apiDesign',
+  CONFIG_SYSTEM: 'configSystem',
+  KEY_PATTERNS: 'keyPatterns',
+};
+
+let analysisProcess = null;
+let analysisProgress = [];
+let analysisSettled = false;
+
+export const isAnalyzing = () => analysisProcess !== null;
+
+export const getAnalysisProgress = () => analysisProgress;
+
+export const validateCredentials = async (baseURL, apiKey) => {
+  const normalizedBase = baseURL.replace(/\/+$/, '');
+  const modelsUrl = `${normalizedBase}/models`;
+
+  const response = await fetch(modelsUrl, {
+    headers: {
+      Authorization: `Bearer ${apiKey}`,
+      'Content-Type': 'application/json',
+    },
+  });
+
+  if (!response.ok) {
+    throw new Error(
+      `Connection failed (HTTP ${response.status}). Check your Base URL and API Key.`,
+    );
+  }
+
+  return true;
+};
+
+export const getOnboardingStatus = () => {
+  const db = getDB();
+  const pk = db.data.meta.projectKnowledge || {};
+  const contentFields = [
+    'folderStructure',
+    'techStack',
+    'codingConventions',
+    'databaseDesign',
+    'apiDesign',
+    'configSystem',
+    'keyPatterns',
+  ];
+  const hasKnowledge = contentFields.some(
+    (f) => typeof pk[f] === 'string' && pk[f].trim().length > 0,
+  );
+  return {
+    onboardingCompleted: db.data.meta.onboardingCompleted || false,
+    baseURL: db.data.meta.baseURL || '',
+    apiKey: db.data.meta.apiKey || '',
+    projectKnowledge: pk,
+    hasCredentials: !!(db.data.meta.baseURL && db.data.meta.apiKey),
+    hasKnowledge,
+    isAnalyzing: isAnalyzing(),
+  };
+};
+
+export const saveCredentials = (baseURL, apiKey) => {
+  const db = getDB();
+  db.data.meta.baseURL = baseURL;
+  db.data.meta.apiKey = apiKey;
+  db.write();
+
+  try {
+    fetchModelsFromProvider(baseURL, apiKey);
+  } catch {
+    // non-fatal
+  }
+};
+
+function parseAnalysisOutput(raw) {
+  const result = {};
+  let currentSection = null;
+  const lines = raw.split('\n');
+
+  for (const line of lines) {
+    for (const marker of SECTION_MARKERS) {
+      const tag = `===${marker}===`;
+      if (line.includes(tag)) {
+        currentSection = marker;
+        result[FIELD_MAP[marker]] = '';
+        break;
+      }
+    }
+
+    if (
+      currentSection &&
+      !SECTION_MARKERS.some((m) => line.includes(`===${m}===`))
+    ) {
+      const field = FIELD_MAP[currentSection];
+      if (result[field] !== undefined) {
+        result[field] += (result[field] ? '\n' : '') + line;
+      }
+    }
+  }
+
+  for (const marker of SECTION_MARKERS) {
+    const field = FIELD_MAP[marker];
+    if (!result[field]) result[field] = '';
+    else result[field] = result[field].trim();
+  }
+
+  return result;
+}
+
+export const startAnalysis = () => {
+  const db = getDB();
+
+  if (analysisProcess) {
+    return { error: 'Analysis is already running' };
+  }
+
+  let workingDir = process.cwd();
+  if (fs.existsSync(CREWOS_CONFIG_PATH)) {
+    try {
+      const cfg = JSON.parse(fs.readFileSync(CREWOS_CONFIG_PATH, 'utf-8'));
+      workingDir = cfg.workingDir || process.cwd();
+    } catch (err) {
+      console.error(`workingDir`, err);
+    }
+  }
+
+  console.log(`analyze working directory`, workingDir);
+
+  const sectionInstructions = SECTION_MARKERS.map((m) => {
+    const label = m.replace(/_/g, ' ').replace(/\b\w/g, (c) => c);
+    return `===${m}===\n[content about ${label.toLowerCase()}]\n===END_${m}===`;
+  }).join('\n\n');
+
+  const prompt = [
+    `You are analyzing the codebase at: ${workingDir}`,
+    '',
+    'IMPORTANT: Explore EVERY directory and subdirectory in this project. Use ls, find (or equivalents) to discover the full folder tree. Read files from ALL top-level and nested directories — do NOT focus on a single subfolder.',
+    '',
+    'Produce a structured knowledge report using EXACTLY the section markers shown below. Each section MUST start with its marker on its own line and end with its END_ marker.',
+    'Include specific file paths, function names, and concrete examples. If a section does not apply, write "N/A". Do not skip any section.',
+    '',
+    sectionInstructions,
+    '',
+    'SECTIONS:',
+    'FOLDER_STRUCTURE — List EVERY top-level directory and file with its purpose. Show the full tree.',
+    'TECH_STACK — Languages, frameworks, dependencies, build tools (check all package.json, requirements.txt, go.mod, Cargo.toml, etc. across every subdirectory)',
+    'CODING_CONVENTIONS — Naming patterns, file organization, styling approach, code style across the whole project',
+    'DATABASE_DESIGN — Schemas, models, relationships, storage mechanism',
+    'API_DESIGN — Route structure, auth approach, request/response patterns',
+    'CONFIG_SYSTEM — Config files, environment variables, how the app bootstraps',
+    'KEY_PATTERNS — Design patterns, architectural decisions, notable idioms',
+    '',
+    `Remember: explore the ENTIRE directory tree at ${workingDir} — do not limit your analysis to any single folder.`,
+  ].join('\n');
+
+  const args = ['run', '--dangerously-skip-permissions', prompt];
+
+  const child = spawn('opencode', args, {
+    cwd: workingDir,
+    env: process.env,
+    stdio: ['ignore', 'pipe', 'pipe'],
+  });
+
+  analysisProcess = child;
+  analysisProgress = [];
+  analysisSettled = false;
+
+  let settled = false;
+  let timeout = null;
+
+  timeout = setTimeout(() => {
+    if (settled) return;
+    settled = true;
+    analysisSettled = true;
+
+    try {
+      child.kill('SIGTERM');
+      setTimeout(() => {
+        if (!child.killed) {
+          try {
+            child.kill('SIGKILL');
+          } catch (err) {
+            console.error(`timeout hit`, err);
+          }
+        }
+      }, 5000);
+    } catch (err) {
+      console.error(`kill`, err);
+    }
+
+    analysisProcess = null;
+  }, ANALYSIS_TIMEOUT_MS);
+
+  child.stdout.on('data', (data) => {
+    const lines = data.toString().split('\n').filter(Boolean);
+    analysisProgress.push(...lines);
+  });
+
+  child.stderr.on('data', (data) => {
+    const lines = data.toString().split('\n').filter(Boolean);
+    analysisProgress.push(...lines);
+  });
+
+  child.on('close', (code) => {
+    if (settled) return;
+    if (timeout) clearTimeout(timeout);
+    settled = true;
+    analysisSettled = true;
+
+    if (code === 0) {
+      const raw = analysisProgress.join('\n');
+      const structured = parseAnalysisOutput(raw);
+      const hasAny = Object.values(structured).some((v) => v && v.trim());
+
+      try {
+        const freshDb = getDB();
+        freshDb.data.meta.projectKnowledge = hasAny
+          ? structured
+          : fallbackParse(raw);
+        freshDb.data.meta.projectKnowledge.lastAnalyzed =
+          new Date().toISOString();
+        freshDb.write();
+      } catch (err) {
+        console.error(`db write`, err);
+      }
+    }
+
+    analysisProcess = null;
+  });
+
+  child.on('error', () => {
+    if (settled) return;
+    if (timeout) clearTimeout(timeout);
+    settled = true;
+    analysisSettled = true;
+    analysisProcess = null;
+  });
+
+  return { success: true };
+};
+
+function fallbackParse(raw) {
+  const result = {};
+  const sections = {
+    '## Project Structure': 'folderStructure',
+    '## Tech Stack': 'techStack',
+    '## Coding Conventions': 'codingConventions',
+    '## Database Design': 'databaseDesign',
+    '## API Design': 'apiDesign',
+    '## Configuration System': 'configSystem',
+    '## Key Patterns': 'keyPatterns',
+  };
+
+  let current = null;
+  for (const line of raw.split('\n')) {
+    const trimmed = line.trim();
+    const match = Object.entries(sections).find(([h]) =>
+      trimmed.toLowerCase().startsWith(h.toLowerCase()),
+    );
+    if (match) {
+      current = match[1];
+      result[current] = '';
+      continue;
+    }
+    if (current && result[current] !== undefined) {
+      result[current] += (result[current] ? '\n' : '') + line;
+    }
+  }
+
+  for (const field of Object.values(sections)) {
+    if (!result[field]) result[field] = '';
+    else result[field] = result[field].trim();
+  }
+
+  return result;
+}
+
+export const completeOnboarding = () => {
+  const db = getDB();
+  const pk = db.data.meta.projectKnowledge || {};
+  const contentFields = [
+    'folderStructure',
+    'techStack',
+    'codingConventions',
+    'databaseDesign',
+    'apiDesign',
+    'configSystem',
+    'keyPatterns',
+  ];
+  const hasKnowledge = contentFields.some(
+    (f) => typeof pk[f] === 'string' && pk[f].trim().length > 0,
+  );
+  if (!hasKnowledge) {
+    return { error: 'Project analysis must be completed first' };
+  }
+  db.data.meta.onboardingCompleted = true;
+  db.write();
+  return { success: true };
+};
+
+export const getProjectKnowledge = () => {
+  const db = getDB();
+  return db.data.meta.projectKnowledge || {};
+};

package/backend/src/services/role.service.js

@@ -0,0 +1,23 @@
+import { create as createMember } from './member.service.js';
+import roles from './data/roles.json' with { type: 'json' };
+
+export const getRoles = () => {
+  return roles;
+};
+
+export const getRoleById = (id) => {
+  return roles.find((r) => r.id === id) || null;
+};
+
+export const pullRole = (roleId) => {
+  const role = getRoleById(roleId);
+  if (!role) return { error: 'Role not found' };
+
+  return createMember({
+    role: role.title,
+    roleId: role.id,
+    skills: role.skills.join(', '),
+    rules: role.rules.join('\n'),
+    memory: role.memory.join('\n'),
+  });
+};