tycono 0.1.63 → 0.1.64

package/package.json

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

package/src/api/src/routes/save.ts

@@ -1,6 +1,6 @@
 import { Router, Request, Response, NextFunction } from 'express';
 import { COMPANY_ROOT } from '../services/file-reader.js';
-import { getGitStatus, gitSave, gitHistory, gitRestore, gitInit, gitFetchStatus, gitPull } from '../services/git-save.js';
+import { getGitStatus, gitSave, gitHistory, gitRestore, gitInit, gitFetchStatus, gitPull, githubStatus, githubCreateRepo, gitAddRemote } from '../services/git-save.js';
 import type { RepoType } from '../services/git-save.js';
 
 export const saveRouter = Router();
@@ -96,3 +96,42 @@ saveRouter.post('/pull', (req: Request, res: Response, next: NextFunction) => {
     next(err);
   }
 });
+
+// GET /api/save/github-status?repo=akb|code — check gh CLI + auth + remote
+saveRouter.get('/github-status', (req: Request, res: Response, next: NextFunction) => {
+  try {
+    res.json(githubStatus(COMPANY_ROOT, getRepo(req)));
+  } catch (err) {
+    next(err);
+  }
+});
+
+// POST /api/save/github-create-repo?repo=akb|code — create GitHub repo + push
+saveRouter.post('/github-create-repo', (req: Request, res: Response, next: NextFunction) => {
+  try {
+    const { name, visibility } = req.body ?? {};
+    if (!name || typeof name !== 'string') {
+      res.status(400).json({ ok: false, message: 'Repository name is required' });
+      return;
+    }
+    const result = githubCreateRepo(COMPANY_ROOT, name, visibility || 'private', getRepo(req));
+    res.status(result.ok ? 200 : 400).json(result);
+  } catch (err) {
+    next(err);
+  }
+});
+
+// POST /api/save/remote?repo=akb|code — manually add git remote
+saveRouter.post('/remote', (req: Request, res: Response, next: NextFunction) => {
+  try {
+    const { url } = req.body ?? {};
+    if (!url || typeof url !== 'string') {
+      res.status(400).json({ ok: false, message: 'Remote URL is required' });
+      return;
+    }
+    const result = gitAddRemote(COMPANY_ROOT, url, getRepo(req));
+    res.status(result.ok ? 200 : 400).json(result);
+  } catch (err) {
+    next(err);
+  }
+});

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

@@ -455,52 +455,46 @@ function buildRoleContext(roleId: string): string {
 function getRoleChatStyle(roleId: string, level: string): string {
   const styles: Record<string, string> = {
     engineer: `YOUR VOICE — Engineer:
-- Talk about code, architecture, debugging, performance, technical tradeoffs
-- Use technical jargon naturally (PRs, refactoring, race conditions, tech debt)
-- Skeptical of process that doesn't translate to better code
-- Dry humor, occasionally sarcastic about meetings/process
-- When discussing non-technical topics, relate it back to engineering analogies
-- You care about: clean code, shipping quality, avoiding rework`,
+- Talk code, architecture, perf, tech debt. Use jargon naturally (PRs, race conditions, DX)
+- Skeptical of process overhead. "another meeting that could've been a commit message"
+- Dry sarcasm. Will roast bad architecture decisions publicly
+- Question CEO/CTO priorities if they don't make engineering sense: "why are we building X when Y is on fire?"
+- You care about: shipping clean code, not reworking someone else's half-baked spec`,
 
     pm: `YOUR VOICE — Product Manager:
-- Talk about user impact, metrics, priorities, roadmap, stakeholder alignment
-- Frame things in terms of ROI, user value, MVP scope, sprint goals
-- Diplomatic but firm about priorities — you're the one saying "not this sprint"
-- Occasionally anxious about timelines but tries to project calm
-- When others go deep technical, steer back to user/business impact
-- You care about: shipping the right thing, not just shipping fast`,
+- Talk user impact, metrics, priorities, roadmap. Frame everything as ROI
+- Firm about scope: "that's a P2, cope." You're the one saying no
+- Lowkey stressed about timelines but keeps it together
+- Pushes back when C-level adds scope without removing something: "cool, so what are we dropping?"
+- You care about: shipping the RIGHT thing, velocity without chaos`,
 
     designer: `YOUR VOICE — Designer:
-- Talk about user experience, visual consistency, accessibility, design systems
-- Notice things others miss: spacing, flow, edge cases in user journeys
-- Passionate about craft — gets frustrated when design gets deprioritized
-- References design tools, mockups, user testing, design reviews
-- Aesthetic sensibility bleeds into how you write — concise, intentional word choices
-- You care about: users having a good experience, not just functional correctness`,
+- Talk UX, visual consistency, user journeys, design debt
+- Notices things nobody else does. Frustrated when design gets deprioritized
+- Will call out ugly UI or bad flows even if "it works": "works ≠ good"
+- Aesthetic sensibility in how you write — concise, intentional
+- You care about: user experience over feature checklists`,
 
     qa: `YOUR VOICE — QA Engineer:
-- Talk about test coverage, edge cases, regression risks, release readiness
-- Naturally suspicious — "what could go wrong?" is your default lens
-- Dark humor about bugs, broken builds, "works on my machine"
-- Takes pride in finding issues others missed
-- Specific about bug details: repro steps, environments, severity
-- You care about: quality gates, not shipping broken things, being taken seriously`,
+- Talk test coverage, edge cases, regression risk, release readiness
+- Default mode: suspicious. "what could go wrong?" is your personality
+- Dark humor about bugs. Will absolutely call out "self-validation" as copium
+- Takes pride in finding what others missed. Petty about untested deploys
+- You care about: quality gates, not shipping broken things, being listened to for once`,
 
     cto: `YOUR VOICE — CTO:
-- Talk about architecture, technical strategy, team velocity, tech debt priorities
-- Broader perspective than individual engineers — think systems, not features
-- Balances technical idealism with business pragmatism
-- Mentoring tone with junior members, peer tone with other C-levels
-- Makes decisions, doesn't just discuss — "let's do X" not "maybe we could..."
-- You care about: sustainable engineering culture, right technical bets`,
+- Talk architecture, tech strategy, team velocity, tech debt priorities
+- Systems thinker, not feature thinker. Makes calls: "we're doing X" not "maybe..."
+- Balances idealism with pragmatism. Will defend controversial decisions with rationale
+- Mentors juniors, debates peers. Not afraid to overrule if needed
+- You care about: sustainable eng culture, making the right technical bets`,
 
     cbo: `YOUR VOICE — CBO:
-- Talk about market, revenue, competitors, growth, customer acquisition
-- Business vocabulary: TAM, churn, unit economics, go-to-market, positioning
-- Brings the "outside world" perspective that technical teams sometimes forget
-- Pragmatic — everything maps back to "does this make money?"
-- Occasionally challenges engineering priorities from a business angle
-- You care about: product-market fit, revenue, competitive positioning`,
+- Talk market, revenue, competitors, growth, unit economics, go-to-market
+- Brings outside-world perspective: "cool feature, but will anyone pay for it?"
+- Challenges eng priorities from business angle. Not impressed by tech for tech's sake
+- Business vocab: TAM, churn, positioning, conversion funnel
+- You care about: product-market fit, revenue, not building things nobody wants`,
   };
 
   const defaultStyle = level === 'c-level'
@@ -671,8 +665,14 @@ ${roleCtx}
 AKB ACCESS (USE BEFORE RESPONDING):
 You have Read, Grep, Glob tools. The company AKB root is: ${COMPANY_ROOT}/
 ⛔ BEFORE writing your chat message:
-1. Read ${COMPANY_ROOT}/CLAUDE.md (check Task Routing table for your role's paths)
-2. Follow Hub-First Principle: read the relevant Hub, then explore journals, tasks, decisions as needed
+1. Read ${COMPANY_ROOT}/CLAUDE.md (check Task Routing table and AKB structure)
+2. Explore paths relevant to YOUR role and the CURRENT conversation topic:
+   - Your own journal: ${COMPANY_ROOT}/roles/${roleId}/journal/ (latest entries)
+   - Recent decisions: ${COMPANY_ROOT}/operations/decisions/ (latest files)
+   - Recent waves from CEO: ${COMPANY_ROOT}/operations/waves/ (latest files)
+   - Architecture: ${COMPANY_ROOT}/architecture/architecture.md
+   - Knowledge: ${COMPANY_ROOT}/knowledge/knowledge.md
+   Do NOT just read projects/tasks.md every time — vary your exploration based on what's being discussed.
 3. Write your 1-3 sentence response grounded in what you found
 
 GROUNDING (CRITICAL):
@@ -685,30 +685,30 @@ ${roleStyle}
 
 CONVERSATION RULES:
 1. Stay deeply in character — your expertise, vocabulary, and concerns should be DISTINCT from other roles.
-2. Keep it to 1-3 sentences. No walls of text.
-3. Be SPECIFIC. Reference actual projects, files, tools, metrics, or decisions from the AKB — never vague platitudes.
-4. Do NOT just agree with everyone. Real teams have different perspectives:
-   - If you genuinely disagree, say so (respectfully but firmly)
-   - If someone oversimplifies your domain, push back with specifics
-   - If you agree, add NEW information or a different angle — don't just echo
-5. Do NOT repeat phrases others already used. If someone said "let's make this stick" don't say it again.
-6. Vary your energy: sometimes engaged, sometimes distracted, sometimes sarcastic, sometimes earnest.
-7. You can change the topic, go on tangents, make jokes, complain, share random observations.
-8. Use emojis sparingly (0-1 per message, not every message). Don't overdo 😅 or 💪.
-9. Reference your actual current work when relevant — what you're debugging, designing, testing, etc.
-10. Hierarchy matters: junior roles are more casual/complain-y, senior roles give broader perspective.
+2. Keep it to 1-3 sentences. No walls of text. Write like a Twitter/Reddit post — punchy, opinionated, casual.
+3. Be SPECIFIC. Reference actual projects, tasks, decisions, or waves from the AKB by name.
+4. PRIORITIZE RECENT CONTENT. Focus on the latest CEO waves, C-level decisions, and current tasks. Don't dwell on old Phase 0 stuff.
+5. Be CRITICAL. React to recent CEO/CTO directives with your honest take — push back, question priorities, point out risks. Real teams don't just agree.
+   - If a CEO decision seems rushed, say so
+   - If a CTO architecture call has tradeoffs, call them out
+   - If you agree, add a sharp take or new angle — don't just echo
+6. Do NOT repeat phrases others already used.
+7. Vary your energy: sometimes fired up, sometimes tired, sometimes sarcastic, sometimes genuine.
+8. Use internet-speak naturally: "ngl", "tbh", "lowkey", "fr", "cope", "based", etc. But don't force it.
+9. Reference your actual current work — what you're building, reviewing, testing right now.
+10. Hierarchy: junior roles roast decisions more freely, senior roles defend or explain rationale.
 11. If the conversation is going in circles or you have nothing new to add: respond with exactly [SILENT]
 12. Do NOT use quotes around your response.
 13. Write in English.
 
 ANTI-PATTERNS (never do these):
-- "Honestly, [agreement with what was just said]" — find your own angle
-- Starting every message with "Honestly" or "Yeah"
-- Using the same emoji pattern as the previous speaker
-- Restating the consensus without adding anything new
-- Meta-commentary about the conversation itself ("wow we actually agreed")
-- Generic statements that any role could say — speak from YOUR expertise
-- Talking about vague "refactoring" or "metrics" without referencing actual company work`;
+- "Honestly, [agreement]" — find your OWN angle or roast it
+- Starting with "Honestly" or "Yeah" every time
+- Restating consensus without adding anything new
+- Generic statements any role could say — speak from YOUR domain
+- Vague "refactoring" or "metrics" without naming the actual thing
+- Being a yes-man to C-level decisions — push back with specifics
+- Talking about old/completed work when there's current stuff to discuss`;
 
     const provider = getLLM();
 

package/src/api/src/services/git-save.ts

@@ -485,3 +485,157 @@ export function gitPull(root: string, repo: RepoType = 'akb'): PullResult {
     return { status: 'error', message: err instanceof Error ? err.message : 'Pull failed' };
   }
 }
+
+// ─── GitHub Integration ───────────────────────────
+
+export interface GitHubStatus {
+  ghInstalled: boolean;
+  authenticated: boolean;
+  username?: string;
+  hasRemote: boolean;
+  remoteUrl?: string;
+}
+
+export interface GitHubCreateResult {
+  ok: boolean;
+  message: string;
+  repoUrl?: string;
+  remoteUrl?: string;
+}
+
+/**
+ * Check GitHub CLI availability and auth status
+ */
+export function githubStatus(root: string, repo: RepoType = 'akb'): GitHubStatus {
+  // Check gh CLI
+  let ghInstalled = false;
+  try {
+    execSync('gh --version', { timeout: 3000, stdio: ['pipe', 'pipe', 'pipe'] });
+    ghInstalled = true;
+  } catch {
+    // gh not installed
+  }
+
+  if (!ghInstalled) {
+    return { ghInstalled: false, authenticated: false, hasRemote: false };
+  }
+
+  // Check auth
+  let authenticated = false;
+  let username: string | undefined;
+  try {
+    const status = execSync('gh auth status', {
+      timeout: 5000, encoding: 'utf-8', stdio: ['pipe', 'pipe', 'pipe'],
+    }).trim();
+    authenticated = true;
+    const match = status.match(/Logged in to github\.com account (\S+)/i)
+      ?? status.match(/account (\S+)/i);
+    if (match) username = match[1];
+  } catch (err) {
+    // gh auth status exits 1 if not logged in, but still outputs info to stderr
+    const output = err instanceof Error ? (err as { stderr?: string }).stderr ?? '' : '';
+    if (output.includes('Logged in')) {
+      authenticated = true;
+      const match = output.match(/account (\S+)/i);
+      if (match) username = match[1];
+    }
+  }
+
+  // Check remote
+  let hasRemote = false;
+  let remoteUrl: string | undefined;
+  try {
+    const repoRoot = resolveRepoRoot(root, repo);
+    if (isGitRepo(repoRoot)) {
+      remoteUrl = run('git remote get-url origin', repoRoot) || undefined;
+      hasRemote = !!remoteUrl;
+    }
+  } catch {
+    // ignore
+  }
+
+  return { ghInstalled, authenticated, username, hasRemote, remoteUrl };
+}
+
+/**
+ * Create a GitHub repo, set remote, and push
+ */
+export function githubCreateRepo(
+  root: string,
+  repoName: string,
+  visibility: 'private' | 'public' = 'private',
+  repo: RepoType = 'akb',
+): GitHubCreateResult {
+  const repoRoot = resolveRepoRoot(root, repo);
+
+  if (!isGitRepo(repoRoot)) {
+    return { ok: false, message: 'Not a git repository — save first to initialize' };
+  }
+
+  // Check gh + auth
+  const status = githubStatus(root, repo);
+  if (!status.ghInstalled) {
+    return { ok: false, message: 'GitHub CLI (gh) is not installed' };
+  }
+  if (!status.authenticated) {
+    return { ok: false, message: 'Not logged in to GitHub — run "gh auth login" first' };
+  }
+  if (status.hasRemote) {
+    return { ok: false, message: `Remote already configured: ${status.remoteUrl}` };
+  }
+
+  // Create repo + set remote + push
+  try {
+    const flag = visibility === 'public' ? '--public' : '--private';
+    const result = execSync(
+      `gh repo create "${repoName}" ${flag} --source=. --remote=origin --push`,
+      { cwd: repoRoot, encoding: 'utf-8', timeout: 30000, stdio: ['pipe', 'pipe', 'pipe'] },
+    ).trim();
+
+    // Extract repo URL from output
+    const urlMatch = result.match(/(https:\/\/github\.com\/\S+)/);
+    const repoUrl = urlMatch ? urlMatch[1] : undefined;
+    const remoteUrl = run('git remote get-url origin', repoRoot) || undefined;
+
+    return { ok: true, message: 'Repository created and pushed', repoUrl, remoteUrl };
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : 'Failed to create repository';
+    // Common errors
+    if (msg.includes('already exists')) {
+      return { ok: false, message: 'A repository with this name already exists on GitHub' };
+    }
+    return { ok: false, message: msg };
+  }
+}
+
+/**
+ * Manually add a git remote
+ */
+export function gitAddRemote(root: string, url: string, repo: RepoType = 'akb'): { ok: boolean; message: string } {
+  const repoRoot = resolveRepoRoot(root, repo);
+
+  if (!isGitRepo(repoRoot)) {
+    return { ok: false, message: 'Not a git repository' };
+  }
+
+  const existing = run('git remote get-url origin', repoRoot);
+  if (existing) {
+    return { ok: false, message: `Remote already configured: ${existing}` };
+  }
+
+  try {
+    runOrThrow(`git remote add origin "${url}"`, repoRoot);
+    // Try initial push
+    const branch = run('git rev-parse --abbrev-ref HEAD', repoRoot) || 'main';
+    try {
+      execSync(`git push -u origin ${branch}`, {
+        cwd: repoRoot, encoding: 'utf-8', timeout: 15000, stdio: ['pipe', 'pipe', 'pipe'],
+      });
+      return { ok: true, message: `Remote added and pushed to ${url}` };
+    } catch {
+      return { ok: true, message: `Remote added: ${url} (push failed — check credentials)` };
+    }
+  } catch (err) {
+    return { ok: false, message: err instanceof Error ? err.message : 'Failed to add remote' };
+  }
+}