cueme 0.1.11 → 0.1.13

package/docs/how-to-submit-a-pr.md

@@ -0,0 +1,85 @@
+# How to submit a PR
+
+## 1. Prerequisites
+
+- Make sure you have write access to the repository (or submit a PR from a fork).
+- Use Node.js locally (recommended to match `package.json` `engines`).
+
+## 2. Update `main` and create a branch
+
+- Pull the latest `main`.
+- Create a new branch (recommended naming):
+  - `feature/<short-desc>`
+  - `fix/<short-desc>`
+  - `chore/<short-desc>`
+
+## 3. Development and local checks
+
+- Make your changes.
+- Run minimal local checks:
+  - `npm ci`
+  - `npm run prepare`
+  - Optional: run a quick manual validation relevant to your change.
+
+## 4. Commit conventions
+
+- Recommended commit message prefixes:
+  - `feat: ...`
+  - `fix: ...`
+  - `refactor: ...`
+  - `chore: ...`
+
+- Keep the PR focused: ideally one PR addresses one category of change.
+
+## 5. Push your branch and create a PR (recommended: gh)
+
+- Push your branch:
+  - `git push -u origin <your-branch>`
+
+- Create the PR:
+  - `gh pr create -R nmhjklnm/cue-command`
+
+- Suggested PR description:
+  - Why (motivation)
+  - What (changes)
+  - How to test
+  - Risks / impact
+
+## 6. CI and review
+
+- Ensure all PR checks pass (CI runs on PRs).
+- Address review feedback by pushing additional commits.
+
+## 7. Merge policy
+
+- This repository uses a ruleset: only `squash` / `rebase` merges are allowed.
+- Generally, **squash merge** is recommended to keep `main` history clean.
+
+## 8. Post-merge
+
+- After merging, confirm `main` CI runs and succeeds.
+- If a release is required, follow the repository release process.
+
+## 9. Common pitfalls
+
+- **CI did not run**
+  - Confirm your PR targets `main`, and check workflow triggers (`pull_request` / `push` branch filters).
+  - Use `gh pr checks <PR_NUMBER> -R nmhjklnm/cue-command` to see if checks are present.
+
+- **CI fails (works locally but fails in CI)**
+  - Prefer `npm ci` (depends on the lockfile) and keep `package-lock.json` in sync with `package.json`.
+  - Use `gh run view <RUN_ID> -R nmhjklnm/cue-command` to inspect the failing step.
+
+- **Merge button disabled / merge method rejected**
+  - The ruleset allows only `squash` / `rebase`; merge commits are not allowed.
+  - Selecting a disallowed merge method in the UI will be blocked by the rules.
+
+- **Conflicts / need to sync with `main`**
+  - Update your branch with the latest `main` (rebase or merge per team preference).
+  - After resolving conflicts, push again and CI will rerun.
+
+- **Useful gh commands**
+  - View PR: `gh pr view <PR_NUMBER> -R nmhjklnm/cue-command`
+  - View diff: `gh pr diff <PR_NUMBER> -R nmhjklnm/cue-command`
+  - View checks: `gh pr checks <PR_NUMBER> -R nmhjklnm/cue-command`
+  - List main runs: `gh run list -R nmhjklnm/cue-command --branch main`

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cueme",
-  "version": "0.1.11",
+  "version": "0.1.13",
   "description": "Cue command protocol adapter (stdin/stdout JSON)",
   "license": "Apache-2.0",
   "files": [

package/src/cli.js

@@ -1,7 +1,7 @@
 const { readAllStdin } = require('./io');
 const { handleCommand } = require('./handler');
 const { parseTagBlocksEnvelope } = require('./envelope');
-const { protoApply, protoInit, protoLs, protoPath, protoRender } = require('./proto');
+const { protoApply, protoRemove, protoInit, protoLs, protoPath, protoRender } = require('./proto');
 const pkg = require('../package.json');
 const fs = require('fs');
 const path = require('path');
@@ -99,10 +99,12 @@ async function main() {
         '  cueme -p|--protocol',
         '  cueme proto <agent>',
         '  cueme proto apply <agent>',
+        '  cueme proto rm|remove <agent>',
         '  cueme proto init',
         '  cueme proto ls',
         '  cueme proto path <agent>',
         '  cueme fix <issue>',
+        '  cueme migrate',
         '  cueme join <agent_runtime>',
         '  cueme cue <agent_id> -',
         '  cueme pause <agent_id> [prompt|-]',
@@ -257,6 +259,17 @@ async function main() {
         return;
       }
 
+      if (action === 'rm' || action === 'remove') {
+        const agent = pos[1];
+        if (!agent) {
+          process.stderr.write('error: missing <agent>\n');
+          process.exitCode = 2;
+          return;
+        }
+        process.stdout.write(protoRemove(String(agent)) + '\n');
+        return;
+      }
+
       if (action === 'path') {
         const agent = pos[1];
         if (!agent) {

package/src/db.js

@@ -112,7 +112,7 @@ async function initSchema(db) {
     const reqCount = reqCountRow ? Number(reqCountRow.n) : 0;
     const respCount = respCountRow ? Number(respCountRow.n) : 0;
     if (reqCount === 0 && respCount === 0) {
-      await run(db, 'INSERT INTO schema_meta (key, value) VALUES (?, ?)', ['schema_version', '2']);
+      await run(db, 'INSERT INTO schema_meta (key, value) VALUES (?, ?)', ['schema_version', '3']);
     }
   }
 }

package/src/handler.js

@@ -336,13 +336,41 @@ async function handlePause(db, { agent_id, prompt }) {
   });
 }
 
+async function handleMigrate(db) {
+  await initSchema(db);
+
+  await run(
+    db,
+    [
+      'CREATE TABLE IF NOT EXISTS conversation_pins (',
+      '  conv_type TEXT NOT NULL,',
+      '  conv_id TEXT NOT NULL,',
+      '  view TEXT NOT NULL,',
+      '  pin_order INTEGER PRIMARY KEY AUTOINCREMENT,',
+      '  pinned_at DATETIME DEFAULT CURRENT_TIMESTAMP,',
+      '  UNIQUE(conv_type, conv_id, view)',
+      ')',
+    ].join('\n')
+  );
+
+  await run(db, 'UPDATE schema_meta SET value = ? WHERE key = ?', ['3', 'schema_version']);
+  await run(db, 'INSERT OR IGNORE INTO schema_meta (key, value) VALUES (?, ?)', [
+    'schema_version',
+    '3',
+  ]);
+
+  return { ok: true, data: { message: 'migrated schema_version to 3' } };
+}
+
 async function handleCommand({ subcommand, args }) {
   const { db, dbPath } = openDb();
   try {
-    await initSchema(db);
-
     if (subcommand === 'join') return await handleJoin(db, args.agent_runtime);
 
+    if (subcommand === 'migrate') return await handleMigrate(db);
+
+    await initSchema(db);
+
     if (subcommand === 'cue') {
       const agent_id = (args.agent_id ?? '').toString();
       const prompt = (args.prompt ?? '').toString();

package/src/proto.js

@@ -91,6 +91,22 @@ function detectWindsurfCandidates({ platform }) {
   return candidates;
 }
 
+function detectKiroCandidates({ platform }) {
+  const candidates = [];
+  const home = os.homedir();
+  const userProfile = process.env.USERPROFILE || home;
+
+  // User-level only (no repo-local detection for Kiro)
+  // Kiro uses ~/.kiro/steering/ directory for global steering files
+  if (platform === 'macos') candidates.push(path.join(home, '.kiro', 'steering', 'cueme_proto.md'));
+  if (platform === 'linux') candidates.push(path.join(home, '.kiro', 'steering', 'cueme_proto.md'));
+  if (platform === 'windows') {
+    candidates.push(path.join(userProfile, '.kiro', 'steering', 'cueme_proto.md'));
+  }
+
+  return candidates;
+}
+
 function firstExistingPath(candidates) {
   for (const p of candidates) {
     if (typeof p === 'string' && p.trim().length > 0 && pathExists(p)) return p;
@@ -125,6 +141,11 @@ function defaultPathMapTemplate() {
   out['windows.windsurf'] = path.join(userProfile, '.codeium', 'windsurf', 'memories', 'global_rules.md');
   out['linux.windsurf'] = path.join(home, '.codeium', 'windsurf', 'memories', 'global_rules.md');
 
+  // Kiro
+  out['macos.kiro'] = path.join(home, '.kiro', 'steering', 'cueme_proto.md');
+  out['windows.kiro'] = path.join(userProfile, '.kiro', 'steering', 'cueme_proto.md');
+  out['linux.kiro'] = path.join(home, '.kiro', 'steering', 'cueme_proto.md');
+
   return out;
 }
 
@@ -135,6 +156,7 @@ function defaultConfigTemplate() {
     'cueme.proto.prefix': {
       windsurf: [],
       vscode: ['---', 'applyTo: "**"', '---'],
+      kiro: [],
     },
     'cueme.proto.protocol_path': protocolPath,
   };
@@ -144,9 +166,10 @@ function detectAndFillTemplatePaths(tpl) {
   const platform = getPlatformKey();
   const keyVscode = `${platform}.vscode`;
   const keyWindsurf = `${platform}.windsurf`;
+  const keyKiro = `${platform}.kiro`;
 
   const pathMap = tpl['cueme.proto.path'] || {};
-  const detected = { platform, vscode: '', windsurf: '' };
+  const detected = { platform, vscode: '', windsurf: '', kiro: '' };
 
   if (typeof pathMap !== 'object' || Array.isArray(pathMap)) {
     return { tpl, detected };
@@ -169,6 +192,14 @@ function detectAndFillTemplatePaths(tpl) {
     }
   }
 
+  if (typeof pathMap[keyKiro] !== 'string' || pathMap[keyKiro].trim().length === 0) {
+    const p = firstExistingPath(detectKiroCandidates({ platform }));
+    if (p) {
+      pathMap[keyKiro] = p;
+      detected.kiro = p;
+    }
+  }
+
   tpl['cueme.proto.path'] = pathMap;
   return { tpl, detected };
 }
@@ -368,15 +399,59 @@ function protoApply(agent) {
   return `ok: applied to ${targetPath}`;
 }
 
+function protoRemove(agent) {
+  const cfg = readConfigOrThrow({ auto_init: true });
+  const targetPath = resolveTargetPath({ cfg, agent });
+
+  let existing = '';
+  try {
+    existing = fs.readFileSync(targetPath, 'utf8');
+  } catch {
+    return `ok: file does not exist: ${targetPath}`;
+  }
+
+  const beginMatch = existing.match(BEGIN_MARKER_RE);
+  const endMatch = existing.match(END_MARKER_RE);
+
+  if (!beginMatch || !endMatch || endMatch.index <= beginMatch.index) {
+    return `ok: no managed block found in: ${targetPath}`;
+  }
+
+  const beginIdx = beginMatch.index;
+  const endIdx = endMatch.index;
+  const endLen = endMatch[0].length;
+
+  const before = existing.slice(0, beginIdx);
+  const after = existing.slice(endIdx + endLen);
+
+  const eol = detectEol(existing);
+  const afterTrim = after.startsWith(eol) ? after.slice(eol.length) : after;
+  const out = before + afterTrim;
+
+  if (out.trim().length === 0) {
+    try {
+      fs.unlinkSync(targetPath);
+      return `ok: removed managed block and deleted empty file: ${targetPath}`;
+    } catch (err) {
+      throw new Error(`error: failed to delete file after removing managed block: ${targetPath}: ${err.message}`);
+    }
+  }
+
+  fs.writeFileSync(targetPath, out, 'utf8');
+  return `ok: removed managed block from: ${targetPath}`;
+}
+
 function protoInit() {
   const { created, path: p, detected } = initConfigIfMissing();
   if (!created) return `ok: exists ${p}`;
   const platform = detected && detected.platform ? detected.platform : getPlatformKey();
   const keyVscode = `${platform}.vscode`;
   const keyWindsurf = `${platform}.windsurf`;
+  const keyKiro = `${platform}.kiro`;
   const vs = detected && detected.vscode ? 'detected' : 'empty';
   const ws = detected && detected.windsurf ? 'detected' : 'empty';
-  return `ok: initialized ${p} (auto-detect: ${keyVscode}=${vs}, ${keyWindsurf}=${ws})`;
+  const ks = detected && detected.kiro ? 'detected' : 'empty';
+  return `ok: initialized ${p} (auto-detect: ${keyVscode}=${vs}, ${keyWindsurf}=${ws}, ${keyKiro}=${ks})`;
 }
 
 module.exports = {
@@ -384,6 +459,7 @@ module.exports = {
   END_MARKER,
   getPlatformKey,
   protoApply,
+  protoRemove,
   protoInit,
   protoLs,
   protoPath,