tycono 0.1.7 → 0.1.8

package/README.md

@@ -7,15 +7,11 @@
 ## Quick Start
 
 ```bash
-# Create a new company
 mkdir my-company && cd my-company
-npx tycono init
-
-# Start the dashboard
 npx tycono
 ```
 
-That's it. Your browser opens to a live dashboard showing your AI team at work.
+That's it. A setup wizard guides you through creating your company, then your browser opens to a live dashboard showing your AI team at work.
 
 ## What You Get
 
@@ -33,7 +29,7 @@ That's it. Your browser opens to a live dashboard showing your AI team at work.
 
 ## Team Templates
 
-When you run `init`, pick a template:
+During setup, pick a template:
 
 | Template | Roles |
 |----------|-------|
@@ -74,8 +70,7 @@ your-company/
 ## CLI Usage
 
 ```bash
-tycono              # Start server + open dashboard
-tycono init          # Create a new company
+tycono              # Start server + open dashboard (setup wizard if first run)
 tycono --help        # Show help
 tycono --version     # Show version
 ```

package/bin/tycono.ts

@@ -20,9 +20,6 @@ function printHelp(): void {
 
   Usage:
     tycono              Start the server and open dashboard
-    tycono init         Initialize a new company in current directory
-    tycono init -y      Use defaults (skip prompts)
-    tycono init --name "Acme Corp"  Set company name
     tycono --help       Show this help message
     tycono --version    Show version
 
@@ -178,12 +175,6 @@ export async function main(args: string[]): Promise<void> {
     return;
   }
 
-  if (command === 'init') {
-    const { runInit } = await import('./init.js');
-    await runInit(args.slice(1));
-    return;
-  }
-
   if (command && !command.startsWith('-')) {
     console.error(`  Unknown command: ${command}`);
     printHelp();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "tycono",
-  "version": "0.1.7",
+  "version": "0.1.8",
   "description": "Build an AI company. Watch them work.",
   "type": "module",
   "bin": {

package/src/api/src/routes/git.ts

@@ -0,0 +1,179 @@
+import { Router, Request, Response, NextFunction } from 'express';
+import { execSync } from 'node:child_process';
+import { COMPANY_ROOT } from '../services/file-reader.js';
+
+export const gitRouter = Router();
+
+interface WorktreeInfo {
+  path: string;
+  branch: string;
+  commitHash: string;
+  isMain: boolean;
+}
+
+interface LastCommit {
+  hash: string;
+  message: string;
+  date: string;
+}
+
+function git(cmd: string): string {
+  return execSync(`git ${cmd}`, { cwd: COMPANY_ROOT, encoding: 'utf-8' }).trim();
+}
+
+// GET /api/git/status
+gitRouter.get('/status', (_req: Request, res: Response, next: NextFunction) => {
+  try {
+    // Current branch
+    let currentBranch: string;
+    try {
+      currentBranch = git('rev-parse --abbrev-ref HEAD');
+    } catch {
+      res.status(500).json({ error: 'Not a git repository or git is not available' });
+      return;
+    }
+
+    // Worktrees
+    let worktrees: WorktreeInfo[] = [];
+    try {
+      const raw = git('worktree list --porcelain');
+      const blocks = raw.split('\n\n').filter(Boolean);
+      for (const block of blocks) {
+        const lines = block.split('\n');
+        const wtPath = lines.find(l => l.startsWith('worktree '))?.replace('worktree ', '') ?? '';
+        const commitHash = lines.find(l => l.startsWith('HEAD '))?.replace('HEAD ', '') ?? '';
+        const branchLine = lines.find(l => l.startsWith('branch '));
+        const branch = branchLine ? branchLine.replace('branch refs/heads/', '') : '(detached)';
+        const isMain = lines.some(l => l === 'worktree ' + COMPANY_ROOT) ||
+          (!branchLine && lines.some(l => l === 'bare'));
+        worktrees.push({
+          path: wtPath,
+          branch,
+          commitHash,
+          isMain: wtPath === COMPANY_ROOT,
+        });
+      }
+    } catch {
+      worktrees = [];
+    }
+
+    // Stale (unmerged) branches
+    let staleBranches: string[] = [];
+    try {
+      const raw = git('branch --no-merged develop');
+      staleBranches = raw
+        .split('\n')
+        .map(b => b.trim().replace(/^\*\s*/, ''))
+        .filter(Boolean);
+    } catch {
+      staleBranches = [];
+    }
+
+    // Unsaved changes count
+    let unsavedChanges = 0;
+    try {
+      const raw = git('status --porcelain');
+      unsavedChanges = raw ? raw.split('\n').filter(Boolean).length : 0;
+    } catch {
+      unsavedChanges = 0;
+    }
+
+    // Last commit
+    let lastCommit: LastCommit | null = null;
+    try {
+      const raw = git('log -1 --format=%H%n%s%n%aI');
+      const [hash, message, date] = raw.split('\n');
+      if (hash) {
+        lastCommit = { hash, message: message ?? '', date: date ?? '' };
+      }
+    } catch {
+      lastCommit = null;
+    }
+
+    res.json({
+      currentBranch,
+      worktrees,
+      staleBranches,
+      unsavedChanges,
+      lastCommit,
+    });
+  } catch (err) {
+    next(err);
+  }
+});
+
+// DELETE /api/git/worktree/:path — Remove a worktree
+gitRouter.delete('/worktree/{*path}', (req: Request, res: Response, next: NextFunction) => {
+  try {
+    const rawPath = (req.params as Record<string, unknown>).path;
+    const worktreePath = Array.isArray(rawPath) ? rawPath.join('/') : String(rawPath ?? '');
+    if (!worktreePath) {
+      res.status(400).json({ error: 'Worktree path is required' });
+      return;
+    }
+
+    try {
+      git(`worktree remove ${JSON.stringify(worktreePath)}`);
+    } catch {
+      // Try force remove if normal remove fails
+      git(`worktree remove --force ${JSON.stringify(worktreePath)}`);
+    }
+
+    res.json({ success: true, removed: worktreePath });
+  } catch (err) {
+    const message = err instanceof Error ? err.message : 'Failed to remove worktree';
+    res.status(500).json({ error: message });
+  }
+});
+
+// DELETE /api/git/branch/:name — Delete a branch (local + remote)
+gitRouter.delete('/branch/{*name}', (req: Request, res: Response, next: NextFunction) => {
+  try {
+    const rawName = (req.params as Record<string, unknown>).name;
+    const branchName = Array.isArray(rawName) ? rawName.join('/') : String(rawName ?? '');
+    if (!branchName) {
+      res.status(400).json({ error: 'Branch name is required' });
+      return;
+    }
+
+    // Prevent deleting main/develop
+    if (branchName === 'main' || branchName === 'develop') {
+      res.status(403).json({ error: `Cannot delete protected branch: ${branchName}` });
+      return;
+    }
+
+    const errors: string[] = [];
+
+    // Delete local branch
+    try {
+      git(`branch -d ${JSON.stringify(branchName)}`);
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : 'Unknown error';
+      // If branch is not fully merged, report but continue to try remote
+      if (msg.includes('not fully merged')) {
+        errors.push(`Local branch not fully merged. Use force delete if intended.`);
+      } else if (!msg.includes('not found')) {
+        errors.push(`Local: ${msg}`);
+      }
+    }
+
+    // Delete remote branch
+    try {
+      git(`push origin --delete ${JSON.stringify(branchName)}`);
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : 'Unknown error';
+      if (!msg.includes('remote ref does not exist')) {
+        errors.push(`Remote: ${msg}`);
+      }
+    }
+
+    if (errors.length > 0) {
+      res.status(207).json({ success: false, branch: branchName, errors });
+    } else {
+      res.json({ success: true, deleted: branchName });
+    }
+  } catch (err) {
+    const message = err instanceof Error ? err.message : 'Failed to delete branch';
+    res.status(500).json({ error: message });
+  }
+});

package/src/api/src/routes/speech.ts

@@ -14,6 +14,7 @@ import { parseMarkdownTable, extractBoldKeyValues } from '../services/markdown-p
 import { AnthropicProvider, ClaudeCliProvider, type LLMProvider } from '../engine/llm-adapter.js';
 import { TokenLedger } from '../services/token-ledger.js';
 import { readConfig } from '../services/company-config.js';
+import { calcLevel } from '../utils/role-level.js';
 
 export const speechRouter = Router();
 
@@ -147,6 +148,29 @@ speechRouter.post('/chat', async (req: Request, res: Response, next: NextFunctio
       workContext?: { currentTask: string | null; taskProgress: string | null };
     };
 
+    // ── Compute role levels from token ledger ──
+    const tokenLedger = getLedger();
+    const allEntries = tokenLedger.query();
+
+    // Aggregate total tokens (input + output) per role
+    const tokensByRole: Record<string, number> = {};
+    for (const entry of allEntries.entries) {
+      tokensByRole[entry.roleId] = (tokensByRole[entry.roleId] ?? 0) + entry.inputTokens + entry.outputTokens;
+    }
+
+    const roleLevel = calcLevel(tokensByRole[roleId] ?? 0);
+
+    // Team stats
+    const roleIds = Object.keys(tokensByRole);
+    const levels = roleIds.map(id => ({ id, level: calcLevel(tokensByRole[id]) }));
+    const avgLevel = levels.length > 0
+      ? Math.round(levels.reduce((sum, r) => sum + r.level, 0) / levels.length)
+      : 1;
+    const topEntry = levels.reduce((best, r) => r.level > best.level ? r : best, { id: roleId, level: roleLevel });
+    const totalTokens = allEntries.totalInput + allEntries.totalOutput;
+
+    const teamStats = { avgLevel, topRole: topEntry.id, totalTokens };
+
     if (!roleId || !channelId) {
       res.status(400).json({ error: 'roleId and channelId are required' });
       return;
@@ -190,6 +214,9 @@ speechRouter.post('/chat', async (req: Request, res: Response, next: NextFunctio
       ? `\nYou are currently working on: "${workContext.currentTask}"${workContext.taskProgress ? ` (${workContext.taskProgress})` : ''}`
       : '\nYou are currently idle (no active task).';
 
+    // Build level context
+    const levelCtx = `\nYour current level is Lv.${roleLevel}. Team average is Lv.${avgLevel}. ${topEntry.id} is the highest-leveled team member.`;
+
     // Format chat history
     const historyText = history.length > 0
       ? history.map(h => {
@@ -209,6 +236,7 @@ speechRouter.post('/chat', async (req: Request, res: Response, next: NextFunctio
     const systemPrompt = `You are ${node.name}, a ${node.level} employee.
 Persona: ${persona}
 ${workCtx}
+${levelCtx}
 ${companyCtx}
 
 You are in the #${channelId} chat channel.${topicCtx}
@@ -224,6 +252,7 @@ Rules:
 - Vary your tone: sometimes enthusiastic, sometimes tired, sometimes joking
 - Use appropriate tone based on hierarchy and familiarity
 - Do NOT repeat what others already said
+- You may occasionally (not every message) reference levels, token usage, or team rankings in a natural way — like coworkers comparing experience or celebrating milestones
 - If the conversation is stale or you have nothing new to add, respond with exactly: [SILENT]
 - Do NOT use quotes around your response. Just output the raw sentence.
 - Write in English.`;

package/src/api/src/routes/sync.ts

@@ -0,0 +1,165 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import YAML from 'yaml';
+import { Router, Request, Response, NextFunction } from 'express';
+import { COMPANY_ROOT } from '../services/file-reader.js';
+import { buildOrgTree, type RoleSource } from '../engine/org-tree.js';
+import { RoleLifecycleManager } from '../engine/role-lifecycle.js';
+import { getTokenLedger } from '../services/token-ledger.js';
+import { estimateCost } from '../services/pricing.js';
+import { calcLevel, calcProgress, formatTokens } from '../utils/role-level.js';
+
+export const syncRouter = Router();
+
+/* ─── GET /api/sync/roles — List roles with source tracking ─── */
+
+syncRouter.get('/roles', (_req: Request, res: Response, next: NextFunction) => {
+  try {
+    const tree = buildOrgTree(COMPANY_ROOT);
+    const trackedRoles: Array<{
+      roleId: string;
+      name: string;
+      level: string;
+      source: RoleSource;
+      persona: string;
+      authority: { autonomous: string[]; needsApproval: string[] };
+      skills?: string[];
+    }> = [];
+
+    for (const [id, node] of tree.nodes) {
+      if (id === 'ceo' || !node.source) continue;
+      trackedRoles.push({
+        roleId: id,
+        name: node.name,
+        level: node.level,
+        source: node.source,
+        persona: node.persona,
+        authority: node.authority,
+        skills: node.skills,
+      });
+    }
+
+    res.json({ roles: trackedRoles });
+  } catch (err) {
+    next(err);
+  }
+});
+
+/* ─── POST /api/sync/apply — Apply upstream changes to a role ─── */
+
+syncRouter.post('/apply', async (req: Request, res: Response, next: NextFunction) => {
+  try {
+    const { roleId, changes, upstreamVersion } = req.body as {
+      roleId: string;
+      changes: { persona?: string; authority?: { autonomous: string[]; needsApproval: string[] }; skills?: string[] };
+      upstreamVersion?: string;
+    };
+
+    if (!roleId || !changes) {
+      res.status(400).json({ error: 'roleId and changes are required' });
+      return;
+    }
+
+    const manager = new RoleLifecycleManager(COMPANY_ROOT);
+    await manager.updateRole(roleId, changes);
+
+    // Update source.upstream_version if provided
+    if (upstreamVersion) {
+      const yamlPath = path.join(COMPANY_ROOT, 'roles', roleId, 'role.yaml');
+      const raw = YAML.parse(fs.readFileSync(yamlPath, 'utf-8')) as Record<string, unknown>;
+      if (raw.source && typeof raw.source === 'object') {
+        (raw.source as Record<string, unknown>).upstream_version = upstreamVersion;
+      }
+      fs.writeFileSync(yamlPath, YAML.stringify(raw));
+    }
+
+    res.json({ ok: true, roleId, applied: Object.keys(changes) });
+  } catch (err) {
+    next(err);
+  }
+});
+
+/* ─── GET /api/sync/stats — Company-wide gamification stats ─── */
+
+syncRouter.get('/stats', (_req: Request, res: Response, next: NextFunction) => {
+  try {
+    const tree = buildOrgTree(COMPANY_ROOT);
+    const ledger = getTokenLedger(COMPANY_ROOT);
+    const summary = ledger.query();
+
+    // Aggregate by role
+    const byRole: Record<string, { inputTokens: number; outputTokens: number; costUsd: number }> = {};
+    const byModel: Record<string, { inputTokens: number; outputTokens: number; costUsd: number }> = {};
+
+    for (const entry of summary.entries) {
+      if (!byRole[entry.roleId]) {
+        byRole[entry.roleId] = { inputTokens: 0, outputTokens: 0, costUsd: 0 };
+      }
+      byRole[entry.roleId].inputTokens += entry.inputTokens;
+      byRole[entry.roleId].outputTokens += entry.outputTokens;
+      byRole[entry.roleId].costUsd += estimateCost(entry.inputTokens, entry.outputTokens, entry.model);
+
+      if (!byModel[entry.model]) {
+        byModel[entry.model] = { inputTokens: 0, outputTokens: 0, costUsd: 0 };
+      }
+      byModel[entry.model].inputTokens += entry.inputTokens;
+      byModel[entry.model].outputTokens += entry.outputTokens;
+      byModel[entry.model].costUsd += estimateCost(entry.inputTokens, entry.outputTokens, entry.model);
+    }
+
+    // Role count (excluding CEO)
+    const roleCount = tree.nodes.size - 1;
+
+    // Compute per-role levels
+    const roleLevels: Array<{
+      roleId: string;
+      name: string;
+      level: number;
+      totalTokens: number;
+      progress: number;
+      formattedTokens: string;
+      costUsd: number;
+    }> = [];
+
+    for (const [id, node] of tree.nodes) {
+      if (id === 'ceo') continue;
+      const roleData = byRole[id];
+      const totalTokens = roleData ? roleData.inputTokens + roleData.outputTokens : 0;
+      roleLevels.push({
+        roleId: id,
+        name: node.name,
+        level: calcLevel(totalTokens),
+        totalTokens,
+        progress: calcProgress(totalTokens),
+        formattedTokens: formatTokens(totalTokens),
+        costUsd: roleData?.costUsd ?? 0,
+      });
+    }
+
+    // Sort by totalTokens desc (leaderboard)
+    roleLevels.sort((a, b) => b.totalTokens - a.totalTokens);
+
+    // Company aggregate
+    const totalTokens = summary.totalInput + summary.totalOutput;
+    let totalCostUsd = 0;
+    for (const entry of summary.entries) {
+      totalCostUsd += estimateCost(entry.inputTokens, entry.outputTokens, entry.model);
+    }
+
+    res.json({
+      company: {
+        roleCount,
+        totalTokens,
+        formattedTokens: formatTokens(totalTokens),
+        totalCostUsd,
+        avgLevel: roleLevels.length > 0
+          ? Math.round(roleLevels.reduce((sum, r) => sum + r.level, 0) / roleLevels.length * 10) / 10
+          : 1,
+      },
+      roles: roleLevels,
+      byModel,
+    });
+  } catch (err) {
+    next(err);
+  }
+});

package/src/api/src/services/scaffold.ts

@@ -1,7 +1,7 @@
 /**
  * scaffold.ts — AKB scaffolding service
  *
- * Extracted from bin/init.ts for reuse by the web onboarding wizard.
+ * AKB scaffolding used by the web onboarding wizard.
  */
 import fs from 'node:fs';
 import path from 'node:path';

package/src/api/src/utils/role-level.ts

@@ -0,0 +1,30 @@
+/**
+ * role-level.ts — Server-side role level calculation
+ *
+ * Mirrors the frontend level thresholds so the chat system prompt
+ * can reference a role's current level and team stats.
+ */
+
+const THRESHOLDS = [
+  0,           // Lv.1
+  10_000,      // Lv.2
+  50_000,      // Lv.3
+  150_000,     // Lv.4
+  400_000,     // Lv.5
+  1_000_000,   // Lv.6
+  2_500_000,   // Lv.7
+  5_000_000,   // Lv.8
+  10_000_000,  // Lv.9
+  25_000_000,  // Lv.10
+];
+
+export function calcLevel(totalTokens: number): number {
+  let level = 1;
+  for (let i = THRESHOLDS.length - 1; i >= 0; i--) {
+    if (totalTokens >= THRESHOLDS[i]) {
+      level = i + 1;
+      break;
+    }
+  }
+  return Math.min(level, 10);
+}