@pellux/goodvibes-agent 0.1.113 → 0.1.116

package/docs/getting-started.md

@@ -46,8 +46,12 @@ bun run dev
 
 After setup has been shown once, the TUI opens directly into the Agent operator workspace. You can also reopen it with `/agent`, `/home`, or `/operator`. That fullscreen workspace is the current front door for setup/config, provider/model selection, Agent Knowledge, local memory/skills/routines/personas, channel readiness, voice/media setup, read-only work/approval/automation views, and explicit GoodVibes TUI build delegation.
 
+The setup workspace scans local Agent behavior folders and shows importable persona, skill, and routine files before asking you to create blank records. Use `/personas discover`, `/agent-skills discover`, and `/routines discover` to preview files, then use the matching import action in the workspace after review.
+
 Use `/agent-profile guide` inside that workspace to walk through starter-profile authoring. It lists built-in and local starters, exports a JSON starter for editing, imports the edited starter back into this Agent home, and creates isolated profiles from the result.
 
+Use `goodvibes-agent profiles create-from-discovered research-desk --yes` or the Profiles workspace form to assemble a local starter template and isolated Agent profile from reviewed discovered persona, skill, and routine files. Use `profiles templates from-discovered <id> --yes` only when you want to save the starter before creating a profile.
+
 Use the Knowledge area in that workspace to ingest a source URL without leaving the TUI. The form requires typed confirmation and writes only to the isolated Agent Knowledge segment.
 
 Use `/schedule receipts` to review redacted local routine promotion history and `/schedule reconcile` to compare those receipts with live connected schedules through public `schedules.list`.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pellux/goodvibes-agent",
-  "version": "0.1.113",
+  "version": "0.1.116",
   "private": false,
   "description": "GoodVibes personal operator assistant TUI with a proactive Agent product brain, isolated Agent Knowledge, local profiles, routines, skills, personas, and explicit build delegation.",
   "type": "module",

package/src/agent/behavior-discovery-summary.ts

