autohand-cli 0.9.1 → 0.9.2

package/dist/{chunk-PGFLPURU.js → chunk-2BPIR7LA.js}

@@ -1,6 +1,6 @@
 import {
   AUTOHAND_PATHS
-} from "./chunk-SHRLFX6F.js";
+} from "./chunk-PG2JIU5M.js";
 
 // src/session/SessionManager.ts
 import fs from "fs-extra";
@@ -42,7 +42,8 @@ var SessionManager = class {
     return session;
   }
   async loadSession(sessionId) {
-    const sessionDir = path.join(this.sessionsDir, sessionId);
+    const resolvedSessionId = await this.resolveSessionReference(sessionId);
+    const sessionDir = path.join(this.sessionsDir, resolvedSessionId);
     if (!await fs.pathExists(sessionDir)) {
       throw new Error(`Session not found: ${sessionId}`);
     }
@@ -53,6 +54,72 @@ var SessionManager = class {
     this.currentSession = session;
     return session;
   }
+  async resolveSessionReference(reference) {
+    const trimmed = reference.trim();
+    if (!trimmed) {
+      throw new Error("Session reference is required");
+    }
+    const asPath = path.resolve(trimmed);
+    if (await fs.pathExists(asPath)) {
+      const stat = await fs.stat(asPath);
+      const sessionDir = stat.isDirectory() ? asPath : path.dirname(asPath);
+      const metadataPath = path.join(sessionDir, "metadata.json");
+      if (await fs.pathExists(metadataPath)) {
+        const metadata = await fs.readJson(metadataPath);
+        return metadata.sessionId;
+      }
+    }
+    const directDir = path.join(this.sessionsDir, trimmed);
+    if (await fs.pathExists(path.join(directDir, "metadata.json"))) {
+      return trimmed;
+    }
+    await this.loadIndex();
+    const candidates = this.index?.sessions.filter((session) => session.id.startsWith(trimmed)) ?? [];
+    if (candidates.length === 1) {
+      return candidates[0].id;
+    }
+    if (candidates.length > 1) {
+      throw new Error(`Ambiguous session reference: ${reference}`);
+    }
+    throw new Error(`Session not found: ${reference}`);
+  }
+  async branchSession(sourceReference, options) {
+    const sourceSessionId = await this.resolveSessionReference(sourceReference);
+    const sourceSession = await this.loadSession(sourceSessionId);
+    const sourceMessages = sourceSession.getMessages();
+    const copiedMessages = selectBranchMessages(sourceMessages, options);
+    const createdAt = (/* @__PURE__ */ new Date()).toISOString();
+    const sessionId = this.generateSessionId();
+    const sessionDir = path.join(this.sessionsDir, sessionId);
+    await fs.ensureDir(sessionDir);
+    const metadata = {
+      ...sourceSession.metadata,
+      sessionId,
+      createdAt,
+      lastActiveAt: createdAt,
+      closedAt: void 0,
+      messageCount: copiedMessages.length,
+      status: "active",
+      exitCode: void 0,
+      branch: {
+        type: options.type,
+        sourceSessionId,
+        sourceMessageIndex: options.type === "fork" && copiedMessages.length > 0 ? copiedMessages.length - 1 : void 0,
+        sourceUserMessageOrdinal: options.type === "fork" ? options.userMessageOrdinal : void 0,
+        createdAt
+      }
+    };
+    const session = new Session(sessionDir, metadata);
+    await session.replaceMessages(copiedMessages);
+    const sourceState = sourceSession.getState();
+    if (sourceState) {
+      await session.updateState(sourceState);
+    }
+    await session.save();
+    this.currentSession = session;
+    await this.addToIndex(session.metadata);
+    return session;
+  }
   async listSessions(filter) {
     await this.loadIndex();
     if (!this.index) return [];
@@ -105,7 +172,16 @@ var SessionManager = class {
   async loadIndex() {
     const indexPath = path.join(this.sessionsDir, "index.json");
     if (await fs.pathExists(indexPath)) {
-      this.index = await fs.readJson(indexPath);
+      try {
+        this.index = await fs.readJson(indexPath);
+      } catch (error) {
+        const backupPath = `${indexPath}.corrupt-${Date.now()}`;
+        await fs.move(indexPath, backupPath, { overwrite: true });
+        const reason = error instanceof Error ? error.message : String(error);
+        console.warn(`Session index was corrupt and has been reset: ${reason}. Backup saved to ${backupPath}`);
+        this.index = { sessions: [], byProject: {} };
+        await this.saveIndex();
+      }
     } else {
       this.index = { sessions: [], byProject: {} };
     }
@@ -121,7 +197,12 @@ var SessionManager = class {
       id: metadata.sessionId,
       projectPath: metadata.projectPath,
       createdAt: metadata.createdAt,
-      summary: metadata.summary
+      summary: metadata.summary,
+      importedFrom: metadata.importedFrom ? {
+        source: metadata.importedFrom.source,
+        originalId: metadata.importedFrom.originalId
+      } : void 0,
+      branch: metadata.branch
     });
     if (!this.index.byProject[metadata.projectPath]) {
       this.index.byProject[metadata.projectPath] = [];
@@ -134,10 +215,31 @@ var SessionManager = class {
     const session = this.index.sessions.find((s) => s.id === metadata.sessionId);
     if (session) {
       session.summary = metadata.summary;
+      session.branch = metadata.branch;
     }
     await this.saveIndex();
   }
 };
+function selectBranchMessages(messages, options) {
+  if (options.type === "clone" || options.userMessageOrdinal === void 0) {
+    return [...messages];
+  }
+  if (!Number.isInteger(options.userMessageOrdinal) || options.userMessageOrdinal < 1) {
+    throw new Error("Fork message must be a positive user-message number");
+  }
+  let seenUserMessages = 0;
+  const selected = [];
+  for (const message of messages) {
+    selected.push(message);
+    if (message.role === "user") {
+      seenUserMessages += 1;
+      if (seenUserMessages === options.userMessageOrdinal) {
+        return selected;
+      }
+    }
+  }
+  throw new Error(`User message ${options.userMessageOrdinal} not found`);
+}
 var Session = class {
   sessionDir;
   metadata;
@@ -147,24 +249,39 @@ var Session = class {
     this.sessionDir = sessionDir;
     this.metadata = metadata;
   }
+  async ensureSessionDir() {
+    await fs.ensureDir(this.sessionDir);
+  }
   async append(message) {
     this.messages.push(message);
     this.metadata.messageCount = this.messages.length;
     this.metadata.lastActiveAt = (/* @__PURE__ */ new Date()).toISOString();
+    await this.ensureSessionDir();
     const conversationPath = path.join(this.sessionDir, "conversation.jsonl");
     await fs.appendFile(conversationPath, JSON.stringify(message) + "\n");
     await this.save();
   }
   async appendTransient(message) {
+    await this.ensureSessionDir();
     const conversationPath = path.join(this.sessionDir, "conversation.jsonl");
     await fs.appendFile(conversationPath, JSON.stringify(message) + "\n");
   }
+  async replaceMessages(messages) {
+    this.messages = [...messages];
+    this.metadata.messageCount = this.messages.length;
+    const conversationPath = path.join(this.sessionDir, "conversation.jsonl");
+    const content = this.messages.map((message) => JSON.stringify(message)).join("\n");
+    await fs.writeFile(conversationPath, content ? `${content}
+` : "");
+  }
   async updateState(state) {
     this.state = state;
+    await this.ensureSessionDir();
     const statePath = path.join(this.sessionDir, "state.json");
     await fs.writeJson(statePath, state, { spaces: 2 });
   }
   async save() {
+    await this.ensureSessionDir();
     const metadataPath = path.join(this.sessionDir, "metadata.json");
     await fs.writeJson(metadataPath, this.metadata, { spaces: 2 });
   }

package/dist/{chunk-AOKXYGBQ.cjs → chunk-2NY7OHBF.cjs}

@@ -1,28 +1,29 @@
 "use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { newObj[key] = obj[key]; } } } newObj.default = obj; return newObj; } } function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } } function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; }
 
 
-var _chunkHG3ZASBHcjs = require('./chunk-HG3ZASBH.cjs');
 
+var _chunkR75AWII3cjs = require('./chunk-R75AWII3.cjs');
 
-var _chunkS5JNQIGLcjs = require('./chunk-S5JNQIGL.cjs');
 
+var _chunkGYLGCR6Fcjs = require('./chunk-GYLGCR6F.cjs');
 
-var _chunkCO2AADYUcjs = require('./chunk-CO2AADYU.cjs');
 
+var _chunkAZKOIF2Gcjs = require('./chunk-AZKOIF2G.cjs');
 
-var _chunkX5P6QQOBcjs = require('./chunk-X5P6QQOB.cjs');
 
+var _chunkCNQKIWIScjs = require('./chunk-CNQKIWIS.cjs');
 
-var _chunkKASXKDF2cjs = require('./chunk-KASXKDF2.cjs');
 
+var _chunk3JURXAL6cjs = require('./chunk-3JURXAL6.cjs');
 
-var _chunkSY2P3Z5Wcjs = require('./chunk-SY2P3Z5W.cjs');
+
+var _chunkRJCZLFHEcjs = require('./chunk-RJCZLFHE.cjs');
 
 // src/commands/login.ts
 var _chalk = require('chalk'); var _chalk2 = _interopRequireDefault(_chalk);
 var metadata = {
   command: "/login",
-  description: _chunkSY2P3Z5Wcjs.t.call(void 0, "commands.login.description"),
+  description: _chunkRJCZLFHEcjs.t.call(void 0, "commands.login.description"),
   implemented: true
 };
 async function openBrowser(url) {
@@ -69,33 +70,33 @@ function sleep(ms) {
 async function login(ctx) {
   const config = ctx.config;
   if (_optionalChain([config, 'optionalAccess', _ => _.auth, 'optionalAccess', _2 => _2.token]) && _optionalChain([config, 'optionalAccess', _3 => _3.auth, 'optionalAccess', _4 => _4.user])) {
-    const result = await _chunkS5JNQIGLcjs.safePrompt.call(void 0, {
+    const result = await _chunkGYLGCR6Fcjs.safePrompt.call(void 0, {
       type: "confirm",
       name: "continueLogin",
       message: `Already logged in as ${_chalk2.default.cyan(config.auth.user.email)}. Log in with a different account?`,
       initial: false
     });
     if (!result || !result.continueLogin) {
-      console.log(_chalk2.default.gray(_chunkSY2P3Z5Wcjs.t.call(void 0, "commands.login.cancelled")));
+      console.log(_chalk2.default.gray(_chunkRJCZLFHEcjs.t.call(void 0, "commands.login.cancelled")));
       return null;
     }
   }
-  const authClient = _chunkCO2AADYUcjs.getAuthClient.call(void 0, );
+  const authClient = _chunkAZKOIF2Gcjs.getAuthClient.call(void 0, );
   console.log(_chalk2.default.gray("Initiating authentication..."));
   const initResult = await authClient.initiateDeviceAuth();
   if (!initResult.success || !initResult.deviceCode || !initResult.userCode) {
-    console.log(_chalk2.default.red(_chunkSY2P3Z5Wcjs.t.call(void 0, "commands.login.failed", { error: initResult.error || "Unknown error" })));
+    console.log(_chalk2.default.red(_chunkRJCZLFHEcjs.t.call(void 0, "commands.login.failed", { error: initResult.error || "Unknown error" })));
     return null;
   }
   console.log();
   console.log(_chalk2.default.bold("To sign in, visit:"));
-  console.log(_chalk2.default.cyan.underline(initResult.verificationUriComplete || `${_chunkKASXKDF2cjs.AUTH_CONFIG.authorizationUrl}?code=${initResult.userCode}`));
+  console.log(_chalk2.default.cyan.underline(initResult.verificationUriComplete || `${_chunk3JURXAL6cjs.AUTH_CONFIG.authorizationUrl}?code=${initResult.userCode}`));
   console.log();
   console.log(_chalk2.default.gray("Or enter this code manually:"));
   console.log(_chalk2.default.bold.yellow(`  ${initResult.userCode}`));
   console.log();
   const browserOpened = await openBrowser(
-    initResult.verificationUriComplete || `${_chunkKASXKDF2cjs.AUTH_CONFIG.authorizationUrl}?code=${initResult.userCode}`
+    initResult.verificationUriComplete || `${_chunk3JURXAL6cjs.AUTH_CONFIG.authorizationUrl}?code=${initResult.userCode}`
   );
   if (browserOpened) {
     console.log(_chalk2.default.gray("Browser opened. Complete the login in your browser."));
@@ -106,8 +107,8 @@ async function login(ctx) {
   console.log(_chalk2.default.gray("Waiting for authorization..."));
   console.log(_chalk2.default.gray("(Press Ctrl+C to cancel)"));
   const startTime = Date.now();
-  const timeout = _chunkKASXKDF2cjs.AUTH_CONFIG.authTimeout;
-  const pollInterval = initResult.interval ? initResult.interval * 1e3 : _chunkKASXKDF2cjs.AUTH_CONFIG.pollInterval;
+  const timeout = _chunk3JURXAL6cjs.AUTH_CONFIG.authTimeout;
+  const pollInterval = initResult.interval ? initResult.interval * 1e3 : _chunk3JURXAL6cjs.AUTH_CONFIG.pollInterval;
   let dots = 0;
   const maxDots = 3;
   while (Date.now() - startTime < timeout) {
@@ -117,7 +118,7 @@ async function login(ctx) {
     const pollResult = await authClient.pollDeviceAuth(initResult.deviceCode);
     if (pollResult.status === "authorized" && pollResult.token && pollResult.user) {
       process.stdout.write("\r" + " ".repeat(20) + "\r");
-      const expiresAt = new Date(Date.now() + _chunkKASXKDF2cjs.AUTH_CONFIG.sessionExpiryDays * 24 * 60 * 60 * 1e3).toISOString();
+      const expiresAt = new Date(Date.now() + _chunk3JURXAL6cjs.AUTH_CONFIG.sessionExpiryDays * 24 * 60 * 60 * 1e3).toISOString();
       const updatedConfig = {
         ...config,
         auth: {
@@ -126,9 +127,9 @@ async function login(ctx) {
           expiresAt
         }
       };
-      await _chunkX5P6QQOBcjs.saveConfig.call(void 0, updatedConfig);
+      await _chunkCNQKIWIScjs.saveConfig.call(void 0, updatedConfig);
       console.log();
-      console.log(_chalk2.default.green(_chunkSY2P3Z5Wcjs.t.call(void 0, "commands.login.success", { email: pollResult.user.name || pollResult.user.email })));
+      console.log(_chalk2.default.green(_chunkRJCZLFHEcjs.t.call(void 0, "commands.login.success", { email: pollResult.user.name || pollResult.user.email })));
       console.log();
       if (process.stdin.isTTY && process.stdout.isTTY) {
         await checkAndRestoreSyncData(pollResult.token, pollResult.user.id, updatedConfig);
@@ -152,11 +153,11 @@ async function login(ctx) {
 }
 async function checkAndRestoreSyncData(token, userId, config) {
   try {
-    const syncService = _chunkHG3ZASBHcjs.createSyncService.call(void 0, {
+    const syncService = _chunkR75AWII3cjs.createSyncService.call(void 0, {
       authToken: token,
       userId,
       config: {
-        ..._chunkHG3ZASBHcjs.DEFAULT_SYNC_CONFIG,
+        ..._chunkR75AWII3cjs.DEFAULT_SYNC_CONFIG,
         ...config.sync,
         enabled: true
       }
@@ -167,13 +168,21 @@ async function checkAndRestoreSyncData(token, userId, config) {
     if (!remoteManifest || remoteManifest.files.length === 0) {
       return;
     }
-    const fileCount = remoteManifest.files.length;
-    const totalSize = remoteManifest.files.reduce((sum, f) => sum + f.size, 0);
+    const memoryFiles = remoteManifest.files.filter((file) => _chunkR75AWII3cjs.isMemorySyncPath.call(void 0, file.path));
+    if (memoryFiles.length > 0) {
+      await restoreMemorySyncData(syncService, memoryFiles);
+    }
+    const consentRequiredFiles = remoteManifest.files.filter((file) => !_chunkR75AWII3cjs.isMemorySyncPath.call(void 0, file.path));
+    if (consentRequiredFiles.length === 0) {
+      return;
+    }
+    const fileCount = consentRequiredFiles.length;
+    const totalSize = consentRequiredFiles.reduce((sum, f) => sum + f.size, 0);
     const sizeStr = formatSize(totalSize);
     console.log(_chalk2.default.cyan(`Found cloud sync data (${fileCount} files, ${sizeStr})`));
-    console.log(_chalk2.default.gray("This includes your settings, agents, skills, and memory."));
+    console.log(_chalk2.default.gray("This includes your settings, agents, skills, sessions, and hooks."));
     console.log();
-    const result = await _chunkS5JNQIGLcjs.safePrompt.call(void 0, {
+    const result = await _chunkGYLGCR6Fcjs.safePrompt.call(void 0, {
       type: "confirm",
       name: "restore",
       message: "Would you like to restore your settings from the cloud?",
@@ -201,6 +210,12 @@ async function checkAndRestoreSyncData(token, userId, config) {
     console.log(_chalk2.default.gray("Could not check cloud sync data."));
   }
 }
+async function restoreMemorySyncData(syncService, memoryFiles) {
+  try {
+    await syncService.forceDownloadPaths(memoryFiles.map((file) => file.path));
+  } catch (e4) {
+  }
+}
 async function cancellableOperation(fn) {
   const stdin = process.stdin;
   const wasRaw = stdin.isRaw;
@@ -211,7 +226,7 @@ async function cancellableOperation(fn) {
       if (stdin.isTTY && stdin.setRawMode) {
         try {
           stdin.setRawMode(_nullishCoalesce(wasRaw, () => ( false)));
-        } catch (e4) {
+        } catch (e5) {
         }
       }
     };
@@ -227,7 +242,7 @@ async function cancellableOperation(fn) {
     if (stdin.isTTY && stdin.setRawMode) {
       try {
         stdin.setRawMode(true);
-      } catch (e5) {
+      } catch (e6) {
       }
     }
     stdin.on("data", onData);

package/dist/chunk-2WUNHTXL.js

@@ -0,0 +1,303 @@
+// src/onboarding/agentsGenerator.ts
+var AgentsGenerator = class {
+  /**
+   * Generate AGENTS.md content
+   */
+  generateContent(info, options) {
+    const sections = [];
+    sections.push("# AGENTS.md");
+    sections.push("");
+    sections.push("This file helps Autohand understand how to work with this project.");
+    sections.push("");
+    sections.push(this.generateProjectOverview(info));
+    if (info.packageManager) {
+      sections.push(this.generateCommandsSection(info));
+    }
+    if (info.testFramework) {
+      sections.push(this.generateTestingSection(info));
+    }
+    if (info.framework) {
+      const frameworkSection = this.generateFrameworkSection(info);
+      if (frameworkSection) {
+        sections.push(frameworkSection);
+      }
+    }
+    sections.push(this.generateInstructionSourcesSection());
+    sections.push(this.generateCodeStyleSection(info));
+    sections.push(this.generateConstraintsSection());
+    if (options?.customSections) {
+      for (const section of options.customSections) {
+        sections.push(`## ${section.title}`);
+        sections.push("");
+        sections.push(section.content);
+        sections.push("");
+      }
+    }
+    return sections.join("\n");
+  }
+  /**
+   * Generate project overview section
+   */
+  generateProjectOverview(info) {
+    const lines = [];
+    lines.push("## Project Overview");
+    lines.push("");
+    if (info.language) {
+      lines.push(`- **Language**: ${info.language}`);
+    }
+    if (info.framework) {
+      lines.push(`- **Framework**: ${info.framework}`);
+    }
+    if (info.packageManager) {
+      lines.push(`- **Package Manager**: ${info.packageManager}`);
+    }
+    if (info.testFramework) {
+      lines.push(`- **Test Framework**: ${info.testFramework}`);
+    }
+    if (info.buildTool) {
+      lines.push(`- **Build Tool**: ${info.buildTool}`);
+    }
+    lines.push("");
+    return lines.join("\n");
+  }
+  /**
+   * Generate commands section based on package manager
+   */
+  generateCommandsSection(info) {
+    const lines = [];
+    lines.push("## Commands");
+    lines.push("");
+    const pm = info.packageManager;
+    if (info.language === "Rust") {
+      lines.push("- **Build**: `cargo build`");
+      lines.push("- **Build (release)**: `cargo build --release`");
+      lines.push("- **Run**: `cargo run`");
+      lines.push("- **Test**: `cargo test`");
+      lines.push("- **Check**: `cargo check`");
+      lines.push("- **Format**: `cargo fmt`");
+      lines.push("- **Lint**: `cargo clippy`");
+    } else if (info.language === "Go") {
+      lines.push("- **Build**: `go build`");
+      lines.push("- **Run**: `go run .`");
+      lines.push("- **Test**: `go test ./...`");
+      lines.push("- **Format**: `go fmt ./...`");
+      lines.push("- **Vet**: `go vet ./...`");
+    } else if (info.language === "Python") {
+      if (pm === "poetry") {
+        lines.push("- **Install**: `poetry install`");
+        lines.push("- **Run**: `poetry run python main.py`");
+        lines.push("- **Add dependency**: `poetry add <package>`");
+        if (info.testFramework) {
+          lines.push(`- **Test**: \`poetry run pytest\``);
+        }
+      } else if (pm === "pipenv") {
+        lines.push("- **Install**: `pipenv install`");
+        lines.push("- **Run**: `pipenv run python main.py`");
+        if (info.testFramework) {
+          lines.push(`- **Test**: \`pipenv run pytest\``);
+        }
+      } else {
+        lines.push("- **Install**: `pip install -r requirements.txt`");
+        lines.push("- **Run**: `python main.py`");
+        if (info.testFramework) {
+          lines.push(`- **Test**: \`pytest\``);
+        }
+      }
+    } else {
+      const run = pm === "npm" ? "npm run" : pm;
+      const install = pm === "npm" ? "npm install" : `${pm} install`;
+      lines.push(`- **Install**: \`${install}\``);
+      lines.push(`- **Dev**: \`${run} dev\``);
+      lines.push(`- **Build**: \`${run} build\``);
+      if (info.testFramework) {
+        lines.push(`- **Test**: \`${run} test\``);
+      }
+      if (info.linter) {
+        lines.push(`- **Lint**: \`${run} lint\``);
+      }
+      if (info.formatter) {
+        lines.push(`- **Format**: \`${run} format\``);
+      }
+    }
+    lines.push("");
+    return lines.join("\n");
+  }
+  /**
+   * Generate testing section
+   */
+  generateTestingSection(info) {
+    const lines = [];
+    lines.push("## Testing");
+    lines.push("");
+    lines.push(`This project uses **${info.testFramework}** for testing.`);
+    lines.push("");
+    lines.push("- Write tests for new features before implementation");
+    lines.push("- Run tests before committing changes");
+    lines.push("- Aim for good test coverage on critical paths");
+    if (info.testFramework === "Vitest" || info.testFramework === "Jest") {
+      lines.push("- Use `describe` and `it` blocks to organize tests");
+      lines.push("- Mock external dependencies when appropriate");
+    } else if (info.testFramework === "pytest") {
+      lines.push("- Use fixtures for shared test setup");
+      lines.push("- Use `pytest.mark` for test categorization");
+    } else if (info.testFramework === "Playwright" || info.testFramework === "Cypress") {
+      lines.push("- Write E2E tests for critical user flows");
+      lines.push("- Keep selectors stable and meaningful");
+    }
+    lines.push("");
+    return lines.join("\n");
+  }
+  /**
+   * Generate framework-specific section
+   */
+  generateFrameworkSection(info) {
+    const lines = [];
+    switch (info.framework) {
+      case "Next.js":
+        lines.push("## Next.js Guidelines");
+        lines.push("");
+        lines.push("- Use the App Router for new pages (`app/` directory)");
+        lines.push("- Prefer Server Components by default");
+        lines.push('- Use `"use client"` only when needed for interactivity');
+        lines.push("- Keep API routes in `app/api/`");
+        lines.push("- Use `next/image` for optimized images");
+        lines.push("- Use `next/link` for client-side navigation");
+        break;
+      case "React":
+        lines.push("## React Guidelines");
+        lines.push("");
+        lines.push("- Use functional components with hooks");
+        lines.push("- Keep components small and focused");
+        lines.push("- Use custom hooks to share logic");
+        lines.push("- Prefer composition over inheritance");
+        lines.push("- Use TypeScript interfaces for props");
+        break;
+      case "Vue":
+        lines.push("## Vue Guidelines");
+        lines.push("");
+        lines.push("- Use Composition API for new components");
+        lines.push("- Keep components in single-file format (.vue)");
+        lines.push("- Use composables to share logic");
+        break;
+      case "Express":
+        lines.push("## Express Guidelines");
+        lines.push("");
+        lines.push("- Use middleware for cross-cutting concerns");
+        lines.push("- Keep route handlers thin, delegate to services");
+        lines.push("- Use async/await with proper error handling");
+        lines.push("- Validate request input before processing");
+        break;
+      case "FastAPI":
+        lines.push("## FastAPI Guidelines");
+        lines.push("");
+        lines.push("- Use Pydantic models for request/response validation");
+        lines.push("- Use dependency injection for shared resources");
+        lines.push("- Keep endpoints in organized routers");
+        lines.push("- Use async functions for I/O operations");
+        break;
+      case "Django":
+        lines.push("## Django Guidelines");
+        lines.push("");
+        lines.push("- Follow Django project structure conventions");
+        lines.push("- Use class-based views where appropriate");
+        lines.push("- Keep business logic in models or services");
+        lines.push("- Use Django ORM for database operations");
+        break;
+      case "Flask":
+        lines.push("## Flask Guidelines");
+        lines.push("");
+        lines.push("- Use blueprints to organize routes");
+        lines.push("- Keep route handlers focused");
+        lines.push("- Use Flask extensions for common functionality");
+        break;
+      case "NestJS":
+        lines.push("## NestJS Guidelines");
+        lines.push("");
+        lines.push("- Follow module-based architecture");
+        lines.push("- Use dependency injection");
+        lines.push("- Use decorators for metadata");
+        lines.push("- Keep controllers thin, services fat");
+        break;
+      default:
+        return null;
+    }
+    lines.push("");
+    return lines.join("\n");
+  }
+  /**
+   * Generate instruction sources section
+   */
+  generateInstructionSourcesSection() {
+    const lines = [];
+    lines.push("## Instruction Sources");
+    lines.push("");
+    lines.push("- Check saved memories and preferences before implementation work.");
+    lines.push("- Follow this AGENTS.md file for repository-specific guidance.");
+    lines.push("- AGENTS.md takes precedence over CLAUDE.md when both files provide instructions.");
+    lines.push("");
+    return lines.join("\n");
+  }
+  /**
+   * Generate code style section
+   */
+  generateCodeStyleSection(info) {
+    const lines = [];
+    lines.push("## Code Style");
+    lines.push("");
+    if (info.language === "TypeScript") {
+      lines.push("- Use strict TypeScript settings");
+      lines.push("- Define types/interfaces for data structures");
+      lines.push("- Avoid `any` type - use `unknown` if type is truly unknown");
+      lines.push("- Use type inference where obvious");
+    } else if (info.language === "Python") {
+      lines.push("- Follow PEP 8 style guidelines");
+      lines.push("- Use type hints for function signatures");
+      lines.push("- Use docstrings for public functions");
+    } else if (info.language === "Rust") {
+      lines.push("- Follow Rust naming conventions (snake_case for functions)");
+      lines.push("- Use descriptive error types");
+      lines.push("- Prefer `Result` over panicking");
+    } else if (info.language === "Go") {
+      lines.push("- Follow Go idioms and conventions");
+      lines.push("- Use short variable names in small scopes");
+      lines.push("- Handle errors explicitly");
+    }
+    lines.push("- Follow existing patterns in the codebase");
+    lines.push("- Use meaningful variable and function names");
+    lines.push("- Add comments for complex logic");
+    lines.push("- Keep functions focused and small");
+    if (info.linter) {
+      lines.push(`- Run **${info.linter}** before committing`);
+    }
+    if (info.formatter) {
+      lines.push(`- Format code with **${info.formatter}**`);
+    }
+    lines.push("");
+    return lines.join("\n");
+  }
+  /**
+   * Generate constraints section
+   */
+  generateConstraintsSection() {
+    const lines = [];
+    lines.push("## Constraints");
+    lines.push("");
+    lines.push("- Do not modify files outside the project directory");
+    lines.push("- Ask before making breaking changes");
+    lines.push("- Prefer editing existing files over creating new ones");
+    lines.push("- Do not delete files without confirmation");
+    lines.push("- Keep dependencies minimal - avoid adding new ones without good reason");
+    lines.push("- Do not commit sensitive data (API keys, secrets, credentials)");
+    lines.push("");
+    return lines.join("\n");
+  }
+};
+
+export {
+  AgentsGenerator
+};
+/**
+ * @license
+ * Copyright 2025 Autohand AI LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */