amai 0.0.6 → 0.0.7

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (7) hide show
  1. package/dist/cli.cjs +249 -305
  2. package/dist/cli.js +244 -300
  3. package/dist/lib/daemon-entry.cjs +221 -277
  4. package/dist/lib/daemon-entry.js +217 -273
  5. package/dist/server.cjs +195 -248
  6. package/dist/server.js +192 -245
  7. package/package.json +1 -1
package/dist/cli.cjs CHANGED
@@ -2,12 +2,12 @@
2
2
  'use strict';
3
3
 
4
4
  var pc5 = require('picocolors');
5
- var WebSocket2 = require('ws');
5
+ var WebSocket = require('ws');
6
6
  var zod = require('zod');
7
7
  var promises = require('fs/promises');
8
- var path9 = require('path');
9
- var fs3 = require('fs');
10
- var os2 = require('os');
8
+ var path11 = require('path');
9
+ var fs4 = require('fs');
10
+ var os3 = require('os');
11
11
  var crypto = require('crypto');
12
12
  var child_process = require('child_process');
13
13
  var util = require('util');
@@ -21,20 +21,20 @@ var _documentCurrentScript = typeof document !== 'undefined' ? document.currentS
21
21
  function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
22
22
 
23
23
  var pc5__default = /*#__PURE__*/_interopDefault(pc5);
24
- var WebSocket2__default = /*#__PURE__*/_interopDefault(WebSocket2);
25
- var path9__default = /*#__PURE__*/_interopDefault(path9);
26
- var fs3__default = /*#__PURE__*/_interopDefault(fs3);
27
- var os2__default = /*#__PURE__*/_interopDefault(os2);
24
+ var WebSocket__default = /*#__PURE__*/_interopDefault(WebSocket);
25
+ var path11__default = /*#__PURE__*/_interopDefault(path11);
26
+ var fs4__default = /*#__PURE__*/_interopDefault(fs4);
27
+ var os3__default = /*#__PURE__*/_interopDefault(os3);
28
28
  var readline__default = /*#__PURE__*/_interopDefault(readline);
29
29
 
30
30
  var DEFAULT_SERVER_URL = "wss://ama-production-a628.up.railway.app";
31
31
  var CLIENT_ID = "client_01K4Y8A67H544Z6J8A47E5GJ9A";
32
- var AMA_DIR = path9__default.default.join(os2__default.default.homedir(), ".amai");
33
- var CODE_DIR = path9__default.default.join(AMA_DIR, "code");
34
- var STORAGE_DIR = path9__default.default.join(AMA_DIR, "storage");
32
+ var AMA_DIR = path11__default.default.join(os3__default.default.homedir(), ".amai");
33
+ var CODE_DIR = path11__default.default.join(AMA_DIR, "code");
34
+ var STORAGE_DIR = path11__default.default.join(AMA_DIR, "storage");
35
35
 
36
36
  // src/lib/project-registry.ts