@@ -0,0 +1,167 @@
+import { readdirSync, readFileSync } from 'node:fs';
+import { join } from 'node:path';
+import type { ShellPathService } from '@/runtime/index.ts';
+import { GOODVIBES_AGENT_SURFACE_ROOT } from '../config/surface.ts';
+
+type DiscoveryOrigin = 'project-local' | 'global';
+
+interface DiscoveryRoot {
+  readonly root: string;
+  readonly origin: DiscoveryOrigin;
+}
+
+interface DiscoveryKindDefinition {
+  readonly roots: readonly DiscoveryRoot[];
+  readonly markers: readonly string[];
+  readonly frontmatterBodyKey?: string;
+}
+
+export interface AgentBehaviorDiscoverySummary {
+  readonly count: number;
+  readonly projectLocalCount: number;
+  readonly globalCount: number;
+  readonly names: readonly string[];
+}
+
+export interface AgentBehaviorDiscoverySnapshot {
+  readonly personas: AgentBehaviorDiscoverySummary;
+  readonly skills: AgentBehaviorDiscoverySummary;
+  readonly routines: AgentBehaviorDiscoverySummary;
+}
+
+const EMPTY_SUMMARY: AgentBehaviorDiscoverySummary = {
+  count: 0,
+  projectLocalCount: 0,
+  globalCount: 0,
+  names: [],
+};
+
+export const EMPTY_AGENT_BEHAVIOR_DISCOVERY_SNAPSHOT: AgentBehaviorDiscoverySnapshot = {
+  personas: EMPTY_SUMMARY,
+  skills: EMPTY_SUMMARY,
+  routines: EMPTY_SUMMARY,
+};
+
+function parseFrontmatter(content: string): Record<string, string> {
+  const match = content.match(/^---\n([\s\S]*?)\n---/);
+  if (!match) return {};
+  const result: Record<string, string> = {};
+  for (const line of match[1].split('\n')) {
+    const [key, ...rest] = line.split(':');
+    if (key && rest.length > 0) {
+      result[key.trim()] = rest.join(':').trim();
+    }
+  }
+  return result;
+}
+
+function markdownBody(content: string): string {
+  return content.replace(/^---\n[\s\S]*?\n---\n?/, '').trim();
+}
+
+function readDiscoveryCandidate(path: string, origin: DiscoveryOrigin, definition: DiscoveryKindDefinition): { readonly name: string; readonly origin: DiscoveryOrigin } | null {
+  let content = '';
+  try {
+    content = readFileSync(path, 'utf-8');
+  } catch {
+    return null;
+  }
+
+  const frontmatter = parseFrontmatter(content);
+  const body = definition.frontmatterBodyKey
+    ? (frontmatter[definition.frontmatterBodyKey] ?? markdownBody(content)).trim()
+    : markdownBody(content);
+  if (body.length === 0) return null;
+  const name = frontmatter.name ?? path.split(/[\\/]/).pop()?.replace(/\.md$/i, '') ?? '';
+  const normalized = name.trim();
+  return normalized ? { name: normalized, origin } : null;
+}
+
+function candidatePaths(root: string, entry: string, markers: readonly string[]): readonly string[] {
+  if (entry.endsWith('.md')) return [join(root, entry)];
+  return markers.map((marker) => join(root, entry, marker));
+}
+
+function summarizeDefinition(definition: DiscoveryKindDefinition, limit: number): AgentBehaviorDiscoverySummary {
+  const seen = new Set<string>();
+  const names: string[] = [];
+  let projectLocalCount = 0;
+  let globalCount = 0;
+
+  for (const { root, origin } of definition.roots) {
+    let entries: string[] = [];
+    try {
+      entries = readdirSync(root);
+    } catch {
+      continue;
+    }
+    for (const entry of entries.sort((left, right) => left.localeCompare(right))) {
+      for (const path of candidatePaths(root, entry, definition.markers)) {
+        const candidate = readDiscoveryCandidate(path, origin, definition);
+        if (!candidate) continue;
+        const key = candidate.name.toLowerCase();
+        if (seen.has(key)) break;
+        seen.add(key);
+        if (candidate.origin === 'project-local') projectLocalCount += 1;
+        else globalCount += 1;
+        if (names.length < limit) names.push(candidate.name);
+        break;
+      }
+    }
+  }
+
+  if (seen.size === 0) return EMPTY_SUMMARY;
+  return {
+    count: seen.size,
+    projectLocalCount,
+    globalCount,
+    names,
+  };
+}
+
+function definitions(shellPaths: Pick<ShellPathService, 'workingDirectory' | 'homeDirectory'>): AgentBehaviorDiscoverySnapshot {
+  const cwd = shellPaths.workingDirectory;
+  const homeDir = shellPaths.homeDirectory;
+  const personas: DiscoveryKindDefinition = {
+    roots: [
+      { root: join(cwd, '.goodvibes', 'personas'), origin: 'project-local' },
+      { root: join(cwd, '.goodvibes', GOODVIBES_AGENT_SURFACE_ROOT, 'personas'), origin: 'project-local' },
+      { root: join(cwd, '.goodvibes', 'agents'), origin: 'project-local' },
+      { root: join(homeDir, '.goodvibes', 'personas'), origin: 'global' },
+      { root: join(homeDir, '.goodvibes', GOODVIBES_AGENT_SURFACE_ROOT, 'personas'), origin: 'global' },
+      { root: join(homeDir, '.goodvibes', 'agents'), origin: 'global' },
+    ],
+    markers: ['PERSONA.md', 'persona.md', 'AGENT.md', 'agent.md'],
+    frontmatterBodyKey: 'system_prompt',
+  };
+  const skills: DiscoveryKindDefinition = {
+    roots: [
+      { root: join(cwd, '.goodvibes', 'skills'), origin: 'project-local' },
+      { root: join(cwd, '.goodvibes', GOODVIBES_AGENT_SURFACE_ROOT, 'skills'), origin: 'project-local' },
+      { root: join(homeDir, '.goodvibes', 'skills'), origin: 'global' },
+      { root: join(homeDir, '.goodvibes', GOODVIBES_AGENT_SURFACE_ROOT, 'skills'), origin: 'global' },
+    ],
+    markers: ['SKILL.md'],
+  };
+  const routines: DiscoveryKindDefinition = {
+    roots: [
+      { root: join(cwd, '.goodvibes', 'routines'), origin: 'project-local' },
+      { root: join(cwd, '.goodvibes', GOODVIBES_AGENT_SURFACE_ROOT, 'routines'), origin: 'project-local' },
+      { root: join(homeDir, '.goodvibes', 'routines'), origin: 'global' },
+      { root: join(homeDir, '.goodvibes', GOODVIBES_AGENT_SURFACE_ROOT, 'routines'), origin: 'global' },
+    ],
+    markers: ['ROUTINE.md', 'routine.md'],
+    frontmatterBodyKey: 'steps',
+  };
+
+  return {
+    personas: summarizeDefinition(personas, 4),
+    skills: summarizeDefinition(skills, 4),
+    routines: summarizeDefinition(routines, 4),
+  };
+}
+
+export function summarizeAgentBehaviorDiscovery(shellPaths: Pick<ShellPathService, 'workingDirectory' | 'homeDirectory'> | undefined): AgentBehaviorDiscoverySnapshot {
+  if (!shellPaths) return EMPTY_AGENT_BEHAVIOR_DISCOVERY_SNAPSHOT;
+  return definitions(shellPaths);
+}

