aiyou-dev 3.5.15

package/v3/@aiyou-dev/cli/dist/src/init/gemini-config-generator.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Gemini CLI Config Generator
+ * Generates/updates ~/.gemini/settings.json with aiyou-dev MCP server config.
+ */
+/**
+ * Add aiyou-dev MCP server to Gemini CLI config.
+ * Preserves existing settings and other MCP servers.
+ */
+export declare function configureGeminiMCP(opts?: {
+    force?: boolean;
+}): {
+    success: boolean;
+    message: string;
+    path: string;
+};
+/**
+ * Check if Gemini CLI is installed
+ */
+export declare function isGeminiCLIInstalled(): boolean;
+/**
+ * Check if aiyou-dev is already configured in Gemini CLI
+ */
+export declare function isGeminiConfigured(): boolean;
+//# sourceMappingURL=gemini-config-generator.d.ts.map

package/v3/@aiyou-dev/cli/dist/src/init/gemini-config-generator.js

@@ -0,0 +1,89 @@
+/**
+ * Gemini CLI Config Generator
+ * Generates/updates ~/.gemini/settings.json with aiyou-dev MCP server config.
+ */
+import { existsSync, readFileSync, writeFileSync, mkdirSync } from 'node:fs';
+import { join } from 'node:path';
+import os from 'os';
+function getGeminiConfigDir() {
+    return join(os.homedir(), '.gemini');
+}
+function getGeminiSettingsPath() {
+    return join(getGeminiConfigDir(), 'settings.json');
+}
+/**
+ * Read existing Gemini settings or return empty object
+ */
+function readGeminiSettings() {
+    const settingsPath = getGeminiSettingsPath();
+    if (existsSync(settingsPath)) {
+        try {
+            return JSON.parse(readFileSync(settingsPath, 'utf-8'));
+        }
+        catch {
+            return {};
+        }
+    }
+    return {};
+}
+/**
+ * Write Gemini settings to ~/.gemini/settings.json
+ */
+function writeGeminiSettings(settings) {
+    const configDir = getGeminiConfigDir();
+    if (!existsSync(configDir)) {
+        mkdirSync(configDir, { recursive: true });
+    }
+    writeFileSync(getGeminiSettingsPath(), JSON.stringify(settings, null, 2), 'utf-8');
+}
+/**
+ * Add aiyou-dev MCP server to Gemini CLI config.
+ * Preserves existing settings and other MCP servers.
+ */
+export function configureGeminiMCP(opts) {
+    const settings = readGeminiSettings();
+    const settingsPath = getGeminiSettingsPath();
+    if (!settings.mcpServers) {
+        settings.mcpServers = {};
+    }
+    // Check if already configured
+    if (settings.mcpServers['aiyou-dev'] && !opts?.force) {
+        return {
+            success: true,
+            message: 'aiyou-dev MCP server already configured in Gemini CLI',
+            path: settingsPath,
+        };
+    }
+    // Add aiyou-dev MCP server
+    settings.mcpServers['aiyou-dev'] = {
+        command: 'npx',
+        args: ['-y', 'aiyou-dev'],
+    };
+    writeGeminiSettings(settings);
+    return {
+        success: true,
+        message: 'Added aiyou-dev MCP server to Gemini CLI',
+        path: settingsPath,
+    };
+}
+/**
+ * Check if Gemini CLI is installed
+ */
+export function isGeminiCLIInstalled() {
+    try {
+        const { execSync } = require('child_process');
+        execSync('gemini --version', { stdio: 'ignore' });
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Check if aiyou-dev is already configured in Gemini CLI
+ */
+export function isGeminiConfigured() {
+    const settings = readGeminiSettings();
+    return !!settings.mcpServers?.['aiyou-dev'];
+}
+//# sourceMappingURL=gemini-config-generator.js.map

package/v3/@aiyou-dev/cli/dist/src/init/geminimd-generator.d.ts

@@ -0,0 +1,15 @@
+/**
+ * GEMINI.md Generator
+ * Generates Gemini CLI configuration with the same rules as CLAUDE.md
+ * but adapted for Gemini CLI's format and capabilities.
+ *
+ * Gemini CLI reads GEMINI.md for project-level instructions,
+ * similar to how Claude Code reads CLAUDE.md.
+ */
+import type { InitOptions, ClaudeMdTemplate } from './types.js';
+/**
+ * Generate GEMINI.md content based on init options and template.
+ */
+export declare function generateGeminiMd(options: InitOptions, template?: ClaudeMdTemplate): string;
+export default generateGeminiMd;
+//# sourceMappingURL=geminimd-generator.d.ts.map

package/v3/@aiyou-dev/cli/dist/src/init/geminimd-generator.js

@@ -0,0 +1,222 @@
+/**
+ * GEMINI.md Generator
+ * Generates Gemini CLI configuration with the same rules as CLAUDE.md
+ * but adapted for Gemini CLI's format and capabilities.
+ *
+ * Gemini CLI reads GEMINI.md for project-level instructions,
+ * similar to how Claude Code reads CLAUDE.md.
+ */
+// Gemini CLI does not support hooks or statusline, so those sections are omitted.
+// MCP tools work identically — same protocol, same tools.
+function behavioralRules() {
+    return `## Behavioral Rules (Always Enforced)
+
+- Do what has been asked; nothing more, nothing less
+- NEVER create files unless they're absolutely necessary for achieving your goal
+- ALWAYS prefer editing an existing file to creating a new one
+- NEVER proactively create documentation files (*.md) or README files unless explicitly requested
+- NEVER save working files, text/mds, or tests to the root folder
+- ALWAYS read a file before editing it
+- NEVER commit secrets, credentials, or .env files`;
+}
+function fileOrganization() {
+    return `## File Organization
+
+- NEVER save to root folder — use the directories below
+- Use \`/src\` for source code files
+- Use \`/tests\` for test files
+- Use \`/docs\` for documentation and markdown files
+- Use \`/config\` for configuration files
+- Use \`/scripts\` for utility scripts
+- Use \`/examples\` for example code`;
+}
+function projectArchitecture(options) {
+    return `## Project Architecture
+
+- Follow Domain-Driven Design with bounded contexts
+- Keep files under 500 lines
+- Use typed interfaces for all public APIs
+- Prefer TDD London School (mock-first) for new code
+- Use event sourcing for state changes
+- Ensure input validation at system boundaries
+
+### Project Config
+
+- **Topology**: ${options.runtime.topology}
+- **Max Agents**: ${options.runtime.maxAgents}
+- **Memory**: ${options.runtime.memoryBackend}
+- **HNSW**: ${options.runtime.enableHNSW ? 'Enabled' : 'Disabled'}
+- **Neural**: ${options.runtime.enableNeural ? 'Enabled' : 'Disabled'}`;
+}
+function buildAndTest() {
+    return `## Build & Test
+
+\`\`\`bash
+npm run build
+npm test
+npm run lint
+\`\`\`
+
+- ALWAYS run tests after making code changes
+- ALWAYS verify build succeeds before committing`;
+}
+function securityRules() {
+    return `## Security Rules
+
+- NEVER hardcode API keys, secrets, or credentials in source files
+- NEVER commit .env files or any file containing secrets
+- Always validate user input at system boundaries
+- Always sanitize file paths to prevent directory traversal`;
+}
+function mcpToolsReference() {
+    return `## MCP Tools (aiyou-dev)
+
+This project uses aiyou-dev as an MCP server. The following tools are available automatically:
+
+### Core Tools
+| Tool Prefix | Purpose |
+|-------------|---------|
+| \`agent_*\` | Agent lifecycle management |
+| \`swarm_*\` | Multi-agent swarm coordination |
+| \`memory_*\` | Vector memory with HNSW search |
+| \`task_*\` | Task creation and lifecycle |
+| \`session_*\` | Session state management |
+| \`gcc_*\` | Git Context Controller — structured agent memory |
+
+### GCC Tools (Context Management)
+| Tool | When to Use |
+|------|-------------|
+| \`gcc_init\` | First time setup |
+| \`gcc_commit\` | After completing meaningful work |
+| \`gcc_branch\` | Before experimental changes |
+| \`gcc_merge\` | When experiment succeeds/fails |
+| \`gcc_context\` | At session start (\`--full\`) or to check history |
+| \`gcc_log\` | At significant decision points |
+| \`gcc_status\` | Check current state |
+
+### Memory Tools
+\`\`\`
+memory_store   — Store key-value with optional namespace and tags
+memory_search  — Semantic vector search across stored entries
+memory_list    — List entries by namespace
+memory_retrieve — Get a specific entry by key
+\`\`\``;
+}
+function gccContextManagement() {
+    return `## Context Management (GCC) — Default Behavior
+
+GCC (Git Context Controller) provides structured, versioned memory. These are **mandatory behaviors**:
+
+### Session Start
+- ALWAYS use \`gcc_context\` with flag \`--full\` at the beginning of every session to recover prior context
+- If \`.aiyou-dev/gcc/\` does not exist, initialize with \`gcc_init\`
+
+### During Work
+- COMMIT after completing any coherent unit of work (function, bug fix, exploration phase)
+- Record OTA entries at significant decision points (not every action)
+- BRANCH before exploring risky or experimental alternatives
+- MERGE when an experiment succeeds; abandon when it fails
+
+### Session End
+- COMMIT final progress before ending the session
+- Include files touched and technical reasoning in every commit
+
+### Token Optimization
+- TOON format (\`@toon-format/toon\`) is used automatically for structured data (~40% fewer tokens)
+- Keep commit contributions concise but technically complete
+- OTA logs: observation + thought + action in 1-2 sentences each`;
+}
+function geminiMcpSetup() {
+    return `## MCP Server Setup
+
+Add to \`~/.gemini/settings.json\`:
+
+\`\`\`json
+{
+  "mcpServers": {
+    "aiyou-dev": {
+      "command": "npx",
+      "args": ["-y", "aiyou-dev"]
+    }
+  }
+}
+\`\`\`
+
+Or run: \`aiyou-dev init --target gemini\``;
+}
+// --- Template Composers ---
+const TEMPLATE_SECTIONS = {
+    minimal: [
+        behavioralRules,
+        fileOrganization,
+        projectArchitecture,
+        () => buildAndTest(),
+        () => securityRules(),
+        () => gccContextManagement(),
+        () => mcpToolsReference(),
+        () => geminiMcpSetup(),
+    ],
+    standard: [
+        behavioralRules,
+        fileOrganization,
+        projectArchitecture,
+        () => buildAndTest(),
+        () => securityRules(),
+        () => mcpToolsReference(),
+        () => gccContextManagement(),
+        () => geminiMcpSetup(),
+    ],
+    full: [
+        behavioralRules,
+        fileOrganization,
+        projectArchitecture,
+        () => buildAndTest(),
+        () => securityRules(),
+        () => mcpToolsReference(),
+        () => gccContextManagement(),
+        () => geminiMcpSetup(),
+    ],
+    security: [
+        behavioralRules,
+        fileOrganization,
+        projectArchitecture,
+        () => buildAndTest(),
+        () => securityRules(),
+        () => mcpToolsReference(),
+        () => gccContextManagement(),
+        () => geminiMcpSetup(),
+    ],
+    performance: [
+        behavioralRules,
+        fileOrganization,
+        projectArchitecture,
+        () => buildAndTest(),
+        () => securityRules(),
+        () => mcpToolsReference(),
+        () => gccContextManagement(),
+        () => geminiMcpSetup(),
+    ],
+    solo: [
+        behavioralRules,
+        fileOrganization,
+        projectArchitecture,
+        () => buildAndTest(),
+        () => securityRules(),
+        () => gccContextManagement(),
+        () => mcpToolsReference(),
+        () => geminiMcpSetup(),
+    ],
+};
+// --- Public API ---
+/**
+ * Generate GEMINI.md content based on init options and template.
+ */
+export function generateGeminiMd(options, template) {
+    const tmpl = template ?? options.runtime.claudeMdTemplate ?? 'standard';
+    const sections = TEMPLATE_SECTIONS[tmpl] ?? TEMPLATE_SECTIONS.standard;
+    const header = `# Gemini CLI Configuration — aiyou-dev\n`;
+    const body = sections.map(fn => fn(options)).join('\n\n');
+    return `${header}\n${body}\n`;
+}
+export default generateGeminiMd;
+//# sourceMappingURL=geminimd-generator.js.map

package/v3/@aiyou-dev/cli/dist/src/init/helpers-generator.d.ts

@@ -0,0 +1,60 @@
+/**
+ * Helpers Generator
+ * Creates utility scripts in .claude/helpers/
+ */
+import type { InitOptions } from './types.js';
+/**
+ * Generate pre-commit hook script
+ */
+export declare function generatePreCommitHook(): string;
+/**
+ * Generate post-commit hook script
+ */
+export declare function generatePostCommitHook(): string;
+/**
+ * Generate session manager script
+ */
+export declare function generateSessionManager(): string;
+/**
+ * Generate agent router script
+ */
+export declare function generateAgentRouter(): string;
+/**
+ * Generate memory helper script
+ */
+export declare function generateMemoryHelper(): string;
+/**
+ * Generate hook-handler.cjs (cross-platform hook dispatcher)
+ * This is the inline fallback when file copy from the package fails.
+ * Uses string concatenation instead of template literals to avoid escaping issues.
+ */
+export declare function generateHookHandler(): string;
+/**
+ * Generate a minimal intelligence.cjs stub for fallback installs.
+ * Provides the same API as the full intelligence.cjs but with simplified logic.
+ * Gets overwritten when source copy succeeds (full version has PageRank, Jaccard, etc.)
+ */
+export declare function generateIntelligenceStub(): string;
+/**
+ * Generate a minimal auto-memory-hook.mjs fallback for fresh installs.
+ * This ESM script handles import/sync/status commands gracefully when
+ * @aiyou-dev/memory is not installed. Gets overwritten when source copy succeeds.
+ */
+export declare function generateAutoMemoryHook(): string;
+/**
+ * Generate Windows PowerShell daemon manager
+ */
+export declare function generateWindowsDaemonManager(): string;
+/**
+ * Generate Windows batch file wrapper
+ */
+export declare function generateWindowsBatchWrapper(): string;
+/**
+ * Generate cross-platform session manager
+ */
+export declare function generateCrossPlatformSessionManager(): string;
+/**
+ * Generate all helper files
+ */
+export declare function generateHelpers(options: InitOptions): Record<string, string>;
+//# sourceMappingURL=helpers-generator.d.ts.map