Function handle

src/tools/detect-circular-dependencies.ts:26–154

(
  args: Record<string, unknown>,
  ctx: ToolContext
)

};

export async function handle(
  args: Record<string, unknown>,
  ctx: ToolContext
): Promise<ToolResponse> {
  const { scope } = args as { scope?: string };

  try {
    // Try relationships sidecar first (preferred), then intelligence
    let graphDataSource: {
      imports?: Record<string, string[]>;
      exports?: Record<string, FileExport[]>;
    } | null = null;
    let graphStats: unknown = null;

    const relationshipsPath = path.join(
      path.dirname(ctx.paths.intelligence),
      RELATIONSHIPS_FILENAME
    );
    try {
      const relationshipsContent = await fs.readFile(relationshipsPath, 'utf-8');
      const relationships = JSON.parse(relationshipsContent);
      if (relationships?.graph) {
        graphDataSource = relationships.graph;
        graphStats = relationships.stats;
      }
    } catch {
      // Relationships sidecar not available, try intelligence
    }

    if (!graphDataSource) {
      const intelligencePath = ctx.paths.intelligence;
      const content = await fs.readFile(intelligencePath, 'utf-8');
      const intelligence = JSON.parse(content);
      if (intelligence.internalFileGraph) {
        graphDataSource = intelligence.internalFileGraph;
        graphStats = intelligence.internalFileGraph.stats;
      }
    }

    if (!graphDataSource) {
      return {
        content: [
          {
            type: 'text',
            text: JSON.stringify(
              {
                status: 'error',
                message:
                  'Internal file graph not found. Please run refresh_index to rebuild the index with cycle detection support.'
              },
              null,
              2
            )
          }
        ]
      };
    }