package/src/agent/persona-discovery.ts

@@ -0,0 +1,117 @@
+import { promises as fsPromises } from 'node:fs';
+import { join } from 'node:path';
+import type { ShellPathService } from '@/runtime/index.ts';
+import { GOODVIBES_AGENT_SURFACE_ROOT } from '../config/surface.ts';
+
+export type PersonaOrigin = 'project-local' | 'global' | 'custom';
+
+export interface DiscoveredPersonaRecord {
+  readonly name: string;
+  readonly description: string;
+  readonly path: string;
+  readonly origin: PersonaOrigin;
+  readonly body: string;
+  readonly frontmatter: Record<string, string>;
+}
+
+const DIRECTORY_MARKERS: readonly string[] = ['PERSONA.md', 'persona.md', 'AGENT.md', 'agent.md'];
+
+function parseFrontmatter(content: string): Record<string, string> {
+  const match = content.match(/^---\n([\s\S]*?)\n---/);
+  if (!match) return {};
+  const result: Record<string, string> = {};
+  for (const line of match[1].split('\n')) {
+    const [key, ...rest] = line.split(':');
+    if (key && rest.length > 0) {
+      result[key.trim()] = rest.join(':').trim();
+    }
+  }
+  return result;
+}
+
+function getPersonaDirectories(cwd: string, homeDir: string): Array<{ root: string; origin: PersonaOrigin }> {
+  return [
+    { root: join(cwd, '.goodvibes', 'personas'), origin: 'project-local' },
+    { root: join(cwd, '.goodvibes', GOODVIBES_AGENT_SURFACE_ROOT, 'personas'), origin: 'project-local' },
+    { root: join(cwd, '.goodvibes', 'agents'), origin: 'project-local' },
+    { root: join(homeDir, '.goodvibes', 'personas'), origin: 'global' },
+    { root: join(homeDir, '.goodvibes', GOODVIBES_AGENT_SURFACE_ROOT, 'personas'), origin: 'global' },
+    { root: join(homeDir, '.goodvibes', 'agents'), origin: 'global' },
+  ];
+}
+
+async function readPersonaFile(path: string, origin: PersonaOrigin): Promise<DiscoveredPersonaRecord | null> {
+  let content = '';
+  try {
+    content = await fsPromises.readFile(path, 'utf-8');
+  } catch {
+    return null;
+  }
+
+  const frontmatter = parseFrontmatter(content);
+  const markdownBody = content.replace(/^---\n[\s\S]*?\n---\n?/, '').trim();
+  const body = (frontmatter.system_prompt ?? markdownBody).trim();
+  if (!body) return null;
+  const name = frontmatter.name ?? path.split(/[\\/]/).pop()?.replace(/\.md$/i, '') ?? 'persona';
+  const description = frontmatter.description ?? frontmatter.summary ?? frontmatter.title ?? '';
+
+  return {
+    name,
+    description,
+    path,
+    origin,
+    body,
+    frontmatter,
+  };
+}
+
+async function scanPersonaDirectory(root: string, origin: PersonaOrigin): Promise<DiscoveredPersonaRecord[]> {
+  let entries: string[] = [];
+  try {
+    entries = await fsPromises.readdir(root);
+  } catch {
+    return [];
+  }
+
+  const records: DiscoveredPersonaRecord[] = [];
+  for (const entry of entries.sort((a, b) => a.localeCompare(b))) {
+    if (entry.endsWith('.md')) {
+      const record = await readPersonaFile(join(root, entry), origin);
+      if (record) records.push(record);
+      continue;
+    }
+
+    for (const marker of DIRECTORY_MARKERS) {
+      const record = await readPersonaFile(join(root, entry, marker), origin);
+      if (record) {
+        records.push(record);
+        break;
+      }
+    }
+  }
+
+  return records;
+}
+
+export async function discoverPersonas(shellPaths: Pick<ShellPathService, 'workingDirectory' | 'homeDirectory'>): Promise<DiscoveredPersonaRecord[]> {
+  const seen = new Set<string>();
+  const records: DiscoveredPersonaRecord[] = [];
+
+  for (const { root, origin } of getPersonaDirectories(shellPaths.workingDirectory, shellPaths.homeDirectory)) {
+    for (const record of await scanPersonaDirectory(root, origin)) {
+      const key = record.name.toLowerCase();
+      if (seen.has(key)) continue;
+      seen.add(key);
+      records.push(record);
+    }
+  }
+
+  return records.sort((a, b) => {
+    const originRank = a.origin === b.origin
+      ? 0
+      : a.origin === 'project-local'
+        ? -1
+        : 1;
+    return originRank || a.name.localeCompare(b.name);
+  });
+}