37
- var REGISTRY_FILE = path9__default.default.join(AMA_DIR, "projects.json");
37
+ var REGISTRY_FILE = path11__default.default.join(AMA_DIR, "projects.json");
38
38
  var ProjectRegistry = class {
39
39
  projects = /* @__PURE__ */ new Map();
40
40
  constructor() {
@@ -42,14 +42,14 @@ var ProjectRegistry = class {
42
42
  }
43
43
  load() {
44
44
  try {
45
- if (fs3__default.default.existsSync(REGISTRY_FILE)) {
46
- const data = fs3__default.default.readFileSync(REGISTRY_FILE, "utf8");
45
+ if (fs4__default.default.existsSync(REGISTRY_FILE)) {
46
+ const data = fs4__default.default.readFileSync(REGISTRY_FILE, "utf8");
47
47
  const parsed = JSON.parse(data);
48
48
  if (!Array.isArray(parsed)) {
49
49
  console.error("Invalid project registry format: expected array, got", typeof parsed);
50
50
  const backupFile = REGISTRY_FILE + ".backup." + Date.now();
51
- fs3__default.default.copyFileSync(REGISTRY_FILE, backupFile);
52
- fs3__default.default.unlinkSync(REGISTRY_FILE);
51
+ fs4__default.default.copyFileSync(REGISTRY_FILE, backupFile);
52
+ fs4__default.default.unlinkSync(REGISTRY_FILE);
53
53
  return;
54
54
  }
55
55
  const projects = parsed;
@@ -62,11 +62,11 @@ var ProjectRegistry = class {
62
62
  }
63
63
  } catch (error) {
64
64
  console.error("Failed to load project registry:", error);
65
- if (fs3__default.default.existsSync(REGISTRY_FILE)) {
65
+ if (fs4__default.default.existsSync(REGISTRY_FILE)) {
66
66
  try {
67
67
  const backupFile = REGISTRY_FILE + ".backup." + Date.now();
68
- fs3__default.default.copyFileSync(REGISTRY_FILE, backupFile);
69
- fs3__default.default.unlinkSync(REGISTRY_FILE);
68
+ fs4__default.default.copyFileSync(REGISTRY_FILE, backupFile);
69
+ fs4__default.default.unlinkSync(REGISTRY_FILE);
70
70
  console.log("Corrupted registry file backed up and removed. Starting fresh.");
71
71
  } catch (backupError) {
72
72
  }
@@ -75,21 +75,21 @@ var ProjectRegistry = class {
75
75
  }
76
76
  save() {
77
77
  try {
78
- if (!fs3__default.default.existsSync(AMA_DIR)) {
79
- fs3__default.default.mkdirSync(AMA_DIR, { recursive: true });
78
+ if (!fs4__default.default.existsSync(AMA_DIR)) {
79
+ fs4__default.default.mkdirSync(AMA_DIR, { recursive: true });
80
80
  }
81
81
  const projects = Array.from(this.projects.values());
82
- fs3__default.default.writeFileSync(REGISTRY_FILE, JSON.stringify(projects, null, 2), "utf8");
82
+ fs4__default.default.writeFileSync(REGISTRY_FILE, JSON.stringify(projects, null, 2), "utf8");
83
83
  } catch (error) {
84
84
  console.error("Failed to save project registry:", error);
85
85
  }
86
86
  }
87
87
  register(projectId, cwd, name) {
88
- const normalizedCwd = path9__default.default.normalize(path9__default.default.resolve(cwd));
88
+ const normalizedCwd = path11__default.default.normalize(path11__default.default.resolve(cwd));
89
89
  this.projects.set(projectId, {
90
90
  id: projectId,
91
91
  cwd: normalizedCwd,
92
- name: name || path9__default.default.basename(normalizedCwd),
92
+ name: name || path11__default.default.basename(normalizedCwd),
93
93
  active: true
94
94
  });
95
95
  this.save();
@@ -119,9 +119,9 @@ var ProjectRegistry = class {
119
119
  var projectRegistry = new ProjectRegistry();
120
120
  function isPathWithinProject(filePath, projectCwd) {
121
121
  try {
122
- const resolved = path9__default.default.resolve(projectCwd, filePath);
123
- const normalized = path9__default.default.normalize(resolved);
124
- const normalizedCwd = path9__default.default.normalize(projectCwd);
122
+ const resolved = path11__default.default.resolve(projectCwd, filePath);
123
+ const normalized = path11__default.default.normalize(resolved);
124
+ const normalizedCwd = path11__default.default.normalize(projectCwd);
125
125
  return normalized.startsWith(normalizedCwd);
126
126
  } catch {
127
127
  return false;
@@ -137,7 +137,7 @@ function validatePath(filePath, projectCwd) {
137
137
  };
138
138
  }
139
139
  try {
140
- const resolvedPath = path9__default.default.resolve(projectCwd, filePath);
140
+ const resolvedPath = path11__default.default.resolve(projectCwd, filePath);
141
141
  if (!isPathWithinProject(filePath, projectCwd)) {
142
142
  return {
143
143
  valid: false,
@@ -156,7 +156,7 @@ function validatePath(filePath, projectCwd) {
156
156
  }
157
157
  }
158
158
  function resolveProjectPath(filePath, projectCwd) {
159
- return path9__default.default.resolve(projectCwd, filePath);
159
+ return path11__default.default.resolve(projectCwd, filePath);
160
160
  }
161
161
 
162
162
  // src/tools/read-file.ts
@@ -278,7 +278,7 @@ var read_file = async function(input, projectCwd) {
278
278
  };
279
279
  }
280
280
  } else {
281
- const absolute_file_path = path9__default.default.resolve(relative_file_path);
281
+ const absolute_file_path = path11__default.default.resolve(relative_file_path);
282
282
  try {
283
283
  const fileStats = await promises.stat(absolute_file_path);
284
284
  if (!fileStats.isFile()) {
@@ -872,20 +872,20 @@ var editFiles = async function(input, projectCwd) {
872
872
  }
873
873
  const basePath = projectCwd || process.cwd();
874
874
  const filePath = resolveProjectPath(target_file, basePath);
875
- const dirPath = path9__default.default.dirname(filePath);
875
+ const dirPath = path11__default.default.dirname(filePath);
876
876
  await promises.mkdir(dirPath, { recursive: true });
877
877
  let isNewFile = providedNewFile;
878
878
  let existingContent = "";
879
879
  if (isNewFile === void 0) {
880
880
  try {
881
- existingContent = await fs3__default.default.promises.readFile(filePath, "utf-8");
881
+ existingContent = await fs4__default.default.promises.readFile(filePath, "utf-8");
882
882
  isNewFile = false;
883
883
  } catch (error) {
884
884
  isNewFile = true;
885
885
  }
886
886
  } else if (!isNewFile) {
887
887
  try {
888
- existingContent = await fs3__default.default.promises.readFile(filePath, "utf-8");
888
+ existingContent = await fs4__default.default.promises.readFile(filePath, "utf-8");
889
889
  } catch (error) {
890
890
  isNewFile = true;
891
891
  }
@@ -898,7 +898,7 @@ var editFiles = async function(input, projectCwd) {
898
898
  content
899
899
  );
900
900
  try {
901
- await fs3__default.default.promises.writeFile(filePath, content);
901
+ await fs4__default.default.promises.writeFile(filePath, content);
902
902
  } catch (writeError) {
903
903
  checkpointStore.removeCheckpoint(checkpointId);
904
904
  throw writeError;
@@ -1022,7 +1022,7 @@ var grepTool = async function(input, projectCwd) {
1022
1022
  try {
1023
1023
  const { includePattern, excludePattern: excludePattern2, caseSensitive } = options || {};
1024
1024
  const searchDir = projectCwd || process.cwd();
1025
- if (projectCwd && !path9__default.default.isAbsolute(projectCwd)) {
1025
+ if (projectCwd && !path11__default.default.isAbsolute(projectCwd)) {
1026
1026
  return {
1027
1027
  success: false,
1028
1028
  message: "Invalid project directory",
@@ -1214,8 +1214,8 @@ var list = async function(input, projectCwd) {
1214
1214
  const walk = async (currentDir, depth) => {
1215
1215
  const entries = await promises.readdir(currentDir, { withFileTypes: true });
1216
1216
  for (const entry of entries) {
1217
- const entryAbsolutePath = path9__default.default.join(currentDir, entry.name);
1218
- const entryRelativePath = path9__default.default.relative(absolutePath, entryAbsolutePath) || ".";
1217
+ const entryAbsolutePath = path11__default.default.join(currentDir, entry.name);
1218
+ const entryRelativePath = path11__default.default.relative(absolutePath, entryAbsolutePath) || ".";
1219
1219
  if (entry.isDirectory()) {
1220
1220
  const isExcluded = entry.name.match(excludePattern);
1221
1221
  if (includeDirectoriesNormalized && matchPattern(entry.name) && !isExcluded) {
@@ -1265,203 +1265,9 @@ var list = async function(input, projectCwd) {
1265
1265
  };
1266
1266
  }
1267
1267
  };
1268
- var ignoreFiles = ["node_modules", ".git", ".next", ".env", ".env.local", ".env.development.local", ".env.test.local", ".env.production.local"];
1269
- var getContext = (dir, base = dir, allFiles = []) => {
1270
- const filePath = fs3.readdirSync(dir, { withFileTypes: true });
1271
- for (const file of filePath) {
1272
- if (ignoreFiles.includes(file.name)) continue;
1273
- const fullPath = path9__default.default.join(dir, file.name);
1274
- if (file.isDirectory()) {
1275
- getContext(fullPath, base, allFiles);
1276
- } else {
1277
- allFiles.push(path9__default.default.relative(base, fullPath));
1278
- }
1279
- }
1280
- return allFiles;
1281
- };
1282
- var HOME = os2__default.default.homedir();
1283
- var IDE_PROJECTS_PATHS = {
1284
- vscode: path9__default.default.join(HOME, ".vscode", "projects"),
1285
- cursor: path9__default.default.join(HOME, ".cursor", "projects"),
1286
- claude: path9__default.default.join(HOME, ".claude", "projects")
1287
- };
1288
- function getWorkspaceStoragePath(ide) {
1289
- const platform = os2__default.default.platform();
1290
- const appName = "Cursor" ;
1291
- if (platform === "darwin") {
1292
- return path9__default.default.join(HOME, "Library", "Application Support", appName, "User", "workspaceStorage");
1293
- } else if (platform === "win32") {
1294
- return path9__default.default.join(process.env.APPDATA || "", appName, "User", "workspaceStorage");
1295
- } else {
1296
- return path9__default.default.join(HOME, ".config", appName, "User", "workspaceStorage");
1297
- }
1298
- }
1299
- function scanWorkspaceStorage(ide) {
1300
- const projects = [];
1301
- const storagePath = getWorkspaceStoragePath();
1302
- if (!fs3__default.default.existsSync(storagePath)) {
1303
- return projects;
1304
- }
1305
- try {
1306
- const workspaces = fs3__default.default.readdirSync(storagePath);
1307
- for (const workspace of workspaces) {
1308
- const workspaceJsonPath = path9__default.default.join(storagePath, workspace, "workspace.json");
1309
- if (fs3__default.default.existsSync(workspaceJsonPath)) {
1310
- try {
1311
- const content = fs3__default.default.readFileSync(workspaceJsonPath, "utf-8");
1312
- const data = JSON.parse(content);
1313
- if (data.folder && typeof data.folder === "string") {
1314
- let projectPath = data.folder;
1315
- if (projectPath.startsWith("file://")) {
1316
- projectPath = projectPath.replace("file://", "");
1317
- projectPath = decodeURIComponent(projectPath);
1318
- }
1319
- if (fs3__default.default.existsSync(projectPath) && fs3__default.default.statSync(projectPath).isDirectory()) {
1320
- projects.push({
1321
- name: path9__default.default.basename(projectPath),
1322
- path: projectPath,
1323
- type: ide
1324
- });
1325
- }
1326
- }
1327
- } catch (err) {
1328
- console.debug(`Error reading workspace.json at ${workspaceJsonPath}: ${err}`);
1329
- }
1330
- }
1331
- }
1332
- } catch (err) {
1333
- console.debug(`Error scanning workspaceStorage for ${ide}: ${err}`);
1334
- }
1335
- return projects;
1336
- }
1337
- var scanIdeProjects = async () => {
1338
- try {
1339
- const allProjects = [];
1340
- const seenPaths = /* @__PURE__ */ new Set();
1341
- const addProject = (projectPath, ide) => {
1342
- try {
1343
- const resolvedPath = fs3__default.default.realpathSync(projectPath);
1344
- if (fs3__default.default.existsSync(resolvedPath) && fs3__default.default.statSync(resolvedPath).isDirectory() && !seenPaths.has(resolvedPath)) {
1345
- const isIdeProjectsDir = Object.values(IDE_PROJECTS_PATHS).some((ideDir) => {
1346
- try {
1347
- return fs3__default.default.realpathSync(ideDir) === resolvedPath;
1348
- } catch {
1349
- return false;
1350
- }
1351
- });
1352
- if (!isIdeProjectsDir) {
1353
- seenPaths.add(resolvedPath);
1354
- allProjects.push({
1355
- name: path9__default.default.basename(resolvedPath),
1356
- path: resolvedPath,
1357
- type: ide
1358
- });
1359
- }
1360
- }
1361
- } catch {
1362
- }
1363
- };
1364
- const cursorProjects = scanWorkspaceStorage("cursor");
1365
- for (const project of cursorProjects) {
1366
- addProject(project.path, "cursor");
1367
- }
1368
- for (const [ide, dirPath] of Object.entries(IDE_PROJECTS_PATHS)) {
1369
- if (ide === "cursor") continue;
1370
- if (fs3__default.default.existsSync(dirPath)) {
1371
- const projects = fs3__default.default.readdirSync(dirPath);
1372
- projects.forEach((project) => {
1373
- const projectPath = path9__default.default.join(dirPath, project);
1374
- try {
1375
- const stats = fs3__default.default.lstatSync(projectPath);
1376
- let actualPath = null;
1377
- if (stats.isSymbolicLink()) {
1378
- actualPath = fs3__default.default.realpathSync(projectPath);
1379
- } else if (stats.isFile()) {
1380
- try {
1381
- let content = fs3__default.default.readFileSync(projectPath, "utf-8").trim();
1382
- if (content.startsWith("~/") || content === "~") {
1383
- content = content.replace(/^~/, HOME);
1384
- }
1385
- const resolvedContent = path9__default.default.isAbsolute(content) ? content : path9__default.default.resolve(path9__default.default.dirname(projectPath), content);
1386
- if (fs3__default.default.existsSync(resolvedContent) && fs3__default.default.statSync(resolvedContent).isDirectory()) {
1387
- actualPath = fs3__default.default.realpathSync(resolvedContent);
1388
- }
1389
- } catch {
1390
- return;
1391
- }
1392
- } else if (stats.isDirectory()) {
1393
- actualPath = fs3__default.default.realpathSync(projectPath);
1394
- }
1395
- if (actualPath) {
1396
- addProject(actualPath, ide);
1397
- }
1398
- } catch {
1399
- }
1400
- });
1401
- }
1402
- }
1403
- return allProjects;
1404
- } catch (error) {
1405
- console.debug(`Error scanning IDE projects: ${error}`);
1406
- return [];
1407
- }
1408
- };
1409
- var wsConnection = null;
1410
- var startHttpServer = (connection) => {
1411
- if (connection) {
1412
- wsConnection = connection;
1413
- }
1268
+ var startHttpServer = () => {
1414
1269
  const app = new hono.Hono();
1415
1270
  app.use(cors.cors());
1416
- app.post("/daemon/status", (c) => {
1417
- const status = wsConnection ? getConnectionStatus(wsConnection) : "closed";
1418
- return c.json({ connected: status === "open" });
1419
- });
1420
- app.get("/daemon/status/stream", (c) => {
1421
- const encoder = new TextEncoder();
1422
- const stream = new ReadableStream({
1423
- start(controller) {
1424
- const initialStatus = wsConnection ? getConnectionStatus(wsConnection) : "closed";
1425
- controller.enqueue(encoder.encode(`data: ${JSON.stringify({ connected: initialStatus === "open" })}
1426
-
1427
- `));
1428
- const heartbeatInterval = setInterval(() => {
1429
- try {
1430
- const currentStatus = wsConnection ? getConnectionStatus(wsConnection) : "closed";
1431
- controller.enqueue(encoder.encode(`data: ${JSON.stringify({ connected: currentStatus === "open" })}
1432
-
1433
- `));
1434
- } catch {
1435
- }
1436
- }, 15e3);
1437
- c.req.raw.signal.addEventListener("abort", () => {
1438
- clearInterval(heartbeatInterval);
1439
- });
1440
- }
1441
- });
1442
- return new Response(stream, {
1443
- headers: {
1444
- "Content-Type": "text/event-stream",
1445
- "Cache-Control": "no-cache",
1446
- "Connection": "keep-alive"
1447
- }
1448
- });
1449
- });
1450
- app.get("context", async (c) => {
1451
- const context = getContext(process.cwd());
1452
- return c.body(JSON.stringify(context));
1453
- });
1454
- app.get("/ide-projects", async (c) => {
1455
- try {
1456
- const projects = await scanIdeProjects();
1457
- if (!projects) {
1458
- return c.json({ error: "No projects found" }, 500);
1459
- }
1460
- return c.json({ projects });
1461
- } catch (error) {
1462
- return c.json({ error: "Failed to scan IDE projects" }, 500);
1463
- }
1464
- });
1465
1271
  app.post("/projects/register", async (c) => {
1466
1272
  try {
1467
1273
  const { projectId, cwd, name } = await c.req.json();
@@ -1490,14 +1296,14 @@ var startHttpServer = (connection) => {
1490
1296
  }
1491
1297
  let resolved;
1492
1298
  if (projectCwd) {
1493
- resolved = path9__default.default.isAbsolute(filePath) ? filePath : path9__default.default.resolve(projectCwd, filePath);
1494
- const normalizedResolved = path9__default.default.normalize(resolved);
1495
- const normalizedCwd = path9__default.default.normalize(projectCwd);
1299
+ resolved = path11__default.default.isAbsolute(filePath) ? filePath : path11__default.default.resolve(projectCwd, filePath);
1300
+ const normalizedResolved = path11__default.default.normalize(resolved);
1301
+ const normalizedCwd = path11__default.default.normalize(projectCwd);
1496
1302
  if (!normalizedResolved.startsWith(normalizedCwd)) {
1497
1303
  return c.json({ error: "Path is outside project directory" }, 403);
1498
1304
  }
1499
1305
  } else {
1500
- resolved = path9__default.default.isAbsolute(filePath) ? filePath : path9__default.default.join(process.cwd(), filePath);
1306
+ resolved = path11__default.default.isAbsolute(filePath) ? filePath : path11__default.default.join(process.cwd(), filePath);
1501
1307
  }
1502
1308
  let currentContent;
1503
1309
  try {
@@ -1584,9 +1390,9 @@ var startHttpServer = (connection) => {
1584
1390
  }
1585
1391
  let resolved;
1586
1392
  if (projectCwd) {
1587
- resolved = path9__default.default.isAbsolute(filePath || checkpoint.filePath) ? filePath || checkpoint.filePath : path9__default.default.resolve(projectCwd, filePath || checkpoint.filePath);
1588
- const normalizedResolved = path9__default.default.normalize(resolved);
1589
- const normalizedCwd = path9__default.default.normalize(projectCwd);
1393
+ resolved = path11__default.default.isAbsolute(filePath || checkpoint.filePath) ? filePath || checkpoint.filePath : path11__default.default.resolve(projectCwd, filePath || checkpoint.filePath);
1394
+ const normalizedResolved = path11__default.default.normalize(resolved);
1395
+ const normalizedCwd = path11__default.default.normalize(projectCwd);
1590
1396
  if (!normalizedResolved.startsWith(normalizedCwd)) {
1591
1397
  return c.json({ error: "Path is outside project directory" }, 403);
1592
1398
  }
@@ -1649,14 +1455,14 @@ var startHttpServer = (connection) => {
1649
1455
  nodeServer.serve({ fetch: app.fetch, port: 3456 });
1650
1456
  };
1651
1457
  var sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
1652
- var CREDENTIALS_DIR = path9__default.default.join(os2__default.default.homedir(), ".amai");
1653
- var CREDENTIALS_PATH = path9__default.default.join(CREDENTIALS_DIR, "credentials.json");
1458
+ var CREDENTIALS_DIR = path11__default.default.join(os3__default.default.homedir(), ".amai");
1459
+ var CREDENTIALS_PATH = path11__default.default.join(CREDENTIALS_DIR, "credentials.json");
1654
1460
  function isAuthenticated() {
1655
1461
  try {
1656
- if (!fs3__default.default.existsSync(CREDENTIALS_PATH)) {
1462
+ if (!fs4__default.default.existsSync(CREDENTIALS_PATH)) {
1657
1463
  return false;
1658
1464
  }
1659
- const raw = fs3__default.default.readFileSync(CREDENTIALS_PATH, "utf8");
1465
+ const raw = fs4__default.default.readFileSync(CREDENTIALS_PATH, "utf8");
1660
1466
  const data = JSON.parse(raw);
1661
1467
  return Boolean(data && data.access_token);
1662
1468
  } catch {
@@ -1665,10 +1471,10 @@ function isAuthenticated() {
1665
1471
  }
1666
1472
  function saveTokens(tokens) {
1667
1473
  try {
1668
- if (!fs3__default.default.existsSync(CREDENTIALS_DIR)) {
1669
- fs3__default.default.mkdirSync(CREDENTIALS_DIR, { recursive: true });
1474
+ if (!fs4__default.default.existsSync(CREDENTIALS_DIR)) {
1475
+ fs4__default.default.mkdirSync(CREDENTIALS_DIR, { recursive: true });
1670
1476
  }
1671
- fs3__default.default.writeFileSync(
1477
+ fs4__default.default.writeFileSync(
1672
1478
  CREDENTIALS_PATH,
1673
1479
  JSON.stringify(tokens, null, 2),
1674
1480
  "utf8"
@@ -1679,18 +1485,18 @@ function saveTokens(tokens) {
1679
1485
  }
1680
1486
  function logout() {
1681
1487
  try {
1682
- if (fs3__default.default.existsSync(CREDENTIALS_PATH)) {
1683
- fs3__default.default.unlinkSync(CREDENTIALS_PATH);
1488
+ if (fs4__default.default.existsSync(CREDENTIALS_PATH)) {
1489
+ fs4__default.default.unlinkSync(CREDENTIALS_PATH);
1684
1490
  }
1685
1491
  } catch (error) {
1686
1492
  console.error(pc5__default.default.red("Failed to logout"), error);
1687
1493
  }
1688
1494
  }
1689
1495
  function getTokens() {
1690
- if (!fs3__default.default.existsSync(CREDENTIALS_PATH)) {
1496
+ if (!fs4__default.default.existsSync(CREDENTIALS_PATH)) {
1691
1497
  return null;
1692
1498
  }
1693
- const raw = fs3__default.default.readFileSync(CREDENTIALS_PATH, "utf8");
1499
+ const raw = fs4__default.default.readFileSync(CREDENTIALS_PATH, "utf8");
1694
1500
  const data = JSON.parse(raw);
1695
1501
  return data;
1696
1502
  }
@@ -1800,10 +1606,10 @@ async function login() {
1800
1606
  }
1801
1607
  var getUserId = () => {
1802
1608
  try {
1803
- if (!fs3__default.default.existsSync(CREDENTIALS_PATH)) {
1609
+ if (!fs4__default.default.existsSync(CREDENTIALS_PATH)) {
1804
1610
  return;
1805
1611
  }
1806
- const raw = fs3__default.default.readFileSync(CREDENTIALS_PATH, "utf8");
1612
+ const raw = fs4__default.default.readFileSync(CREDENTIALS_PATH, "utf8");
1807
1613
  const data = JSON.parse(raw);
1808
1614
  return {
1809
1615
  userId: data.user.id
@@ -1899,6 +1705,147 @@ var runTerminalCommand = async (input, projectCwd) => {
1899
1705
  };
1900
1706
  }
1901
1707
  };
1708
+ var ignoreFiles = ["node_modules", ".git", ".next", ".env", ".env.local", ".env.development.local", ".env.test.local", ".env.production.local"];
1709
+ var getContext = (dir, base = dir, allFiles = []) => {
1710
+ const filePath = fs4.readdirSync(dir, { withFileTypes: true });
1711
+ for (const file of filePath) {
1712
+ if (ignoreFiles.includes(file.name)) continue;
1713
+ const fullPath = path11__default.default.join(dir, file.name);
1714
+ if (file.isDirectory()) {
1715
+ getContext(fullPath, base, allFiles);
1716
+ } else {
1717
+ allFiles.push(path11__default.default.relative(base, fullPath));
1718
+ }
1719
+ }
1720
+ return allFiles;
1721
+ };
1722
+ var HOME = os3__default.default.homedir();
1723
+ var IDE_PROJECTS_PATHS = {
1724
+ vscode: path11__default.default.join(HOME, ".vscode", "projects"),
1725
+ cursor: path11__default.default.join(HOME, ".cursor", "projects"),
1726
+ claude: path11__default.default.join(HOME, ".claude", "projects")
1727
+ };
1728
+ function getWorkspaceStoragePath(ide) {
1729
+ const platform = os3__default.default.platform();
1730
+ const appName = "Cursor" ;
1731
+ if (platform === "darwin") {
1732
+ return path11__default.default.join(HOME, "Library", "Application Support", appName, "User", "workspaceStorage");
1733
+ } else if (platform === "win32") {
1734
+ return path11__default.default.join(process.env.APPDATA || "", appName, "User", "workspaceStorage");
1735
+ } else {
1736
+ return path11__default.default.join(HOME, ".config", appName, "User", "workspaceStorage");
1737
+ }
1738
+ }
1739
+ function scanWorkspaceStorage(ide) {
1740
+ const projects = [];
1741
+ const storagePath = getWorkspaceStoragePath();
1742
+ if (!fs4__default.default.existsSync(storagePath)) {
1743
+ return projects;
1744
+ }
1745
+ try {
1746
+ const workspaces = fs4__default.default.readdirSync(storagePath);
1747
+ for (const workspace of workspaces) {
1748
+ const workspaceJsonPath = path11__default.default.join(storagePath, workspace, "workspace.json");
1749
+ if (fs4__default.default.existsSync(workspaceJsonPath)) {
1750
+ try {
1751
+ const content = fs4__default.default.readFileSync(workspaceJsonPath, "utf-8");
1752
+ const data = JSON.parse(content);
1753
+ if (data.folder && typeof data.folder === "string") {
1754
+ let projectPath = data.folder;
1755
+ if (projectPath.startsWith("file://")) {
1756
+ projectPath = projectPath.replace("file://", "");
1757
+ projectPath = decodeURIComponent(projectPath);
1758
+ }
1759
+ if (fs4__default.default.existsSync(projectPath) && fs4__default.default.statSync(projectPath).isDirectory()) {
1760
+ projects.push({
1761
+ name: path11__default.default.basename(projectPath),
1762
+ path: projectPath,
1763
+ type: ide
1764
+ });
1765
+ }
1766
+ }
1767
+ } catch (err) {
1768
+ console.debug(`Error reading workspace.json at ${workspaceJsonPath}: ${err}`);
1769
+ }
1770
+ }
1771
+ }
1772
+ } catch (err) {
1773
+ console.debug(`Error scanning workspaceStorage for ${ide}: ${err}`);
1774
+ }
1775
+ return projects;
1776
+ }
1777
+ var scanIdeProjects = async () => {
1778
+ try {
1779
+ const allProjects = [];
1780
+ const seenPaths = /* @__PURE__ */ new Set();
1781
+ const addProject = (projectPath, ide) => {
1782
+ try {
1783
+ const resolvedPath = fs4__default.default.realpathSync(projectPath);
1784
+ if (fs4__default.default.existsSync(resolvedPath) && fs4__default.default.statSync(resolvedPath).isDirectory() && !seenPaths.has(resolvedPath)) {
1785
+ const isIdeProjectsDir = Object.values(IDE_PROJECTS_PATHS).some((ideDir) => {
1786
+ try {
1787
+ return fs4__default.default.realpathSync(ideDir) === resolvedPath;
1788
+ } catch {
1789
+ return false;
1790
+ }
1791
+ });
1792
+ if (!isIdeProjectsDir) {
1793
+ seenPaths.add(resolvedPath);
1794
+ allProjects.push({
1795
+ name: path11__default.default.basename(resolvedPath),
1796
+ path: resolvedPath,
1797
+ type: ide
1798
+ });
1799
+ }
1800
+ }
1801
+ } catch {
1802
+ }
1803
+ };
1804
+ const cursorProjects = scanWorkspaceStorage("cursor");
1805
+ for (const project of cursorProjects) {
1806
+ addProject(project.path, "cursor");
1807
+ }
1808
+ for (const [ide, dirPath] of Object.entries(IDE_PROJECTS_PATHS)) {
1809
+ if (ide === "cursor") continue;
1810
+ if (fs4__default.default.existsSync(dirPath)) {
1811
+ const projects = fs4__default.default.readdirSync(dirPath);
1812
+ projects.forEach((project) => {
1813
+ const projectPath = path11__default.default.join(dirPath, project);
1814
+ try {
1815
+ const stats = fs4__default.default.lstatSync(projectPath);
1816
+ let actualPath = null;
1817
+ if (stats.isSymbolicLink()) {
1818
+ actualPath = fs4__default.default.realpathSync(projectPath);
1819
+ } else if (stats.isFile()) {
1820
+ try {
1821
+ let content = fs4__default.default.readFileSync(projectPath, "utf-8").trim();
1822
+ if (content.startsWith("~/") || content === "~") {
1823
+ content = content.replace(/^~/, HOME);
1824
+ }
1825
+ const resolvedContent = path11__default.default.isAbsolute(content) ? content : path11__default.default.resolve(path11__default.default.dirname(projectPath), content);
1826
+ if (fs4__default.default.existsSync(resolvedContent) && fs4__default.default.statSync(resolvedContent).isDirectory()) {
1827
+ actualPath = fs4__default.default.realpathSync(resolvedContent);
1828
+ }
1829
+ } catch {
1830
+ return;
1831
+ }
1832
+ } else if (stats.isDirectory()) {
1833
+ actualPath = fs4__default.default.realpathSync(projectPath);
1834
+ }
1835
+ if (actualPath) {
1836
+ addProject(actualPath, ide);
1837
+ }
1838
+ } catch {
1839
+ }
1840
+ });
1841
+ }
1842
+ }
1843
+ return allProjects;
1844
+ } catch (error) {
1845
+ console.debug(`Error scanning IDE projects: ${error}`);
1846
+ return [];
1847
+ }
1848
+ };
1902
1849
 
1903
1850
  // src/lib/rpc-handlers.ts
1904
1851
  var rpcHandlers = {
@@ -2008,7 +1955,7 @@ var connectToUserStreams = async (serverUrl) => {
2008
1955
  throw new Error("No tokens found");
2009
1956
  }
2010
1957
  const wsUrl = `${serverUrl}/api/v1/user-streams?${params.toString()}`;
2011
- const ws = new WebSocket2__default.default(wsUrl, {
1958
+ const ws = new WebSocket__default.default(wsUrl, {
2012
1959
  headers: {
2013
1960
  Authorization: `Bearer ${tokens.access_token}`
2014
1961
  }
@@ -2105,16 +2052,13 @@ var toolExecutors = {
2105
2052
  stringReplace: apply_patch,
2106
2053
  runTerminalCommand
2107
2054
  };
2108
- function getConnectionStatus(ws) {
2109
- return ws.readyState === WebSocket2__default.default.CONNECTING ? "connecting" : ws.readyState === WebSocket2__default.default.OPEN ? "open" : ws.readyState === WebSocket2__default.default.CLOSING ? "closing" : "closed";
2110
- }
2111
- function connectToServer2(serverUrl = DEFAULT_SERVER_URL) {
2055
+ function connectToServer(serverUrl = DEFAULT_SERVER_URL) {
2112
2056
  const tokens = getTokens();
2113
2057
  if (!tokens) {
2114
2058
  throw new Error("No tokens found");
2115
2059
  }
2116
2060
  const wsUrl = `${serverUrl}/agent-streams`;
2117
- const ws = new WebSocket2__default.default(wsUrl, {
2061
+ const ws = new WebSocket__default.default(wsUrl, {
2118
2062
  headers: {
2119
2063
  "Authorization": `Bearer ${tokens.access_token}`
2120
2064
  }
@@ -2150,7 +2094,7 @@ function connectToServer2(serverUrl = DEFAULT_SERVER_URL) {
2150
2094
  });
2151
2095
  ws.on("close", () => {
2152
2096
  console.log(pc5__default.default.red("Disconnected from server. Reconnecting in 5s..."));
2153
- setTimeout(() => connectToServer2(serverUrl), 5e3);
2097
+ setTimeout(() => connectToServer(serverUrl), 5e3);
2154
2098
  });
2155
2099
  ws.on("error", (error) => {
2156
2100
  console.error(pc5__default.default.red(`WebSocket error: ${error.message}`));
@@ -2161,9 +2105,9 @@ async function main() {
2161
2105
  const serverUrl = DEFAULT_SERVER_URL;
2162
2106
  console.log(pc5__default.default.green("Starting local amai..."));
2163
2107
  console.log(pc5__default.default.gray(`Connecting to server at ${serverUrl}`));
2164
- const connection = connectToServer2(serverUrl);
2108
+ connectToServer(serverUrl);
2165
2109
  await connectToUserStreams(serverUrl);
2166
- startHttpServer(connection);
2110
+ startHttpServer();
2167
2111
  }
2168
2112
  var execAsync2 = util.promisify(child_process.exec);
2169
2113
  var CODE_SERVER_VERSION = "4.96.4";
@@ -2192,27 +2136,27 @@ function getDownloadUrl() {
2192
2136
  }
2193
2137
  function getCodeServerDir() {
2194
2138
  const { platform, arch } = getPlatformInfo();
2195
- return path9__default.default.join(CODE_DIR, `code-server-${CODE_SERVER_VERSION}-${platform}-${arch}`);
2139
+ return path11__default.default.join(CODE_DIR, `code-server-${CODE_SERVER_VERSION}-${platform}-${arch}`);
2196
2140
  }
2197
2141
  function getCodeServerBin() {
2198
- return path9__default.default.join(getCodeServerDir(), "bin", "code-server");
2142
+ return path11__default.default.join(getCodeServerDir(), "bin", "code-server");
2199
2143
  }
2200
2144
  function isCodeServerInstalled() {
2201
2145
  const binPath = getCodeServerBin();
2202
- return fs3__default.default.existsSync(binPath);
2146
+ return fs4__default.default.existsSync(binPath);
2203
2147
  }
2204
2148
  async function installCodeServer() {
2205
2149
  const { ext } = getPlatformInfo();
2206
2150
  const downloadUrl = getDownloadUrl();
2207
- const tarballPath = path9__default.default.join(AMA_DIR, `code-server.${ext}`);
2208
- if (!fs3__default.default.existsSync(AMA_DIR)) {
2209
- fs3__default.default.mkdirSync(AMA_DIR, { recursive: true });
2151
+ const tarballPath = path11__default.default.join(AMA_DIR, `code-server.${ext}`);
2152
+ if (!fs4__default.default.existsSync(AMA_DIR)) {
2153
+ fs4__default.default.mkdirSync(AMA_DIR, { recursive: true });
2210
2154
  }
2211
- if (!fs3__default.default.existsSync(CODE_DIR)) {
2212
- fs3__default.default.mkdirSync(CODE_DIR, { recursive: true });
2155
+ if (!fs4__default.default.existsSync(CODE_DIR)) {
2156
+ fs4__default.default.mkdirSync(CODE_DIR, { recursive: true });
2213
2157
  }
2214
- if (!fs3__default.default.existsSync(STORAGE_DIR)) {
2215
- fs3__default.default.mkdirSync(STORAGE_DIR, { recursive: true });
2158
+ if (!fs4__default.default.existsSync(STORAGE_DIR)) {
2159
+ fs4__default.default.mkdirSync(STORAGE_DIR, { recursive: true });
2216
2160
  }
2217
2161
  console.log(pc5__default.default.cyan(`Downloading code-server v${CODE_SERVER_VERSION}...`));
2218
2162
  console.log(pc5__default.default.gray(downloadUrl));
@@ -2221,13 +2165,13 @@ async function installCodeServer() {
2221
2165
  throw new Error(`Failed to download code-server: ${response.statusText}`);
2222
2166
  }
2223
2167
  const buffer = await response.arrayBuffer();
2224
- await fs3__default.default.promises.writeFile(tarballPath, Buffer.from(buffer));
2168
+ await fs4__default.default.promises.writeFile(tarballPath, Buffer.from(buffer));
2225
2169
  console.log(pc5__default.default.cyan("Extracting code-server..."));
2226
2170
  await execAsync2(`tar -xzf ${tarballPath} -C ${CODE_DIR}`);
2227
- await fs3__default.default.promises.unlink(tarballPath);
2171
+ await fs4__default.default.promises.unlink(tarballPath);
2228
2172
  const binPath = getCodeServerBin();
2229
- if (fs3__default.default.existsSync(binPath)) {
2230
- await fs3__default.default.promises.chmod(binPath, 493);
2173
+ if (fs4__default.default.existsSync(binPath)) {
2174
+ await fs4__default.default.promises.chmod(binPath, 493);
2231
2175
  }
2232
2176
  console.log(pc5__default.default.green("\u2713 code-server installed successfully"));
2233
2177
  }
@@ -2252,19 +2196,19 @@ async function killExistingCodeServer() {
2252
2196
  async function startCodeServer(cwd) {
2253
2197
  const binPath = getCodeServerBin();
2254
2198
  const workDir = cwd || process.cwd();
2255
- if (!fs3__default.default.existsSync(binPath)) {
2199
+ if (!fs4__default.default.existsSync(binPath)) {
2256
2200
  throw new Error("code-server is not installed. Run installCodeServer() first.");
2257
2201
  }
2258
2202
  await killExistingCodeServer();
2259
- const workspaceStoragePath = path9__default.default.join(STORAGE_DIR, "User", "workspaceStorage");
2260
- path9__default.default.join(STORAGE_DIR, "User", "globalStorage");
2203
+ const workspaceStoragePath = path11__default.default.join(STORAGE_DIR, "User", "workspaceStorage");
2204
+ path11__default.default.join(STORAGE_DIR, "User", "globalStorage");
2261
2205
  try {
2262
- if (fs3__default.default.existsSync(workspaceStoragePath)) {
2263
- await fs3__default.default.promises.rm(workspaceStoragePath, { recursive: true, force: true });
2206
+ if (fs4__default.default.existsSync(workspaceStoragePath)) {
2207
+ await fs4__default.default.promises.rm(workspaceStoragePath, { recursive: true, force: true });
2264
2208
  }
2265
- const stateDbPath = path9__default.default.join(STORAGE_DIR, "User", "globalStorage", "state.vscdb");
2266
- if (fs3__default.default.existsSync(stateDbPath)) {
2267
- await fs3__default.default.promises.unlink(stateDbPath);
2209
+ const stateDbPath = path11__default.default.join(STORAGE_DIR, "User", "globalStorage", "state.vscdb");
2210
+ if (fs4__default.default.existsSync(stateDbPath)) {
2211
+ await fs4__default.default.promises.unlink(stateDbPath);
2268
2212
  }
2269
2213
  } catch {
2270
2214
  }
@@ -2291,15 +2235,15 @@ async function startCodeServer(cwd) {
2291
2235
  return codeServer;
2292
2236
  }
2293
2237
  var __filename$1 = url.fileURLToPath((typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('cli.cjs', document.baseURI).href)));
2294
- var __dirname$1 = path9.dirname(__filename$1);
2295
- var DAEMON_PID_FILE = path9__default.default.join(AMA_DIR, "daemon.pid");
2296
- var DAEMON_LOG_FILE = path9__default.default.join(AMA_DIR, "daemon.log");
2238
+ var __dirname$1 = path11.dirname(__filename$1);
2239
+ var DAEMON_PID_FILE = path11__default.default.join(AMA_DIR, "daemon.pid");
2240
+ var DAEMON_LOG_FILE = path11__default.default.join(AMA_DIR, "daemon.log");
2297
2241
  function isDaemonRunning() {
2298
- if (!fs3__default.default.existsSync(DAEMON_PID_FILE)) {
2242
+ if (!fs4__default.default.existsSync(DAEMON_PID_FILE)) {
2299
2243
  return false;
2300
2244
  }
2301
2245
  try {
2302
- const pid = Number(fs3__default.default.readFileSync(DAEMON_PID_FILE, "utf8"));
2246
+ const pid = Number(fs4__default.default.readFileSync(DAEMON_PID_FILE, "utf8"));
2303
2247
  process.kill(pid, 0);
2304
2248
  return true;
2305
2249
  } catch {
@@ -2307,30 +2251,30 @@ function isDaemonRunning() {
2307
2251
  }
2308
2252
  }
2309
2253
  function stopDaemon() {
2310
- if (!fs3__default.default.existsSync(DAEMON_PID_FILE)) {
2254
+ if (!fs4__default.default.existsSync(DAEMON_PID_FILE)) {
2311
2255
  return false;
2312
2256
  }
2313
2257
  try {
2314
- const pid = Number(fs3__default.default.readFileSync(DAEMON_PID_FILE, "utf8"));
2258
+ const pid = Number(fs4__default.default.readFileSync(DAEMON_PID_FILE, "utf8"));
2315
2259
  process.kill(pid, "SIGTERM");
2316
- fs3__default.default.unlinkSync(DAEMON_PID_FILE);
2260
+ fs4__default.default.unlinkSync(DAEMON_PID_FILE);
2317
2261
  return true;
2318
2262
  } catch (error) {
2319
2263
  return false;
2320
2264
  }
2321
2265
  }
2322
2266
  function startDaemon() {
2323
- if (!fs3__default.default.existsSync(AMA_DIR)) {
2324
- fs3__default.default.mkdirSync(AMA_DIR, { recursive: true });
2267
+ if (!fs4__default.default.existsSync(AMA_DIR)) {
2268
+ fs4__default.default.mkdirSync(AMA_DIR, { recursive: true });
2325
2269
  }
2326
2270
  if (isDaemonRunning()) {
2327
2271
  stopDaemon();
2328
2272
  }
2329
- const daemonScript = path9__default.default.join(__dirname$1, "lib", "daemon-entry.js");
2330
- if (!fs3__default.default.existsSync(daemonScript)) {
2273
+ const daemonScript = path11__default.default.join(__dirname$1, "lib", "daemon-entry.js");
2274
+ if (!fs4__default.default.existsSync(daemonScript)) {
2331
2275
  throw new Error(`Daemon entry script not found at: ${daemonScript}. Please rebuild the project.`);
2332
2276
  }
2333
- const logFd = fs3__default.default.openSync(DAEMON_LOG_FILE, "a");
2277
+ const logFd = fs4__default.default.openSync(DAEMON_LOG_FILE, "a");
2334
2278
  const daemon = child_process.spawn(process.execPath, [daemonScript], {
2335
2279
  detached: true,
2336
2280
  stdio: ["ignore", logFd, logFd],
@@ -2338,20 +2282,20 @@ function startDaemon() {
2338
2282
  cwd: process.cwd()
2339
2283
  });
2340
2284
  daemon.unref();
2341
- fs3__default.default.writeFileSync(DAEMON_PID_FILE, String(daemon.pid));
2342
- fs3__default.default.closeSync(logFd);
2285
+ fs4__default.default.writeFileSync(DAEMON_PID_FILE, String(daemon.pid));
2286
+ fs4__default.default.closeSync(logFd);
2343
2287
  }
2344
2288
  function getDaemonPid() {
2345
- if (!fs3__default.default.existsSync(DAEMON_PID_FILE)) {
2289
+ if (!fs4__default.default.existsSync(DAEMON_PID_FILE)) {
2346
2290
  return null;
2347
2291
  }
2348
2292
  try {
2349
- return Number(fs3__default.default.readFileSync(DAEMON_PID_FILE, "utf8"));
2293
+ return Number(fs4__default.default.readFileSync(DAEMON_PID_FILE, "utf8"));
2350
2294
  } catch {
2351
2295
  return null;
2352
2296
  }
2353
2297
  }
2354
- var VERSION = "0.0.6";
2298
+ var VERSION = "0.0.7";
2355
2299
  var PROJECT_DIR = process.cwd();
2356
2300
  function promptUser(question) {
2357
2301
  const rl = readline__default.default.createInterface({
@@ -2462,16 +2406,16 @@ if (args[0] === "project") {
2462
2406
  console.log("Usage: amai project add <path>");
2463
2407
  process.exit(1);
2464
2408
  }
2465
- const resolvedPath = path9__default.default.resolve(projectPath);
2466
- if (!fs3__default.default.existsSync(resolvedPath)) {
2409
+ const resolvedPath = path11__default.default.resolve(projectPath);
2410
+ if (!fs4__default.default.existsSync(resolvedPath)) {
2467
2411
  console.error(pc5__default.default.red(`Path does not exist: ${resolvedPath}`));
2468
2412
  process.exit(1);
2469
2413
  }
2470
- if (!fs3__default.default.statSync(resolvedPath).isDirectory()) {
2414
+ if (!fs4__default.default.statSync(resolvedPath).isDirectory()) {
2471
2415
  console.error(pc5__default.default.red(`Path is not a directory: ${resolvedPath}`));
2472
2416
  process.exit(1);
2473
2417
  }
2474
- const projectId = path9__default.default.basename(resolvedPath);
2418
+ const projectId = path11__default.default.basename(resolvedPath);
2475
2419
  projectRegistry.register(projectId, resolvedPath);
2476
2420
  console.log(pc5__default.default.green(`Project registered: ${projectId} -> ${resolvedPath}`));
2477
2421
  process.exit(0);