package/src/agent/routine-discovery.ts

@@ -0,0 +1,115 @@
+import { promises as fsPromises } from 'node:fs';
+import { join } from 'node:path';
+import type { ShellPathService } from '@/runtime/index.ts';
+import { GOODVIBES_AGENT_SURFACE_ROOT } from '../config/surface.ts';
+
+export type RoutineOrigin = 'project-local' | 'global' | 'custom';
+
+export interface DiscoveredRoutineRecord {
+  readonly name: string;
+  readonly description: string;
+  readonly path: string;
+  readonly origin: RoutineOrigin;
+  readonly steps: string;
+  readonly frontmatter: Record<string, string>;
+}
+
+const DIRECTORY_MARKERS: readonly string[] = ['ROUTINE.md', 'routine.md'];
+
+function parseFrontmatter(content: string): Record<string, string> {
+  const match = content.match(/^---\n([\s\S]*?)\n---/);
+  if (!match) return {};
+  const result: Record<string, string> = {};
+  for (const line of match[1].split('\n')) {
+    const [key, ...rest] = line.split(':');
+    if (key && rest.length > 0) {
+      result[key.trim()] = rest.join(':').trim();
+    }
+  }
+  return result;
+}
+
+function getRoutineDirectories(cwd: string, homeDir: string): Array<{ root: string; origin: RoutineOrigin }> {
+  return [
+    { root: join(cwd, '.goodvibes', 'routines'), origin: 'project-local' },
+    { root: join(cwd, '.goodvibes', GOODVIBES_AGENT_SURFACE_ROOT, 'routines'), origin: 'project-local' },
+    { root: join(homeDir, '.goodvibes', 'routines'), origin: 'global' },
+    { root: join(homeDir, '.goodvibes', GOODVIBES_AGENT_SURFACE_ROOT, 'routines'), origin: 'global' },
+  ];
+}
+
+async function readRoutineFile(path: string, origin: RoutineOrigin): Promise<DiscoveredRoutineRecord | null> {
+  let content = '';
+  try {
+    content = await fsPromises.readFile(path, 'utf-8');
+  } catch {
+    return null;
+  }
+
+  const frontmatter = parseFrontmatter(content);
+  const markdownBody = content.replace(/^---\n[\s\S]*?\n---\n?/, '').trim();
+  const steps = (frontmatter.steps ?? markdownBody).trim();
+  if (!steps) return null;
+  const name = frontmatter.name ?? path.split(/[\\/]/).pop()?.replace(/\.md$/i, '') ?? 'routine';
+  const description = frontmatter.description ?? frontmatter.summary ?? frontmatter.title ?? '';
+
+  return {
+    name,
+    description,
+    path,
+    origin,
+    steps,
+    frontmatter,
+  };
+}
+
+async function scanRoutineDirectory(root: string, origin: RoutineOrigin): Promise<DiscoveredRoutineRecord[]> {
+  let entries: string[] = [];
+  try {
+    entries = await fsPromises.readdir(root);
+  } catch {
+    return [];
+  }
+
+  const records: DiscoveredRoutineRecord[] = [];
+  for (const entry of entries.sort((a, b) => a.localeCompare(b))) {
+    if (entry.endsWith('.md')) {
+      const record = await readRoutineFile(join(root, entry), origin);
+      if (record) records.push(record);
+      continue;
+    }
+
+    for (const marker of DIRECTORY_MARKERS) {
+      const record = await readRoutineFile(join(root, entry, marker), origin);
+      if (record) {
+        records.push(record);
+        break;
+      }
+    }
+  }
+
+  return records;
+}
+
+export async function discoverRoutines(shellPaths: Pick<ShellPathService, 'workingDirectory' | 'homeDirectory'>): Promise<DiscoveredRoutineRecord[]> {
+  const seen = new Set<string>();
+  const records: DiscoveredRoutineRecord[] = [];
+
+  for (const { root, origin } of getRoutineDirectories(shellPaths.workingDirectory, shellPaths.homeDirectory)) {
+    for (const record of await scanRoutineDirectory(root, origin)) {
+      const key = record.name.toLowerCase();
+      if (seen.has(key)) continue;
+      seen.add(key);
+      records.push(record);
+    }
+  }
+
+  return records.sort((a, b) => {
+    const originRank = a.origin === b.origin
+      ? 0
+      : a.origin === 'project-local'
+        ? -1
+        : 1;
+    return originRank || a.name.localeCompare(b.name);
+  });
+}